更新openwrt，更新HCppBox

FW/openwrt-23.05/openwrt

@@ -1 +1 @@
-Subproject commit 16810687a28a40ba63c1bf131de5421a1af118c9
+Subproject commit b0834b0265351c7e617a7c6398ebd5af0268d5e7

FW/package/3rdparty/HCppBox/master/hbox/CMakeLists.txt

@@ -6,7 +6,7 @@ if(MSVC)
 endif()
 
 add_library(HBox EXCLUDE_FROM_ALL)
-file(GLOB  HBOX_C_CPP_FILES *.cpp *.hpp *.c *.h cpp/*.cpp cpp/*.hpp cpp/*.c cpp/*.h)
+file(GLOB  HBOX_C_CPP_FILES *.cpp *.hpp *.c *.h cpp/*.cpp cpp/*.hpp cpp/*.c cpp/*.h h3rdparty/*.cpp h3rdparty/*.hpp h3rdparty/*.c h3rdparty/*.h )
 target_sources(HBox PRIVATE ${HBOX_C_CPP_FILES})
 target_include_directories(HBox PUBLIC ./ )
 target_include_directories(HBox PUBLIC ./cpp/ )
@@ -24,6 +24,6 @@ target_compile_definitions(${targetname} PUBLIC  HBOX_ENABLE=1)
 endfunction()
 
 #添加dotfontscan工具构建
-add_custom_target(dotfontscan_tool 	${CMAKE_COMMAND} -E make_directory dotfontscan && ${CMAKE_COMMAND}  -S ${CMAKE_CURRENT_SOURCE_DIR}/gui/tools/dotfontscan/ -B dotfontscan && ${CMAKE_COMMAND} --build dotfontscan 
+add_custom_target(dotfontscan_tool 	${CMAKE_COMMAND} -E make_directory dotfontscan && ${CMAKE_COMMAND}  -S ${CMAKE_CURRENT_SOURCE_DIR}/hgui/tools/dotfontscan/ -B dotfontscan && ${CMAKE_COMMAND} --build dotfontscan 
 									WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/
 									USES_TERMINAL)

FW/package/3rdparty/HCppBox/master/hbox/SConscript

@@ -1,21 +1,21 @@
-from building import *
-import os
-import sys
-
-
-cwd = GetCurrentDir()
-src = Glob('*.c')
+from building import *
+import os
+import sys
+
+
+cwd = GetCurrentDir()
+src = Glob('*.c')
 src += Glob('*.cpp')
-CPPPATH = [
-cwd,
-cwd+'/cpp'
-]
-
-group = DefineGroup('HBox', src, depend = [''], CPPPATH = CPPPATH)
-
-list = os.listdir(cwd)
-for item in list:
-    if os.path.isfile(os.path.join(cwd, item, 'SConscript')):
-        group = group + SConscript(os.path.join(item, 'SConscript'))
-
-Return('group')
+CPPPATH = [
+cwd,
+cwd+'/cpp'
+]
+
+group = DefineGroup('HBox', src, depend = [''], CPPPATH = CPPPATH)
+
+list = os.listdir(cwd)
+for item in list:
+    if os.path.isfile(os.path.join(cwd, item, 'SConscript')):
+        group = group + SConscript(os.path.join(item, 'SConscript'))
+
+Return('group')

FW/package/3rdparty/HCppBox/master/hbox/cpp/hchain.h

@@ -12,7 +12,7 @@
 #ifdef __cplusplus
 
 #include "hcpprt.h"
-#include "heventchain.h"
+#include "hevent.h"
 
 
 template<class lock=hlock,class cmemory=hcmemory>

FW/package/3rdparty/HCppBox/master/hbox/cpp/hcpprt.cpp

@@ -10,7 +10,9 @@
 #include "hcompiler.h"
 #include "hdefaults.h"
 #include "h3rdparty.h"
-
+#include "hstacklesscoroutine.h"
+#include "hevent.h"
+#include "hruntime.h"
 
 
 /*
@@ -89,13 +91,55 @@ static void ctors_execute()
 void hcpprt_init()
 {
     /*
-     * 初始化第三方库
+     * C语言组件初始化(底层部分)
      */
-    h3rdparty_init();
+    hruntime_init_lowlevel();
+
+    /*
+     * 系统循环
+     */
+    {
+        heventslots_t *slots_loop=heventslots_get_slots_from_table(HEVENTSLOTS_SYSTEM_SLOTS_LOOP);
+        if(slots_loop==NULL)
+        {
+#ifndef HCPPRT_SYSTEM_LOOP_NO_AUTOINIT
+            heventslots_set_slots_to_table(HEVENTSLOTS_SYSTEM_SLOTS_LOOP,NULL);
+#endif // HCPPRT_SYSTEM_LOOP_NO_AUTOINIT
+        }
+    }
+
+    /*
+     * 工作队列
+     */
+    {
+        heventloop_t *loop_workqueue=heventloop_get_loop_from_table(HEVENTLOOP_SYSTEM_LOOP_WORKQUEUE);
+        if(loop_workqueue==NULL)
+        {
+#ifndef HCPPRT_SYSTEM_WORKQUEUE_NO_AUTOINIT
+            heventloop_set_loop_to_table(HEVENTLOOP_SYSTEM_LOOP_WORKQUEUE,NULL);
+#endif // HCPPRT_SYSTEM_WORKQUEUE_NO_AUTOINIT
+        }
+    }
+
     /*
      * 执行构造函数
      */
     ctors_execute();
+
+    /*
+     * C语言组件初始化
+     */
+    hruntime_init();
+}
+
+HSTACKLESSCOROUTINE_DECLARE_COROUTINE(hsoftdog);
+void hcpprt_loop(void)
+{
+    //hsoftdog组件
+    HSTACKLESSCOROUTINE_ENTRY(hsoftdog);
+
+    //C语言组件循环
+    hruntime_loop();
 }
 
 

FW/package/3rdparty/HCppBox/master/hbox/cpp/hcpprt.h

@@ -10,6 +10,7 @@
 #define HCPPRT_H
 #include "hcompiler.h"
 #include "hdefaults.h"
+#include "stdbool.h"
 
 #ifdef __cplusplus
 extern "C"
@@ -22,6 +23,13 @@ extern "C"
  */
 void hcpprt_init(void);
 
+
+/** \brief hcpprt循环，用户需要较低优先级的任务或者空闲任务中周期性调用此函数以保证内部状态得到正确更新。
+ *
+ *
+ */
+void hcpprt_loop(void);
+
 #ifdef __cplusplus
 }
 #endif // __cplusplus
@@ -246,5 +254,24 @@ public:
     }
 };
 
+/*
+ * 利用C++运行库进行初始化的入口（仅适用于C++代码）,效果类似GCC的__attribute__((constructor))属性
+ */
+typedef void (*hcpprt_init_entry_t)(void);
+#define HCPPRT_INIT_EXPORT(NAME,ENTRY) \
+    __USED\
+    static class hcpprt_init_##NAME\
+    {\
+        public:\
+        hcpprt_init_##NAME()\
+        {\
+            if((ENTRY)!=NULL)\
+            {\
+                (ENTRY)();\
+            }\
+        }\
+        \
+    } g_hcpprt_init_##NAME
+
 #endif // __cplusplus
 #endif // HCPPRT_H

FW/package/3rdparty/HCppBox/master/hbox/cpp/hfifo.h

@@ -12,7 +12,7 @@
 #ifdef __cplusplus
 
 #include "hcpprt.h"
-#include "hringbuf.h"
+#include "hmemory.h"
 #include "stdint.h"
 #include "stdlib.h"
 

FW/package/3rdparty/HCppBox/master/hbox/cpp/hloop.h

@@ -12,7 +12,7 @@
 #ifdef __cplusplus
 
 #include "hcpprt.h"
-#include "heventloop.h"
+#include "hevent.h"
 
 template<class lock=hlock,class cmemory=hcmemory>
 class hloop

FW/package/3rdparty/HCppBox/master/hbox/cpp/hobj.h

@@ -10,7 +10,7 @@
 #define __HOBJ_H__
 #include "hcompiler.h"
 #include "hdefaults.h"
-#include "hobject.h"
+#include "hmemory.h"
 #include "hcpprt.h"
 #ifdef __cplusplus
 

FW/package/3rdparty/HCppBox/master/hbox/cpp/hslots.h

@@ -12,7 +12,7 @@
 #ifdef __cplusplus
 
 #include "hcpprt.h"
-#include "heventslots.h"
+#include "hevent.h"
 
 template<class lock=hlock,class cmemory=hcmemory>
 class hslots

FW/package/3rdparty/HCppBox/master/hbox/cpp/hsoftdog.cpp

@@ -7,4 +7,8 @@
  * License:   MIT
  **************************************************************/
 #include "hsoftdog.h"
+#include "hstacklesscoroutine.h"
 
+HSTACKLESSCOROUTINE_BLOCK_START(hsoftdog)
+HWATCHDOG_FEED();
+HSTACKLESSCOROUTINE_BLOCK_END(hsoftdog)

FW/package/3rdparty/HCppBox/master/hbox/cpp/hsoftdog.h

@@ -12,7 +12,7 @@
 #ifdef __cplusplus
 
 #include "hcpprt.h"
-#include "hwatchdog.h"
+#include "hdriverframework.h"
 
 /*
 软狗,通过继承此类方便喂狗,在子类中调用watchdog_feed喂狗

FW/package/3rdparty/HCppBox/master/hbox/gui/tools/dotfontscan/.gitignore

@@ -1,2 +0,0 @@
-build
-*.exe

FW/package/3rdparty/HCppBox/master/hbox/h3rdparty.h

@@ -19,8 +19,8 @@
  * 引入cJSON库
  */
 #ifndef H3RDPARTY_USING_SYSTEM_CJSON
-#include "3rdparty/cJSON/cJSON.h"
-#include "3rdparty/cJSON/cJSON_Utils.h"
+#include "h3rdparty/3rdparty/cJSON/cJSON.h"
+#include "h3rdparty/3rdparty/cJSON/cJSON_Utils.h"
 #else
 #include "cJSON.h"
 #include "cJSON_Utils.h"
@@ -92,31 +92,49 @@ int hvfctprintf(void (*out)(char character, void* arg), void* arg, const char* f
 /*
  *  引入nanopb库
  */
-#ifndef H3RDPARTY_USING_SYSTEM_NANOPB
-#include "3rdparty/nanopb/pb.h"
-#include "3rdparty/nanopb/pb_encode.h"
-#include "3rdparty/nanopb/pb_decode.h"
+#ifndef H3RDPARTY_NANOPB_PB_HEADER
+#ifdef  H3RDPARTY_USING_SYSTEM_NANOPB
+#define H3RDPARTY_NANOPB_PB_HEADER "pb.h"
 #else
-#include "pb.h"
-#include "pb_encode.h"
-#include "pb_decode.h"
+#define H3RDPARTY_NANOPB_PB_HEADER "h3rdparty/3rdparty/nanopb/pb.h"
 #endif
+#endif
+#ifndef H3RDPARTY_NANOPB_PB_ENCODE_HEADER
+#ifdef  H3RDPARTY_USING_SYSTEM_NANOPB
+#define H3RDPARTY_NANOPB_PB_ENCODE_HEADER "pb_encode.h"
+#else
+#define H3RDPARTY_NANOPB_PB_ENCODE_HEADER "h3rdparty/3rdparty/nanopb/pb_encode.h"
+#endif
+#endif
+#ifndef H3RDPARTY_NANOPB_PB_DECODE_HEADER
+#ifdef  H3RDPARTY_USING_SYSTEM_NANOPB
+#define H3RDPARTY_NANOPB_PB_DECODE_HEADER "pb_decode.h"
+#else
+#define H3RDPARTY_NANOPB_PB_DECODE_HEADER "h3rdparty/3rdparty/nanopb/pb_decode.h"
+#endif
+#endif
+#include H3RDPARTY_NANOPB_PB_HEADER
+#include H3RDPARTY_NANOPB_PB_ENCODE_HEADER
+#include H3RDPARTY_NANOPB_PB_DECODE_HEADER
+
+
+
 
 /*
  * 引入paho.mqtt.embedded-c库,用户需要手动引入相应头文件
  */
 #ifndef H3RDPARTY_PAHO_MQTT_EMBEDDED_C_PACKET_HEADER
-#define H3RDPARTY_PAHO_MQTT_EMBEDDED_C_PACKET_HEADER "3rdparty/paho.mqtt.embedded-c/MQTTPacket/src/MQTTPacket.h"
+#define H3RDPARTY_PAHO_MQTT_EMBEDDED_C_PACKET_HEADER "h3rdparty/3rdparty/paho.mqtt.embedded-c/MQTTPacket/src/MQTTPacket.h"
 #endif
 
 /*
  * 引入softfp库,用户需要手动引入相应头文件
  */
 #ifndef H3RDPARTY_SOFTFP_HEADER
-#define H3RDPARTY_SOFTFP_HEADER "3rdparty/softfp/softfp.h"
+#define H3RDPARTY_SOFTFP_HEADER "h3rdparty/3rdparty/softfp/softfp.h"
 #endif
 #ifndef H3RDPARTY_SOFTFLOAT_HEADER
-#define H3RDPARTY_SOFTFLOAT_HEADER "3rdparty/softfp/softfloat.h"
+#define H3RDPARTY_SOFTFLOAT_HEADER "h3rdparty/3rdparty/softfp/softfloat.h"
 #endif
 
 #endif // __H3RDPARTY_H__

FW/package/3rdparty/HCppBox/master/hbox/h3rdparty/3rdparty/cJSON/update-master.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+
+#检查工具是否存在,$1为待检查的工具名。
+function CheckTool
+{
+	[  -n "$1"  ] ||
+	{
+		echo -e  "\033[41;37mCheckTool 参数错误!!\r\n\033[40;37m";
+		return 255;
+	};
+	ToolPath=`which $1`;
+	[ -e "$ToolPath" ] ||
+	{
+		 echo -e "\033[41;37m$1 不存在，请先安装此工具\r\n\033[40;37m";
+		 return 255;
+	};
+	return 0;
+}
+
+CheckTool git
+[ $? -eq 0 ] || exit;
+CheckTool mkdir
+[ $? -eq 0 ] || exit;
+CheckTool rsync
+[ $? -eq 0 ] || exit;
+
+
+#获取当前目录
+slef_path=
+# shellcheck disable=SC2128  # ignore array expansion warning
+if [ -n "${BASH_SOURCE-}" ]
+then
+        self_path="${BASH_SOURCE}"
+elif [ -n "${ZSH_VERSION-}" ]
+then
+        self_path="${(%):-%x}"
+else
+        return 1
+fi
+# shellcheck disable=SC2169,SC2169,SC2039  # unreachable with 'dash'
+if [[ "$OSTYPE" == "darwin"* ]]; then
+        # convert possibly relative path to absolute
+        script_dir="$(realpath_int "${self_path}")"
+        # resolve any ../ references to make the path shorter
+        script_dir="$(cd "${script_dir}" || exit 1; pwd)"
+else
+        # convert to full path and get the directory name of that
+        script_name="$(readlink -f "${self_path}")"
+        script_dir="$(dirname "${script_name}")"
+fi
+
+echo 当前目录为${script_dir}.
+
+if [ -d "${script_dir}/cJSON" ]
+then
+	pushd "${script_dir}/cJSON"
+	git pull			
+	popd
+else
+	git clone -b master https://github.com/DaveGamble/cJSON "${script_dir}/cJSON"
+fi
+
+
+if [ -f "${script_dir}/cJSON/LICENSE" ]
+then
+	rsync -rl --progress  "${script_dir}/cJSON/LICENSE" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/cJSON/cJSON.h" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/cJSON/cJSON.c" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/cJSON/cJSON_Utils.h" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/cJSON/cJSON_Utils.c" "${script_dir}/"
+fi

FW/package/3rdparty/HCppBox/master/hbox/h3rdparty/3rdparty/nanopb/pb_decode.c

@@ -782,6 +782,22 @@ static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type
         
         if (!pb_make_string_substream(stream, &substream))
             return false;
+
+        /* If the callback field is inside a submsg, first call the submsg_callback which
+         * should set the decoder for the callback field. */
+        if (PB_LTYPE(field->type) == PB_LTYPE_SUBMSG_W_CB && field->pSize != NULL) {
+            pb_callback_t* callback;
+            *(pb_size_t*)field->pSize = field->tag;
+            callback = (pb_callback_t*)field->pSize - 1;
+
+            if (callback->funcs.decode)
+            {
+                if (!callback->funcs.decode(&substream, field, &callback->arg)) {
+                    PB_SET_ERROR(stream, substream.errmsg ? substream.errmsg : "submsg callback failed");
+                    return false;
+                }
+            }
+        }
         
         do
         {

FW/package/3rdparty/HCppBox/master/hbox/h3rdparty/3rdparty/nanopb/update-master.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+
+#检查工具是否存在,$1为待检查的工具名。
+function CheckTool
+{
+	[  -n "$1"  ] ||
+	{
+		echo -e  "\033[41;37mCheckTool 参数错误!!\r\n\033[40;37m";
+		return 255;
+	};
+	ToolPath=`which $1`;
+	[ -e "$ToolPath" ] ||
+	{
+		 echo -e "\033[41;37m$1 不存在，请先安装此工具\r\n\033[40;37m";
+		 return 255;
+	};
+	return 0;
+}
+
+CheckTool git
+[ $? -eq 0 ] || exit;
+CheckTool mkdir
+[ $? -eq 0 ] || exit;
+CheckTool rsync
+[ $? -eq 0 ] || exit;
+
+
+#获取当前目录
+slef_path=
+# shellcheck disable=SC2128  # ignore array expansion warning
+if [ -n "${BASH_SOURCE-}" ]
+then
+        self_path="${BASH_SOURCE}"
+elif [ -n "${ZSH_VERSION-}" ]
+then
+        self_path="${(%):-%x}"
+else
+        return 1
+fi
+# shellcheck disable=SC2169,SC2169,SC2039  # unreachable with 'dash'
+if [[ "$OSTYPE" == "darwin"* ]]; then
+        # convert possibly relative path to absolute
+        script_dir="$(realpath_int "${self_path}")"
+        # resolve any ../ references to make the path shorter
+        script_dir="$(cd "${script_dir}" || exit 1; pwd)"
+else
+        # convert to full path and get the directory name of that
+        script_name="$(readlink -f "${self_path}")"
+        script_dir="$(dirname "${script_name}")"
+fi
+
+echo 当前目录为${script_dir}.
+
+if [ -d "${script_dir}/nanopb" ]
+then
+	pushd "${script_dir}/nanopb"
+	git pull			
+	popd
+else
+	git clone -b master https://github.com/nanopb/nanopb.git "${script_dir}/nanopb"
+fi
+
+
+if [ -f "${script_dir}/nanopb/LICENSE.txt" ]
+then
+	rsync -rl --progress  "${script_dir}/nanopb/LICENSE.txt" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/nanopb/pb.h" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/nanopb/pb_common.h" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/nanopb/pb_common.c" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/nanopb/pb_encode.h" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/nanopb/pb_encode.c" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/nanopb/pb_decode.h" "${script_dir}/"
+	rsync -rl --progress  "${script_dir}/nanopb/pb_decode.c" "${script_dir}/"
+fi

FW/package/3rdparty/HCppBox/master/hbox/h3rdparty/SConscript

@@ -0,0 +1,21 @@
+from building import *
+import os
+import sys
+
+
+cwd = GetCurrentDir()
+src = Glob('*.c')
+src += Glob('*.cpp')
+CPPPATH = [
+cwd,
+cwd+'/cpp'
+]
+
+group = DefineGroup('HBox_3rdparty', src, depend = [''], CPPPATH = CPPPATH)
+
+list = os.listdir(cwd)
+for item in list:
+    if os.path.isfile(os.path.join(cwd, item, 'SConscript')):
+        group = group + SConscript(os.path.join(item, 'SConscript'))
+
+Return('group')

FW/package/3rdparty/HCppBox/master/hbox/hbox.h

@@ -16,20 +16,18 @@
 #include "hcompiler.h"
 #include "hdefaults.h"
 #include "h3rdparty.h" //第三方库
-#include "heventloop.h"
-#include "heventslots.h"
-#include "heventchain.h"
-#include "hwatchdog.h"
-#include "hmemoryheap.h"
-#include "hobject.h"
-#include "hringbuf.h"
-#include "hunicode.h"
+#include "hevent.h"
+#include "hdriverframework.h"
+#include "hmemory.h"
+#include "hlocale.h"
 #include "hstacklesscoroutine.h"
 #include "hmodbus.h"
-#include "hbase64.h"
 #include "hsimulator.h"
 #include "hgui.h"
 #include "hshell.h"
+#include "huuid.h"
+#include "hcrypto.h"
+#include "hruntime.h"
 
 /*
 由C++编写的组件

FW/package/3rdparty/HCppBox/master/hbox/hcrypto.c

@@ -0,0 +1,27 @@
+/***************************************************************
+ * Name:      hcrypto.c
+ * Purpose:   实现hcrypto接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-12
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "hcrypto.h"
+
+#include "hcrypto/hbignum.c"
+
+#include "hcrypto/hbase16.c"
+#include "hcrypto/hbase64.c"
+#include "hcrypto/hasn1.c"
+#include "hcrypto/haes.c"
+#include "hcrypto/hbcc.c"
+#include "hcrypto/hlrc.c"
+#include "hcrypto/hcrc.c"
+#include "hcrypto/hmd5.c"
+#include "hcrypto/hsha.c"
+#include "hcrypto/hripemd160.c"
+#include "hcrypto/hsm3.c"
+#include "hcrypto/hmd4.c"
+#include "hcrypto/hsm4.c"
+#include "hcrypto/hhmac.c"
+

FW/package/3rdparty/HCppBox/master/hbox/hcrypto.h

@@ -0,0 +1,39 @@
+/***************************************************************
+ * Name:      hcrypto.h
+ * Purpose:   声明hcrypto接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-12
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HCRYPTO_H__
+#define __HCRYPTO_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#include "hcrypto/hbignum.h"
+
+#include "hcrypto/hbase16.h"
+#include "hcrypto/hbase64.h"
+#include "hcrypto/hasn1.h"
+#include "hcrypto/haes.h"
+#include "hcrypto/hbcc.h"
+#include "hcrypto/hlrc.h"
+#include "hcrypto/hcrc.h"
+#include "hcrypto/hmd5.h"
+#include "hcrypto/hsha.h"
+#include "hcrypto/hripemd160.h"
+#include "hcrypto/hsm3.h"
+#include "hcrypto/hmd4.h"
+#include "hcrypto/hsm4.h"
+#include "hcrypto/hhmac.h"
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HCRYPTO_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/haes.h

@@ -0,0 +1,99 @@
+/***************************************************************
+ * Name:      haes.h
+ * Purpose:   声明haes接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-12
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HAES_H__
+#define __HAES_H__
+#include "stdint.h"
+#include "stdlib.h"
+#include "string.h"
+#include "stdbool.h"
+
+/*
+ * 本文件提供简易的AES加密解密功能。
+ *
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#ifndef HAES_MAXNR
+#define HAES_MAXNR      14
+#endif // HAES_MAXNR
+#ifndef HAES_BLOCK_SIZE
+/*
+ * AES是分组加密算法，一个块的大小为16字节
+ */
+#define HAES_BLOCK_SIZE 16
+#endif // HAES_BLOCK_SIZE
+
+typedef struct haes_key haes_key_t;
+struct haes_key
+{
+    uint32_t rd_key[4 *(HAES_MAXNR + 1)];
+    int rounds;
+};
+
+/** \brief aes初始化加密密钥
+ *
+ * \param userKey const uint8_t* 密钥数据
+ * \param bits const int 128/192/256 分别对应aes128、aes192、aes256
+ * \param key haes_key_t* 密钥
+ * \return int 0等于成功
+ *
+ */
+int haes_set_encrypt_key(const uint8_t *userKey, const int bits,haes_key_t *key);
+
+/** \brief aes初始化解密密钥
+ *
+ * \param userKey const uint8_t* 密钥数据
+ * \param bits const int 128/192/256 分别对应aes128、aes192、aes256
+ * \param key haes_key_t* 密钥
+ * \return int 0等于成功
+ *
+ */
+int haes_set_decrypt_key(const uint8_t *userKey, const int bits,haes_key_t *key);
+
+/** \brief aes加密单个分组（16字节）
+ *
+ * \param in const uint8_t* 输入数据
+ * \param out uint8_t* 输出数据
+ * \param key const haes_key_t* 加密密钥
+ *
+ */
+void haes_encrypt(const uint8_t *in, uint8_t *out,const haes_key_t *key);
+
+/** \brief aes解密单个分组（16字节）
+ *
+ * \param in const uint8_t* 输入数据
+ * \param out uint8_t* 输出数据
+ * \param key const haes_key_t* 解密密钥
+ *
+ */
+void haes_decrypt(const uint8_t *in, uint8_t *out,const haes_key_t *key);
+
+
+/** \brief aes cbc加密
+ *
+ * \param in const uint8_t* 输入数据
+ * \param out uint8_t*  输出数据
+ * \param length const size_t 数据长度（输入输出数据长度一致）
+ * \param key const haes_key_t* 加密密钥
+ * \param ivec uint8_t* 初始向量（长度为16字节），必须可读写
+ * \param enc bool 是否为加密
+ *
+ */
+void haes_cbc_encrypt(const uint8_t *in, uint8_t *out,const size_t length, const haes_key_t *key, uint8_t *ivec, bool enc);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HAES_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hasn1.c

@@ -0,0 +1,11 @@
+/***************************************************************
+ * Name:      hasn1.c
+ * Purpose:   实现hasn1接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-25
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "hasn1.h"
+
+#include "hasn1/hasn1_ber.c"

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hasn1.h

@@ -0,0 +1,24 @@
+/***************************************************************
+ * Name:      hasn1.h
+ * Purpose:   声明hasn1接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-25
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HASN1_H__
+#define __HASN1_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#include "hasn1/hasn1_ber.h"
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HASN1_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hasn1/hasn1_ber.c

@@ -0,0 +1,432 @@
+/***************************************************************
+ * Name:      hasn1_ber.c
+ * Purpose:   实现hasn1_ber接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-25
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "hasn1_ber.h"
+
+hasn1_ber_type_class_t hasn1_ber_type_class_get(const hasn1_ber_type_t *type)
+{
+    if(type!=NULL)
+    {
+        return (hasn1_ber_type_class_t)(type->type & (3 << 6));
+    }
+    return HASN1_BER_TYPE_CLASS_UNIVERSAL;
+}
+
+void hasn1_ber_type_class_set(hasn1_ber_type_t *type,const hasn1_ber_type_class_t type_class)
+{
+    if(type!=NULL)
+    {
+        type->type &= (~(3 <<6));
+        type->type |= type_class;
+    }
+}
+
+
+hasn1_ber_type_p_c_t hasn1_ber_type_p_c_get(const hasn1_ber_type_t *type)
+{
+    if(type!=NULL)
+    {
+        return (hasn1_ber_type_p_c_t)(type->type & (1 << 5));
+    }
+    return HASN1_BER_TYPE_PRIMITIVE;
+}
+
+void hasn1_ber_type_p_c_set(hasn1_ber_type_t *type,const hasn1_ber_type_p_c_t type_p_c)
+{
+    if(type!=NULL)
+    {
+        type->type &= (~(1 <<5));
+        type->type |= type_p_c;
+    }
+}
+
+uint64_t hasn1_ber_type_tag_get(const hasn1_ber_type_t *type)
+{
+    uint64_t ret=0;
+    if(type!=NULL)
+    {
+        ret=(type->type&0x1F);
+        if(ret==HASN1_BER_TYPE_TAG_FOLLOW_BYTES)
+        {
+            ret=0;
+            for(size_t i=0; i<sizeof(type->tag); i++)
+            {
+                ret<<=7;
+                ret+=(type->tag[i]&0x7f);
+                if((type->tag[i]&0x80)==0)
+                {
+                    break;
+                }
+            }
+        }
+    }
+    return ret;
+}
+
+void hasn1_ber_type_tag_set(hasn1_ber_type_t *type,uint64_t tag)
+{
+    if(type!=NULL)
+    {
+        if(tag <= 0x1F)
+        {
+            type->type &= (~(0x1f));
+            type->type |= tag;
+        }
+        else
+        {
+            //type低五位全部置1
+            type->type |= 0x1f;
+            size_t clz=0;
+            for(size_t i=0; i<8*sizeof(tag); i++)
+            {
+                if(((1ULL << (8*sizeof(tag)-1-i)) & tag )!=0)
+                {
+                    clz=i;
+                    break;
+                }
+            }
+            size_t bytes_need=(8*sizeof(tag)-clz)/8 + (((8*sizeof(tag)-clz)%8!=0)?1:0);
+            if(bytes_need > sizeof(type->tag))
+            {
+                //不能超过结构体存储的上限
+                bytes_need=sizeof(type->tag);
+            }
+            for(size_t i=0; i<bytes_need; i++)
+            {
+                type->tag[i]=(0x80 | (0x7F &(tag >> (((bytes_need-1-i)*7)))));
+                if(i==(bytes_need-1))
+                {
+                    //最后一个字节的最高位为0
+                    type->tag[i] &= 0x7f;
+                }
+            }
+        }
+    }
+}
+
+size_t hasn1_ber_type_get(hasn1_ber_type_t *type,const uint8_t *data,size_t data_length)
+{
+    size_t ret=0;
+    if(data==NULL || data_length==0)
+    {
+        return ret;
+    }
+    uint8_t type_field=data[0];
+    ret=1;
+    if((type_field&0x1F)==HASN1_BER_TYPE_TAG_FOLLOW_BYTES)
+    {
+        //长度在后跟的字节中
+        bool tag_ok=false;
+        for(size_t i=1; i < data_length ; i++)
+        {
+            if((data[i] & 0x80)==0)
+            {
+                ret=(i+1);
+                tag_ok=true;
+                break;
+            }
+        }
+        if(!tag_ok)
+        {
+            //tag过长，不能存储在hasn1_ber_type_t结构中
+            ret=0;
+        }
+    }
+    if(type!=NULL)
+    {
+        type->type=type_field;
+        memcpy(type->tag,&data[1],ret-1);
+    }
+    return ret;
+}
+
+size_t hasn1_ber_type_set(const hasn1_ber_type_t *type,uint8_t *data,size_t data_length)
+{
+    size_t ret=0;
+    if(type==NULL || data==NULL || data_length==0)
+    {
+        return ret;
+    }
+
+    data[ret++]=type->type;
+    if((type->type&0x1F)==HASN1_BER_TYPE_TAG_FOLLOW_BYTES)
+    {
+        for(size_t i=0; i<sizeof(type->tag); i++)
+        {
+            if(i+1 < data_length)
+            {
+                data[ret++]=type->tag[i];
+                if((type->tag[i]&0x80)==0)
+                {
+                    break;
+                }
+            }
+            else
+            {
+                //写入失败
+                return ret;
+            }
+        }
+    }
+
+    return ret;
+}
+
+
+size_t hasn1_ber_length_get( hasn1_ber_length_t *length,const uint8_t *data,size_t data_length)
+{
+    size_t ret=0;
+    if(data==NULL && data_length ==0)
+    {
+        return ret;
+    }
+    {
+        //跳过类型数据
+        size_t type_len=hasn1_ber_type_get(NULL,data,data_length);
+        if(type_len > 0)
+        {
+            data+=type_len;
+            data_length-=type_len;
+        }
+        else
+        {
+            return ret;
+        }
+    }
+    if(data[0] < 0x80 )
+    {
+        //长度小于127
+        ret = 1;
+        if(length!=NULL)
+        {
+            length->length=(data[0]&0x7f);
+        }
+    }
+    if(data[0]==0x80)
+    {
+        //长度动态(在发送时不确定，且需要立即发送数据时使用)，值（V）以两个00结尾（不计入长度字节与值字节）
+        ret=1;
+        bool value_end_found=false;
+        for(size_t i=0; i<(data_length-1); i++)
+        {
+            if(data[1+i]==0x00 && data[1+i+1]==0x00)
+            {
+                if(length!=NULL)
+                {
+                    length->length=i;
+                }
+                break;
+            }
+        }
+        if(!value_end_found)
+        {
+            ret=0;
+        }
+    }
+    if(data[0] > 0x80)
+    {
+        //长度值字节数在第一个字节的低7位给出
+        size_t len=(data[0]&0x7f);
+        ret=len+1;
+        if(len > sizeof(length->length) || ret > data_length)
+        {
+            //长度所占空间过大
+            ret=0;
+        }
+        if(length!=NULL)
+        {
+            length->length=0;
+            for(size_t i=0; i<len; i++)
+            {
+                length->length <<= 8;
+                length->length += data[1+i];
+            }
+        }
+    }
+    return ret;
+}
+
+size_t hasn1_ber_length_set(const hasn1_ber_length_t *length,uint8_t *data,size_t data_length)
+{
+    size_t ret=0;
+    if(data == NULL || data_length==0)
+    {
+        return ret;
+    }
+    {
+        //跳过类型数据
+        size_t type_len=hasn1_ber_type_get(NULL,data,data_length);
+        if(type_len > 0)
+        {
+            data+=type_len;
+            data_length-=type_len;
+        }
+        else
+        {
+            return ret;
+        }
+    }
+
+
+    if(length!=NULL)
+    {
+        if(length->length > 0x80)
+        {
+            size_t bytes_need=0;
+            {
+                size_t clz=0;
+                for(size_t i=0; i<8*sizeof(length->length); i++)
+                {
+                    if(((1ULL << (8*sizeof(length->length)-1-i)) & length->length )!=0)
+                    {
+                        clz=i;
+                        break;
+                    }
+                }
+                bytes_need=(8*sizeof(length->length)-clz)/8 + (((8*sizeof(length->length)-clz)%8!=0)?1:0);
+            }
+            if(bytes_need + 1 > data_length )
+            {
+                data[0]=(0x80 & bytes_need);
+                for(size_t i=0; i<bytes_need; i++)
+                {
+                    data[1+i]=(0xff &(length->length >> ((bytes_need-1-i)*8)));
+                }
+                ret=bytes_need+1;
+            }
+        }
+        else
+        {
+            if(data_length >= 1)
+            {
+                data[0]=(length->length&0x7f);
+                ret=1;
+            }
+        }
+    }
+    else
+    {
+        if(data_length >= 1)
+        {
+            //动态长度，在值末尾添两个00结尾
+            data[0]=0x80;
+            ret=1;
+        }
+    }
+
+    return ret;
+}
+
+size_t hasn1_ber_value_get( hasn1_ber_value_t *value,const uint8_t *data,size_t data_length)
+{
+    size_t ret=0;
+    if(data==NULL && data_length ==0)
+    {
+        return ret;
+    }
+    const uint8_t *   original_data=data;
+    size_t      original_data_length=data_length;
+    {
+        //跳过类型数据
+        size_t type_len=hasn1_ber_type_get(NULL,original_data,original_data_length);
+        if(type_len > 0)
+        {
+            data+=type_len;
+            data_length-=type_len;
+        }
+        else
+        {
+            return ret;
+        }
+    }
+    hasn1_ber_length_t length;
+    bool is_dynamic_length=(data[0]==0x80);
+    {
+        //跳过长度数据
+        size_t length_len=hasn1_ber_length_get(&length,original_data,original_data_length);
+        if(length_len > 0)
+        {
+            data+=length_len;
+            data_length-=length_len;
+        }
+        else
+        {
+            return ret;
+        }
+    }
+    if(data_length >= length.length)
+    {
+        ret=length.length;
+        if(is_dynamic_length)
+        {
+            //末尾00计入字节数
+            ret+=2;
+        }
+        if(value!=NULL)
+        {
+            value->value=data;
+            value->length=length.length;
+        }
+    }
+    return ret;
+}
+
+size_t hasn1_ber_value_set(const hasn1_ber_value_t *value,uint8_t *data,size_t data_length)
+{
+    size_t ret=0;
+    if(data==NULL && data_length ==0 || value == NULL)
+    {
+        return ret;
+    }
+    uint8_t *   original_data=data;
+    size_t      original_data_length=data_length;
+    {
+        //跳过类型数据
+        size_t type_len=hasn1_ber_type_get(NULL,original_data,original_data_length);
+        if(type_len > 0)
+        {
+            data+=type_len;
+            data_length-=type_len;
+        }
+        else
+        {
+            return ret;
+        }
+    }
+    bool is_dynamic_length=(data[0]==0x80);
+    if(is_dynamic_length)
+    {
+        data+=1;
+        data_length-=1;
+        if(data_length >= (value->length+2))
+        {
+            memcpy(data,value->value,value->length);
+            //末尾添加两个00字节
+            memset(&data[value->length],0,2);
+            ret=(value->length+2);
+        }
+    }
+    else
+    {
+        hasn1_ber_length_t length;
+        length.length=value->length;
+        size_t length_len=hasn1_ber_length_set(&length,original_data,original_data_length);
+        if(length_len > 0)
+        {
+            data+=length_len;
+            data_length-=length_len;
+            if(data_length >= value->length)
+            {
+                memcpy(data,value->value,value->length);
+                ret=value->length;
+            }
+        }
+    }
+
+    return ret;
+}

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hasn1/hasn1_ber.h

@@ -0,0 +1,215 @@
+/***************************************************************
+ * Name:      hasn1_ber.h
+ * Purpose:   声明hasn1_ber接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-25
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HASN1_BER_H__
+#define __HASN1_BER_H__
+#include "stdint.h"
+#include "stdlib.h"
+#include "stdbool.h"
+#include "string.h"
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+/*
+ *  BER传输TLV三元组<Type,Length, Value>，其中三元组内部采用大端模式。
+ */
+
+typedef enum
+{
+    HASN1_BER_TYPE_CLASS_UNIVERSAL              = 0<<6,
+    HASN1_BER_TYPE_CLASS_APPLICATION            = 1<<6,
+    HASN1_BER_TYPE_CLASS_CONTEXT_SPECIFIC       = 2<<6,
+    HASN1_BER_TYPE_CLASS_PRIVATE                = 3<<6
+}   hasn1_ber_type_class_t;  /**< 类，一般占用类型字节(第1个)的[6,7] */
+
+typedef enum
+{
+    HASN1_BER_TYPE_PRIMITIVE                    = 0 << 5,
+    HASN1_BER_TYPE_CONSTRUCTED                  = 1 << 5
+}   hasn1_ber_type_p_c_t; /**< 结构类型，一般占用类型字节(第1个)的位5 */
+
+typedef enum
+{
+    HASN1_BER_TYPE_TAG_BER_RESEVED_0            = 0,
+    HASN1_BER_TYPE_TAG_BOOLEAN                  = 1,
+    HASN1_BER_TYPE_TAG_INTEGER                  = 2,
+    HASN1_BER_TYPE_TAG_BITSTRING                = 3,
+    HASN1_BER_TYPE_TAG_OCTETSTRING              = 4,
+    HASN1_BER_TYPE_TAG_NULL                     = 5,
+    HASN1_BER_TYPE_TAG_IDENTIFIER               = 6,
+    HASN1_BER_TYPE_TAG_DESCRIPTION              = 7,
+    HASN1_BER_TYPE_TAG_EXTERNAL                 = 8,
+    HASN1_BER_TYPE_TAG_REAL                     = 9,
+    HASN1_BER_TYPE_TAG_ENUMERATED               = 10,
+    HASN1_BER_TYPE_TAG_EMBEDDED_PDV             = 11,
+    HASN1_BER_TYPE_TAG_UTF8STRING               = 12,
+    HASN1_BER_TYPE_TAG_RELATIVE_OID             = 13,
+    HASN1_BER_TYPE_TAG_RESEVED_14               = 14,
+    HASN1_BER_TYPE_TAG_RESEVED_15               = 15,
+    HASN1_BER_TYPE_TAG_SEQUENCE                 = 16,       /**<  一般配合HASN1_BER_TYPE_CONSTRUCTED使用*/
+    HASN1_BER_TYPE_TAG_SET                      = 17,       /**<  一般配合HASN1_BER_TYPE_CONSTRUCTED使用*/
+    HASN1_BER_TYPE_TAG_NUMERICSTRING            = 18,
+    HASN1_BER_TYPE_TAG_PRINTABLESTRING          = 19,
+    HASN1_BER_TYPE_TAG_TELETEXSTRING            = 20,
+    HASN1_BER_TYPE_TAG_VIDEOTEXSTRING           = 21,
+    HASN1_BER_TYPE_TAG_IA5STRING                = 22,
+    HASN1_BER_TYPE_TAG_UTC                      = 23,
+    HASN1_BER_TYPE_TAG_GENERALIZEDTIME          = 24,
+    HASN1_BER_TYPE_TAG_GRAPHICSTRING            = 25,
+    HASN1_BER_TYPE_TAG_VISIBLESSTRING           = 26,
+    HASN1_BER_TYPE_TAG_GENERALSTRING            = 27,
+    HASN1_BER_TYPE_TAG_UNIVERSALSTRING          = 28,
+    HASN1_BER_TYPE_TAG_CHARACTER_STRING         = 29,
+    HASN1_BER_TYPE_TAG_BMPSTRING                = 30,
+    HASN1_BER_TYPE_TAG_RESEVED_31               = 31,
+    HASN1_BER_TYPE_TAG_FOLLOW_BYTES             = 31        /**< 标签将在紧接的字节给出，直到字节高位为0的字节结束 */
+}   hasn1_ber_type_base_tag_t; /**< 标签,低5位.此枚举通常用于通用类 */
+
+#ifndef HASN1_BER_TYPE_TAG_MAX_LENGTH
+#define HASN1_BER_TYPE_TAG_MAX_LENGTH 10
+#endif // HASN1_BER_TYPE_TAG_MAX_LENGTH
+
+typedef struct hasn1_ber_type hasn1_ber_type_t;
+struct hasn1_ber_type
+{
+    uint8_t type;                                   /**< 类型 */
+    uint8_t tag[HASN1_BER_TYPE_TAG_MAX_LENGTH];     /**< TAG,编码后的TAG。即结尾字节的最高位为0，其余字节的最高位为1 */
+};
+
+/** \brief 获取类
+ *
+ * \param type const hasn1_ber_type_t* 类型
+ * \return hasn1_ber_type_class_t 类
+ *
+ */
+hasn1_ber_type_class_t hasn1_ber_type_class_get(const hasn1_ber_type_t *type);
+
+/** \brief 设置类
+ *
+ * \param type const hasn1_ber_type_t* 类型
+ * \param type_class hasn1_ber_type_class_t 类
+ *
+ */
+void hasn1_ber_type_class_set(hasn1_ber_type_t *type,const hasn1_ber_type_class_t type_class);
+
+
+/** \brief 获取P_C
+ *
+ * \param type const hasn1_ber_type_t* 类型
+ * \return hasn1_ber_type_p_c_t P_C
+ *
+ */
+hasn1_ber_type_p_c_t hasn1_ber_type_p_c_get(const hasn1_ber_type_t *type);
+
+/** \brief 设置P_C
+ *
+ * \param type const hasn1_ber_type_t* 类型
+ * \param type_class hasn1_ber_type_p_c_t P_C
+ *
+ */
+void hasn1_ber_type_p_c_set(hasn1_ber_type_t *type,const hasn1_ber_type_p_c_t type_p_c);
+
+/** \brief 获取TAG
+ *
+ * \param type const hasn1_ber_type_t*  类型
+ * \return uint64_t tag
+ *
+ */
+uint64_t hasn1_ber_type_tag_get(const hasn1_ber_type_t *type);
+
+/** \brief 设置TAG
+ *
+ * \param type const hasn1_ber_type_t* 类型
+ * \param tag uint64_t tag
+ *
+ */
+void hasn1_ber_type_tag_set(hasn1_ber_type_t *type,uint64_t tag);
+
+/** \brief 从数据中提取类型
+ *
+ * \param type hasn1_ber_type_t*            类型
+ * \param data const uint8_t*               数据（按照TLV三元组存放的数据）
+ * \param data_length size_t                数据长度。
+ * \return size_t 类型所占长度，0表示出错。
+ *
+ */
+size_t hasn1_ber_type_get(hasn1_ber_type_t *type,const uint8_t *data,size_t data_length);
+
+/** \brief 向数据中设置类型
+ *
+ * \param type const hasn1_ber_type_t*      类型
+ * \param data uint8_t*                     数据（按照TLV三元组存放的数据）
+ * \param data_length size_t                数据长度。
+ * \return size_t 类型所占长度，0表示出错。
+ *
+ */
+size_t hasn1_ber_type_set(const hasn1_ber_type_t *type,uint8_t *data,size_t data_length);
+
+typedef struct  hasn1_ber_length hasn1_ber_length_t;
+struct hasn1_ber_length
+{
+    uint64_t length;  /**< 本库默认支持64位长度,理论上BER支持更长的长度 */
+};
+
+/** \brief 从数据中提取长度
+ *
+ * \param length hasn1_ber_length_t*    长度
+ * \param data const uint8_t*           数据（按照TLV三元组存放的数据）
+ * \param data_length size_t            数据长度。
+ * \return size_t 长度所占长度，0表示出错。
+ *
+ */
+size_t hasn1_ber_length_get( hasn1_ber_length_t *length,const uint8_t *data,size_t data_length);
+
+
+/** \brief 向数据中设置长度（需要先设置好类型）
+ *
+ * \param length const hasn1_ber_length_t*  长度(为NULL时表示动态长度)
+ * \param data uint8_t*                     数据（按照TLV三元组存放的数据）
+ * \param data_length size_t                数据长度。
+ * \return size_t  长度所占长度，0表示出错。
+ *
+ */
+size_t hasn1_ber_length_set(const hasn1_ber_length_t *length,uint8_t *data,size_t data_length);
+
+typedef struct  hasn1_ber_value hasn1_ber_value_t;
+struct  hasn1_ber_value
+{
+    const uint8_t *value;           /**< 值地址 */
+    uint64_t length;                /**< 值长度,本库默认支持64位长度,理论上BER支持更长的长度 */
+};
+
+/** \brief 从数据中提取值
+ *
+ * \param length  hasn1_ber_value_t*    值
+ * \param data const uint8_t*           数据（按照TLV三元组存放的数据）
+ * \param data_length size_t            数据长度。
+ * \return size_t 值所占长度（若为动态长度，包含末尾的两个00），0表示出错。
+ *
+ */
+size_t hasn1_ber_value_get(hasn1_ber_value_t *value,const uint8_t *data,size_t data_length);
+
+
+/** \brief 向数据中设置值（需要先设置好类型）
+ *
+ * \param length const hasn1_ber_value_t*   值(为NULL时表示动态长度)
+ * \param data uint8_t*                     数据（按照TLV三元组存放的数据）
+ * \param data_length size_t                数据长度。
+ * \return size_t  长度所占长度（若为动态长度，包含末尾的两个00），0表示出错。
+ *
+ */
+size_t hasn1_ber_value_set(const hasn1_ber_value_t *value,uint8_t *data,size_t data_length);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HASN1_BER_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbase16.c

@@ -0,0 +1,159 @@
+/***************************************************************
+ * Name:      hbase16.c
+ * Purpose:   声明base16实现。
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2024-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "hbase16.h"
+
+static uint8_t hbase16_decode_single_char(char  code)
+{
+    if(code >= '0' && code <= '9')
+    {
+        return code-'0'+0;
+    }
+    if(code >= 'A' && code <= 'F')
+    {
+        return code-'A'+0xA;
+    }
+    if(code >= 'a' && code <= 'f')
+    {
+        return code-'a'+0xa;
+    }
+    return 0;
+}
+static uint8_t hbase16_decode_single_data(const char * code,size_t code_len)
+{
+    uint8_t ret=0;
+    if(code!=NULL &&code_len>0)
+    {
+        for(size_t i=0; i<code_len; i++)
+        {
+            ret<<=4;
+            ret+=hbase16_decode_single_char(code[i]);
+        }
+    }
+    return ret;
+}
+
+size_t hbase16_decode(uint8_t *value,size_t value_length,const char *encoding,size_t encoding_length)
+{
+    if(encoding==NULL || encoding_length==0)
+    {
+        return 0;
+    }
+    size_t len=0;
+    size_t single_data_start=0;
+    size_t single_data_length=0;
+    for(size_t i=0; i<encoding_length; i++)
+    {
+        if(encoding[i]=='0' && (encoding[i+1]=='x' || encoding[i+1]=='X'))
+        {
+            if(single_data_length>0)
+            {
+                if(value !=NULL && value_length > len)
+                {
+                    value[len]=hbase16_decode_single_data(&encoding[single_data_start],single_data_length);
+                }
+                len++;
+            }
+            //跳过0x,0X
+            i+=2;
+            single_data_start=i;
+            single_data_length=0;
+            continue;
+        }
+        if(encoding[i]==' ')
+        {
+            //跳过空格
+            if(single_data_length>0)
+            {
+                if(value !=NULL && value_length > len)
+                {
+                    value[len]=hbase16_decode_single_data(&encoding[single_data_start],single_data_length);
+                }
+                len++;
+            }
+            i++;
+            single_data_start=i;
+            single_data_length=0;
+            continue;
+        }
+        if(single_data_length >=1)
+        {
+            /*
+             * 已经满足两个有效字符
+             */
+            single_data_length++;
+            {
+                if(value !=NULL && value_length > len)
+                {
+                    value[len]=hbase16_decode_single_data(&encoding[single_data_start],single_data_length);
+                }
+                len++;
+            }
+            i++;
+            single_data_start=i;
+            single_data_length=0;
+        }
+        single_data_length++;
+    }
+    return len;
+}
+
+static char hbase16_encode_single_char(uint8_t code)
+{
+    if(code >= 0x10)
+    {
+        //异常情况不处理，返回空格
+        return ' ';
+    }
+    if(code < 0xA)
+    {
+        return code-0x0+'0';
+    }
+    else
+    {
+        return code-0xA+'A';
+    }
+}
+
+size_t hbase16_encode(char *encoding,size_t encoding_length,const uint8_t*value,size_t value_length)
+{
+    if(value==NULL || value_length==0)
+    {
+        return 0;
+    }
+    size_t bytes_encode=0;
+    for(size_t i=0; i<value_length; i++)
+    {
+        if(encoding!=NULL)
+        {
+            if((bytes_encode+1)*2 >= encoding_length)
+            {
+                break;
+            }
+            encoding[i*2+0]=hbase16_encode_single_char((value[i]>>4)&0xF);
+            encoding[i*2+1]=hbase16_encode_single_char((value[i]>>0)&0xF);
+        }
+        bytes_encode++;
+    }
+    return bytes_encode*2;//每个字符编码为2个字符
+}
+
+size_t hbase16_encode_with_null_terminator(char *encoding,size_t encoding_length,const uint8_t*value,size_t value_length)
+{
+    size_t len=hbase16_encode(encoding,encoding_length,value,value_length);
+    len+=1;//添加'\0'字符长度
+    if(len > encoding_length)
+    {
+        len=encoding_length;
+    }
+    if(encoding!=NULL)
+    {
+        encoding[len-1]='\0';
+    }
+    return len;
+}

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbase16.h

@@ -0,0 +1,60 @@
+/***************************************************************
+ * Name:      hbase16.h
+ * Purpose:   声明base16接口。
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HBASE16_H__
+#define __HBASE16_H__
+#include "stdint.h"
+#include "stdbool.h"
+#include "stdlib.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+/** \brief 解码
+ *
+ * \param value uint8_t* 解码数据缓冲区，当其为NULL时仅返回长度不做处理
+ * \param value_length size_t 解码数据缓冲区长度
+ * \param encoding const char* 待解码数据缓冲区，需要确保内容为标准base16编码，否则可能出错。
+ * \param encoding_length size_t 待解码数据缓冲区长度，不含'\0' 字符
+ * \return size_t 解码长度
+ *
+ */
+size_t hbase16_decode(uint8_t *value,size_t value_length,const char *encoding,size_t encoding_length);
+
+/** \brief 编码
+ *
+ * \param encoding char* 编码数据缓冲区，当其为NULL时仅返回长度不做处理
+ * \param encoding_length size_t 编码数据缓冲区长度
+ * \param uint8_t*value const 待编码数据缓冲区
+ * \param value_length size_t 待编码数据缓冲区长度
+ * \return size_t 编码长度，注意：本函数不会添加'\0',也不会将'\0'计入长度。
+ *
+ */
+size_t hbase16_encode(char *encoding,size_t encoding_length,const uint8_t*value,size_t value_length);
+
+/** \brief 编码
+ *
+ * \param encoding char* 编码数据缓冲区
+ * \param encoding_length size_t 编码数据缓冲区长度
+ * \param uint8_t*value const 待编码数据缓冲区
+ * \param value_length size_t 待编码数据缓冲区长度
+ * \return size_t 编码长度(含'\0')
+ *
+ */
+size_t hbase16_encode_with_null_terminator(char *encoding,size_t encoding_length,const uint8_t*value,size_t value_length);
+
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // __HBASE16_H__
+

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbase64.c

@@ -202,7 +202,7 @@ size_t hbase64_get_encoding_length(const char *encoding)
     size_t ret=0;
     if(encoding!=NULL)
     {
-        while((*encoding)!='\0')
+        while(((*encoding)!='\0') && ((*encoding)!='\n') && ((*encoding)!='\r'))
         {
             encoding++;
             ret++;

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbase64.h

@@ -52,7 +52,7 @@ size_t hbase64_encode_with_null_terminator(char *encoding,size_t encoding_length
 
 /** \brief 获取base64编码字符串长度，通常用于解码
  *
- * \param encoding const char* base64编码字符串（以'\0'结尾的字符串）
+ * \param encoding const char* base64编码字符串（以'\0'结尾的字符串）,回车符或者换行符也视为终止.
  * \return size_t base64编码字符串长度
  *
  */

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbcc.c

@@ -0,0 +1,27 @@
+/***************************************************************
+ * Name:      hbcc.c
+ * Purpose:   实现hbcc接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-13
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "hbcc.h"
+
+uint8_t hbcc_calculate(const uint8_t *data,size_t datalen)
+{
+    uint8_t ret=0;
+    if(data!=NULL && datalen > 0)
+    {
+        for(size_t i=0; i<datalen; i++)
+        {
+            ret ^= data[i];
+        }
+    }
+    return ret;
+}
+
+bool hbcc_check(const uint8_t *data,size_t datalen,uint8_t check)
+{
+    return check==hbcc_calculate(data,datalen);
+}

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbcc.h

@@ -0,0 +1,47 @@
+/***************************************************************
+ * Name:      hbcc.h
+ * Purpose:   声明hbcc接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-13
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HBCC_H__
+#define __HBCC_H__
+#include "stdint.h"
+#include "stdbool.h"
+#include "stdlib.h"
+/*
+ * BCC校验，又称异或检验。将数据段的每一个字节异或可得出校验。
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+/** \brief bcc 计算
+ *
+ * \param data const uint8_t* 数据指针
+ * \param datalen size_t 数据长度
+ * \return uint8_t 校验结果
+ *
+ */
+uint8_t hbcc_calculate(const uint8_t *data,size_t datalen);
+
+/** \brief bcc 校验
+ *
+ * \param data const uint8_t* 数据指针
+ * \param datalen size_t 数据长度
+ * \param check uint8_t 校验值
+ * \return bool 是否校验成功
+ *
+ */
+bool hbcc_check(const uint8_t *data,size_t datalen,uint8_t check);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HBCC_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum.c

@@ -0,0 +1,18 @@
+/***************************************************************
+ * Name:      hbignum.c
+ * Purpose:   实现hbignum接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "hbignum.h"
+
+#include "hbignum/huint128.c"
+#include "hbignum/huint256.c"
+#include "hbignum/huint512.c"
+#include "hbignum/huint1024.c"
+#include "hbignum/huint2048.c"
+#include "hbignum/huint4096.c"
+#include "hbignum/huint8192.c"
+

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum.h

@@ -0,0 +1,30 @@
+/***************************************************************
+ * Name:      hbignum.h
+ * Purpose:   声明hbignum接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HBIGNUM_H__
+#define __HBIGNUM_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#include "hbignum/huint128.h"
+#include "hbignum/huint256.h"
+#include "hbignum/huint512.h"
+#include "hbignum/huint1024.h"
+#include "hbignum/huint2048.h"
+#include "hbignum/huint4096.h"
+#include "hbignum/huint8192.h"
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HBIGNUM_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint1024.c

@@ -0,0 +1,711 @@
+/***************************************************************
+ * Name:      huint1024.c
+ * Purpose:   实现huint1024接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "huint1024.h"
+
+void huint1024_load(huint1024_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[i+3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[i+2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[i+1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[i+0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint1024_load_be(huint1024_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    if(bytes_count > sizeof(num->val))
+    {
+        //丢弃高位
+        size_t bytes_overflow=bytes_count-sizeof(huint1024_t);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint1024_load_uint32(huint1024_t *num,uint32_t uint32_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=uint32_num;
+
+    //清零剩余值
+    for(size_t i=(1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint1024_load_uint64(huint1024_t *num,uint64_t uint64_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=((uint64_num>>0)&0xFFFFFFFF);
+    num->val[1]=((uint64_num>>32)&0xFFFFFFFF);
+
+    //清零剩余值
+    for(size_t i=(2); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint1024_store(huint1024_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[sizeof(num->val[0])*i+0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[sizeof(num->val[0])*i+1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[sizeof(num->val[0])*i+2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[sizeof(num->val[0])*i+3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint1024_store_be(huint1024_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    if(bytes_count > sizeof(num->val))
+    {
+        //高位置零
+        size_t bytes_overflow=bytes_count-sizeof(huint1024_t);
+        memset(bytes,0,bytes_overflow);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint1024_store_uint32(const huint1024_t *num,uint32_t* uint32_num)
+{
+    if(num==NULL || uint32_num ==NULL)
+    {
+        return;
+    }
+    (*uint32_num)=num->val[0];
+}
+
+void huint1024_store_uint64(const huint1024_t *num,uint64_t* uint64_num)
+{
+    if(num==NULL || uint64_num ==NULL)
+    {
+        return;
+    }
+    (*uint64_num)=num->val[0]+(((uint64_t)num->val[1]) << 32);
+}
+
+void huint1024_copy(huint1024_t *dst,const huint1024_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=src->val[i];
+    }
+}
+
+void huint1024_bitwise_not(huint1024_t *dst,const huint1024_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(~src->val[i]);
+    }
+}
+
+void huint1024_bitwise_and(huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] & src2->val[i]);
+    }
+}
+
+void huint1024_bitwise_or(huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] | src2->val[i]);
+    }
+}
+
+void huint1024_bitwise_xor(huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] ^ src2->val[i]);
+    }
+}
+
+int huint1024_compare(const huint1024_t *src1,const huint1024_t *src2)
+{
+    if(src1==NULL || src2==NULL)
+    {
+        return -2;
+    }
+    for(int i=((sizeof(src1->val)/sizeof(src2->val[0]))-1); i>=0 ; i--)
+    {
+        if(src1->val[i] > src2->val[i])
+        {
+            return 1;
+        }
+        if(src1->val[i] < src2->val[i])
+        {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+void huint1024_complement(huint1024_t *dst,const huint1024_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    //取反
+    huint1024_bitwise_not(dst,src);
+
+    //加1
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        if(i==0)
+        {
+            temp+=((uint64_t)dst->val[i])+1;
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+        else
+        {
+            temp+=((uint64_t)dst->val[i]);
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+    }
+}
+
+static size_t huint1024_left_shift_internal(huint1024_t *dst,const huint1024_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((((uint64_t)src->val[i]) << (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)temp;
+        temp >>= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+void huint1024_left_shift(huint1024_t *dst,const huint1024_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT1024_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint1024_load_uint32(dst,0);
+        return;
+    }
+
+    huint1024_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint1024_left_shift_internal(dst,dst,bits);
+    }
+}
+
+static size_t huint1024_right_shift_internal(huint1024_t *dst,const huint1024_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(int i=((sizeof(dst->val)/sizeof(dst->val[0]))-1); i>=0 ; i--)
+    {
+        temp = (((((uint64_t)src->val[i]) << (sizeof(uint32_t)*8)) >> (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)(temp >> (sizeof(uint32_t)*8));
+        temp <<= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+
+void huint1024_right_shift(huint1024_t *dst,const huint1024_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT1024_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint1024_load_uint32(dst,0);
+        return;
+    }
+
+    huint1024_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint1024_right_shift_internal(dst,dst,bits);
+    }
+}
+
+void huint1024_bit_set(huint1024_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT1024_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] |= (1ULL << (bits%(sizeof(dst->val[0])*8)));
+    }
+}
+
+void huint1024_bit_clear(huint1024_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT1024_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] &= (~(1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+}
+
+bool huint1024_bit(const huint1024_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT1024_BITS_COUNT)
+        {
+            return false;
+        }
+
+        return 0!=(dst->val[bits/(sizeof(dst->val[0])*8)] & (1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+
+    return false;
+}
+
+size_t huint1024_clz(const huint1024_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT1024_BITS_COUNT; i++)
+        {
+            if(huint1024_bit(dst,HUINT1024_BITS_COUNT-1-i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT1024_BITS_COUNT;
+}
+
+size_t huint1024_ctz(const huint1024_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT1024_BITS_COUNT; i++)
+        {
+            if(huint1024_bit(dst,i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT1024_BITS_COUNT;
+}
+
+void huint1024_add(huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((uint64_t)src1->val[i])+src2->val[i]+temp;
+        dst->val[i]=(uint32_t)temp;
+        temp>>=32;
+    }
+}
+
+void huint1024_sub(huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    //求补码
+    huint1024_complement(dst,src2);
+
+    //对补码进行加
+    huint1024_add(dst,dst,src1);
+}
+
+void huint1024_mul(huint1024_t *state,huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2)
+{
+    if(state == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint1024_load_uint32(dst,0);
+    size_t clz=huint1024_clz(src2);
+    size_t ctz=huint1024_ctz(src2);
+    for(size_t i=ctz; i < (HUINT1024_BITS_COUNT-clz); i++)
+    {
+        if(huint1024_bit(src2,i))
+        {
+            //当前位是1, src1左移后累加至结果
+            huint1024_left_shift(state,src1,i);
+            huint1024_add(dst,dst,state);
+        }
+    }
+}
+
+void huint1024_div(huint1024_t *state,huint1024_t *state1,huint1024_t *state2,huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+
+    huint1024_load_uint32(dst,0);
+    if(huint1024_compare(src2,state)==0 )
+    {
+        huint1024_load_uint32(state,0);
+        //除0错误
+        return;
+    }
+
+    if(huint1024_compare(src2,src1) > 0)
+    {
+        //除数大于被除数
+        huint1024_copy(state,src1);
+        huint1024_load_uint32(dst,0);
+        return;
+    }
+
+    size_t clz1=huint1024_clz(src1);
+    size_t clz2=huint1024_clz(src2);
+    if(clz1 > clz2)
+    {
+        //除数大于被除数
+        huint1024_copy(state,src1);
+        huint1024_load_uint32(dst,0);
+        return;
+    }
+
+    huint1024_copy(state,src1);
+
+    for(size_t i=0; i<= clz2-clz1; i++)
+    {
+        huint1024_left_shift(state1,src2,(clz2-clz1)-i);
+        if(huint1024_compare(state,state1) >= 0)
+        {
+            //被除数大于左移后的除数，直接相减并将相应位置1
+            huint1024_sub(state2,state,state1);
+            huint1024_bit_set(dst,(clz2-clz1)-i);
+            //余数保存至state
+            huint1024_copy(state,state2);
+        }
+    }
+
+}
+
+void huint1024_power(huint1024_t *state,huint1024_t *state1,huint1024_t *state2,huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint1024_load_uint32(state,0);
+    huint1024_load_uint32(dst,1);
+    if(huint1024_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint1024_load_uint32(dst,0);
+        return;
+    }
+    if(huint1024_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint1024_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint1024_clz(src2);
+    huint1024_copy(state,src1);
+    for(size_t i=0; i<(HUINT1024_BITS_COUNT - clz2); i++)
+    {
+        if(huint1024_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint1024_mul(state1,state2,dst,state);
+            huint1024_copy(dst,state2);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint1024_mul(state1,state2,state,state);
+        huint1024_copy(state,state2);
+    }
+
+}
+
+void huint1024_power_mod(huint1024_t *state,huint1024_t *state1,huint1024_t *state2,huint1024_t *state3,huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2,const huint1024_t *src3)
+{
+    if(state == NULL || state1==NULL || state2== NULL || state3 == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint1024_load_uint32(state,0);
+    huint1024_load_uint32(dst,1);
+    if(huint1024_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint1024_load_uint32(dst,0);
+        return;
+    }
+    if(huint1024_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint1024_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint1024_clz(src2);
+    huint1024_copy(state,src1);
+    for(size_t i=0; i<(HUINT1024_BITS_COUNT - clz2); i++)
+    {
+        if(huint1024_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint1024_mul(state1,state2,dst,state);
+            huint1024_copy(dst,state2);
+
+            //对dst提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+            huint1024_div(dst,state1,state2,state3,dst,src3);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint1024_mul(state1,state2,state,state);
+        huint1024_copy(state,state2);
+
+        //对state提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+        huint1024_div(state,state1,state2,state3,state,src3);
+    }
+
+}

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint1024.h

@@ -0,0 +1,294 @@
+/***************************************************************
+ * Name:      huint1024.h
+ * Purpose:   声明huint1024接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HUINT1024_H__
+#define __HUINT1024_H__
+#include "stdint.h"
+#include "stdbool.h"
+#include "stdlib.h"
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#define HUINT1024_BITS_COUNT 1024
+
+typedef struct huint1024 huint1024_t;
+struct huint1024
+{
+    uint32_t val[(HUINT1024_BITS_COUNT/(sizeof(uint32_t)*8))+((HUINT1024_BITS_COUNT%(sizeof(uint32_t)*8))!=0?1:0)];
+};
+
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint1024_t* 大数指针
+ * \param bytes const uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint1024_load(huint1024_t *num,const uint8_t *bytes,size_t bytes_count);
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint1024_t* 大数指针
+ * \param bytes const uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint1024_load_be(huint1024_t *num,const uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint1024_t* 大数
+ * \param uint32_num uint32_t 数字
+ *
+ */
+void huint1024_load_uint32(huint1024_t *num,uint32_t uint32_num);
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint1024_t* 大数
+ * \param uint64_num uint64_t 数字
+ *
+ */
+void huint1024_load_uint64(huint1024_t *num,uint64_t uint64_num);
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint1024_t* 大数指针
+ * \param bytes uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint1024_store(huint1024_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint1024_t* 大数指针
+ * \param bytes uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint1024_store_be(huint1024_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数数字
+ *
+ * \param num huint1024_t* 大数
+ * \param uint32_num uint32_t* 数字
+ *
+ */
+void huint1024_store_uint32(const huint1024_t *num,uint32_t* uint32_num);
+
+/** \brief 保存大数数字
+ *
+ * \param num huint1024_t* 大数
+ * \param uint64_num uint64_t* 数字
+ *
+ */
+void huint1024_store_uint64(const huint1024_t *num,uint64_t* uint64_num);
+
+/** \brief 复制
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param src const huint1024_t* 源大数
+ *
+ */
+void huint1024_copy(huint1024_t *dst,const huint1024_t *src);
+
+/** \brief 按位非
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param src const huint1024_t* 源大数
+ *
+ */
+void huint1024_bitwise_not(huint1024_t *dst,const huint1024_t *src);
+
+/** \brief 按位与
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param src1 const huint1024_t* 源大数1
+ * \param src2 const huint1024_t* 源大数2
+ *
+ */
+void huint1024_bitwise_and(huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2);
+
+/** \brief 按位或
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param src1 const huint1024_t* 源大数1
+ * \param src2 const huint1024_t* 源大数2
+ *
+ */
+void huint1024_bitwise_or(huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2);
+
+/** \brief 按位异或
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param src1 const huint1024_t* 源大数1
+ * \param src2 const huint1024_t* 源大数2
+ *
+ */
+void huint1024_bitwise_xor(huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2);
+
+/** \brief 比较
+ *
+ * \param src1 const huint1024_t* 源大数1
+ * \param src2 const huint1024_t* 源大数2
+ * \return int 0=相等，1=源大数1大于源大数2,-1表示源大数2大于源大数1，-2=参数出错
+ *
+ */
+int huint1024_compare(const huint1024_t *src1,const huint1024_t *src2);
+
+/** \brief 求补码
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param src const huint1024_t* 源大数
+ *
+ */
+void huint1024_complement(huint1024_t *dst,const huint1024_t *src);
+
+/** \brief 左移
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param src const huint1024_t* 源大数
+ * \param bits size_t 左移位数
+ *
+ */
+void huint1024_left_shift(huint1024_t *dst,const huint1024_t *src,size_t bits);
+
+/** \brief 右移
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param src const huint1024_t* 源大数
+ * \param bits size_t 右移位数
+ *
+ */
+void huint1024_right_shift(huint1024_t *dst,const huint1024_t *src,size_t bits);
+
+/** \brief 设置位
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint1024_bit_set(huint1024_t *dst,size_t bits);
+
+/** \brief 清除位
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint1024_bit_clear(huint1024_t *dst,size_t bits);
+
+/** \brief 获取位
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param bits size_t 位
+ * \return bool 位上的值
+ *
+ */
+bool huint1024_bit(const huint1024_t *dst,size_t bits);
+
+/** \brief 前导0的个数
+ *
+ * \param dst huint1024_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint1024_clz(const huint1024_t *dst);
+
+/** \brief 尾部0的个数
+ *
+ * \param dst huint1024_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint1024_ctz(const huint1024_t *dst);
+
+/** \brief 加
+ *
+ * \param dst huint1024_t* 目标大数
+ * \param src1 const huint1024_t* 源大数1
+ * \param src2 const huint1024_t* 源大数2
+ *
+ */
+void huint1024_add(huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2);
+
+
+/** \brief 减
+ *
+ * \param dst huint1024_t* 目标大数,dst=src1-src2
+ * \param src1 const huint1024_t* 源大数1
+ * \param src2 const huint1024_t* 源大数2
+ *
+ */
+void huint1024_sub(huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2);
+
+/** \brief 乘
+ *
+ * \param state huint1024_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint1024_t* 目标大数,dst=src1*src2
+ * \param src1 const huint1024_t* 源大数1
+ * \param src2 const huint1024_t* 源大数2
+ *
+ */
+void huint1024_mul(huint1024_t *state,huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2);
+
+
+/** \brief 除
+ *
+ * \param state huint1024_t* 状态值，存储余数。state=src1%src2
+ * \param state1 huint1024_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint1024_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint1024_t* 目标大数,dst=src1/src2
+ * \param src1 const huint1024_t* 源大数1
+ * \param src2 const huint1024_t* 源大数2
+ *
+ */
+void huint1024_div(huint1024_t *state,huint1024_t *state1,huint1024_t *state2,huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2);
+
+
+/** \brief 幂函数
+ *
+ * \param state huint1024_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint1024_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint1024_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint1024_t* 目标大数,dst=src1的src2次方
+ * \param src1 const huint1024_t* 源大数1
+ * \param src2 const huint1024_t* 源大数2
+ *
+ */
+void huint1024_power(huint1024_t *state,huint1024_t *state1,huint1024_t *state2,huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2);
+
+
+/** \brief 幂取模函数（常用于RSA等加密算法）
+ *
+ * \param state huint1024_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint1024_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint1024_t* 状态值，用于中间状态存储,不可为空
+ * \param state3 huint1024_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint1024_t* 目标大数,dst=src1的src2次方对src3取模
+ * \param src1 const huint1024_t* 源大数1
+ * \param src2 const huint1024_t* 源大数2
+ * \param src3 const huint1024_t* 源大数3
+ *
+ */
+void huint1024_power_mod(huint1024_t *state,huint1024_t *state1,huint1024_t *state2,huint1024_t *state3,huint1024_t *dst,const huint1024_t *src1,const huint1024_t *src2,const huint1024_t *src3);
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HUINT1024_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint128.c

@@ -0,0 +1,711 @@
+/***************************************************************
+ * Name:      huint128.c
+ * Purpose:   实现huint128接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "huint128.h"
+
+void huint128_load(huint128_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[i+3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[i+2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[i+1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[i+0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint128_load_be(huint128_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    if(bytes_count > sizeof(num->val))
+    {
+        //丢弃高位
+        size_t bytes_overflow=bytes_count-sizeof(huint128_t);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint128_load_uint32(huint128_t *num,uint32_t uint32_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=uint32_num;
+
+    //清零剩余值
+    for(size_t i=(1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint128_load_uint64(huint128_t *num,uint64_t uint64_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=((uint64_num>>0)&0xFFFFFFFF);
+    num->val[1]=((uint64_num>>32)&0xFFFFFFFF);
+
+    //清零剩余值
+    for(size_t i=(2); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint128_store(huint128_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[sizeof(num->val[0])*i+0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[sizeof(num->val[0])*i+1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[sizeof(num->val[0])*i+2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[sizeof(num->val[0])*i+3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint128_store_be(huint128_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    if(bytes_count > sizeof(num->val))
+    {
+        //高位置零
+        size_t bytes_overflow=bytes_count-sizeof(huint128_t);
+        memset(bytes,0,bytes_overflow);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint128_store_uint32(const huint128_t *num,uint32_t* uint32_num)
+{
+    if(num==NULL || uint32_num ==NULL)
+    {
+        return;
+    }
+    (*uint32_num)=num->val[0];
+}
+
+void huint128_store_uint64(const huint128_t *num,uint64_t* uint64_num)
+{
+    if(num==NULL || uint64_num ==NULL)
+    {
+        return;
+    }
+    (*uint64_num)=num->val[0]+(((uint64_t)num->val[1]) << 32);
+}
+
+void huint128_copy(huint128_t *dst,const huint128_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=src->val[i];
+    }
+}
+
+void huint128_bitwise_not(huint128_t *dst,const huint128_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(~src->val[i]);
+    }
+}
+
+void huint128_bitwise_and(huint128_t *dst,const huint128_t *src1,const huint128_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] & src2->val[i]);
+    }
+}
+
+void huint128_bitwise_or(huint128_t *dst,const huint128_t *src1,const huint128_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] | src2->val[i]);
+    }
+}
+
+void huint128_bitwise_xor(huint128_t *dst,const huint128_t *src1,const huint128_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] ^ src2->val[i]);
+    }
+}
+
+int huint128_compare(const huint128_t *src1,const huint128_t *src2)
+{
+    if(src1==NULL || src2==NULL)
+    {
+        return -2;
+    }
+    for(int i=((sizeof(src1->val)/sizeof(src2->val[0]))-1); i>=0 ; i--)
+    {
+        if(src1->val[i] > src2->val[i])
+        {
+            return 1;
+        }
+        if(src1->val[i] < src2->val[i])
+        {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+void huint128_complement(huint128_t *dst,const huint128_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    //取反
+    huint128_bitwise_not(dst,src);
+
+    //加1
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        if(i==0)
+        {
+            temp+=((uint64_t)dst->val[i])+1;
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+        else
+        {
+            temp+=((uint64_t)dst->val[i]);
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+    }
+}
+
+static size_t huint128_left_shift_internal(huint128_t *dst,const huint128_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((((uint64_t)src->val[i]) << (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)temp;
+        temp >>= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+void huint128_left_shift(huint128_t *dst,const huint128_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT128_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint128_load_uint32(dst,0);
+        return;
+    }
+
+    huint128_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint128_left_shift_internal(dst,dst,bits);
+    }
+}
+
+static size_t huint128_right_shift_internal(huint128_t *dst,const huint128_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(int i=((sizeof(dst->val)/sizeof(dst->val[0]))-1); i>=0 ; i--)
+    {
+        temp = (((((uint64_t)src->val[i]) << (sizeof(uint32_t)*8)) >> (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)(temp >> (sizeof(uint32_t)*8));
+        temp <<= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+
+void huint128_right_shift(huint128_t *dst,const huint128_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT128_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint128_load_uint32(dst,0);
+        return;
+    }
+
+    huint128_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint128_right_shift_internal(dst,dst,bits);
+    }
+}
+
+void huint128_bit_set(huint128_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT128_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] |= (1ULL << (bits%(sizeof(dst->val[0])*8)));
+    }
+}
+
+void huint128_bit_clear(huint128_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT128_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] &= (~(1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+}
+
+bool huint128_bit(const huint128_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT128_BITS_COUNT)
+        {
+            return false;
+        }
+
+        return 0!=(dst->val[bits/(sizeof(dst->val[0])*8)] & (1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+
+    return false;
+}
+
+size_t huint128_clz(const huint128_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT128_BITS_COUNT; i++)
+        {
+            if(huint128_bit(dst,HUINT128_BITS_COUNT-1-i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT128_BITS_COUNT;
+}
+
+size_t huint128_ctz(const huint128_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT128_BITS_COUNT; i++)
+        {
+            if(huint128_bit(dst,i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT128_BITS_COUNT;
+}
+
+void huint128_add(huint128_t *dst,const huint128_t *src1,const huint128_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((uint64_t)src1->val[i])+src2->val[i]+temp;
+        dst->val[i]=(uint32_t)temp;
+        temp>>=32;
+    }
+}
+
+void huint128_sub(huint128_t *dst,const huint128_t *src1,const huint128_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    //求补码
+    huint128_complement(dst,src2);
+
+    //对补码进行加
+    huint128_add(dst,dst,src1);
+}
+
+void huint128_mul(huint128_t *state,huint128_t *dst,const huint128_t *src1,const huint128_t *src2)
+{
+    if(state == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint128_load_uint32(dst,0);
+    size_t clz=huint128_clz(src2);
+    size_t ctz=huint128_ctz(src2);
+    for(size_t i=ctz; i < (HUINT128_BITS_COUNT-clz); i++)
+    {
+        if(huint128_bit(src2,i))
+        {
+            //当前位是1, src1左移后累加至结果
+            huint128_left_shift(state,src1,i);
+            huint128_add(dst,dst,state);
+        }
+    }
+}
+
+void huint128_div(huint128_t *state,huint128_t *state1,huint128_t *state2,huint128_t *dst,const huint128_t *src1,const huint128_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+
+    huint128_load_uint32(dst,0);
+    if(huint128_compare(src2,state)==0 )
+    {
+        huint128_load_uint32(state,0);
+        //除0错误
+        return;
+    }
+
+    if(huint128_compare(src2,src1) > 0)
+    {
+        //除数大于被除数
+        huint128_copy(state,src1);
+        huint128_load_uint32(dst,0);
+        return;
+    }
+
+    size_t clz1=huint128_clz(src1);
+    size_t clz2=huint128_clz(src2);
+    if(clz1 > clz2)
+    {
+        //除数大于被除数
+        huint128_copy(state,src1);
+        huint128_load_uint32(dst,0);
+        return;
+    }
+
+    huint128_copy(state,src1);
+
+    for(size_t i=0; i<= clz2-clz1; i++)
+    {
+        huint128_left_shift(state1,src2,(clz2-clz1)-i);
+        if(huint128_compare(state,state1) >= 0)
+        {
+            //被除数大于左移后的除数，直接相减并将相应位置1
+            huint128_sub(state2,state,state1);
+            huint128_bit_set(dst,(clz2-clz1)-i);
+            //余数保存至state
+            huint128_copy(state,state2);
+        }
+    }
+
+}
+
+void huint128_power(huint128_t *state,huint128_t *state1,huint128_t *state2,huint128_t *dst,const huint128_t *src1,const huint128_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint128_load_uint32(state,0);
+    huint128_load_uint32(dst,1);
+    if(huint128_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint128_load_uint32(dst,0);
+        return;
+    }
+    if(huint128_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint128_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint128_clz(src2);
+    huint128_copy(state,src1);
+    for(size_t i=0; i<(HUINT128_BITS_COUNT - clz2); i++)
+    {
+        if(huint128_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint128_mul(state1,state2,dst,state);
+            huint128_copy(dst,state2);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint128_mul(state1,state2,state,state);
+        huint128_copy(state,state2);
+    }
+
+}
+
+void huint128_power_mod(huint128_t *state,huint128_t *state1,huint128_t *state2,huint128_t *state3,huint128_t *dst,const huint128_t *src1,const huint128_t *src2,const huint128_t *src3)
+{
+    if(state == NULL || state1==NULL || state2== NULL || state3 == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint128_load_uint32(state,0);
+    huint128_load_uint32(dst,1);
+    if(huint128_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint128_load_uint32(dst,0);
+        return;
+    }
+    if(huint128_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint128_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint128_clz(src2);
+    huint128_copy(state,src1);
+    for(size_t i=0; i<(HUINT128_BITS_COUNT - clz2); i++)
+    {
+        if(huint128_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint128_mul(state1,state2,dst,state);
+            huint128_copy(dst,state2);
+
+            //对dst提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+            huint128_div(dst,state1,state2,state3,dst,src3);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint128_mul(state1,state2,state,state);
+        huint128_copy(state,state2);
+
+        //对state提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+        huint128_div(state,state1,state2,state3,state,src3);
+    }
+
+}

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint128.h

@@ -0,0 +1,294 @@
+/***************************************************************
+ * Name:      huint128.h
+ * Purpose:   声明huint128接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HUINT128_H__
+#define __HUINT128_H__
+#include "stdint.h"
+#include "stdbool.h"
+#include "stdlib.h"
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#define HUINT128_BITS_COUNT 128
+
+typedef struct huint128 huint128_t;
+struct huint128
+{
+    uint32_t val[(HUINT128_BITS_COUNT/(sizeof(uint32_t)*8))+((HUINT128_BITS_COUNT%(sizeof(uint32_t)*8))!=0?1:0)];
+};
+
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint128_t* 大数指针
+ * \param bytes const uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint128_load(huint128_t *num,const uint8_t *bytes,size_t bytes_count);
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint128_t* 大数指针
+ * \param bytes const uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint128_load_be(huint128_t *num,const uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint128_t* 大数
+ * \param uint32_num uint32_t 数字
+ *
+ */
+void huint128_load_uint32(huint128_t *num,uint32_t uint32_num);
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint128_t* 大数
+ * \param uint64_num uint64_t 数字
+ *
+ */
+void huint128_load_uint64(huint128_t *num,uint64_t uint64_num);
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint128_t* 大数指针
+ * \param bytes uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint128_store(huint128_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint128_t* 大数指针
+ * \param bytes uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint128_store_be(huint128_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数数字
+ *
+ * \param num huint128_t* 大数
+ * \param uint32_num uint32_t* 数字
+ *
+ */
+void huint128_store_uint32(const huint128_t *num,uint32_t* uint32_num);
+
+/** \brief 保存大数数字
+ *
+ * \param num huint128_t* 大数
+ * \param uint64_num uint64_t* 数字
+ *
+ */
+void huint128_store_uint64(const huint128_t *num,uint64_t* uint64_num);
+
+/** \brief 复制
+ *
+ * \param dst huint128_t* 目标大数
+ * \param src const huint128_t* 源大数
+ *
+ */
+void huint128_copy(huint128_t *dst,const huint128_t *src);
+
+/** \brief 按位非
+ *
+ * \param dst huint128_t* 目标大数
+ * \param src const huint128_t* 源大数
+ *
+ */
+void huint128_bitwise_not(huint128_t *dst,const huint128_t *src);
+
+/** \brief 按位与
+ *
+ * \param dst huint128_t* 目标大数
+ * \param src1 const huint128_t* 源大数1
+ * \param src2 const huint128_t* 源大数2
+ *
+ */
+void huint128_bitwise_and(huint128_t *dst,const huint128_t *src1,const huint128_t *src2);
+
+/** \brief 按位或
+ *
+ * \param dst huint128_t* 目标大数
+ * \param src1 const huint128_t* 源大数1
+ * \param src2 const huint128_t* 源大数2
+ *
+ */
+void huint128_bitwise_or(huint128_t *dst,const huint128_t *src1,const huint128_t *src2);
+
+/** \brief 按位异或
+ *
+ * \param dst huint128_t* 目标大数
+ * \param src1 const huint128_t* 源大数1
+ * \param src2 const huint128_t* 源大数2
+ *
+ */
+void huint128_bitwise_xor(huint128_t *dst,const huint128_t *src1,const huint128_t *src2);
+
+/** \brief 比较
+ *
+ * \param src1 const huint128_t* 源大数1
+ * \param src2 const huint128_t* 源大数2
+ * \return int 0=相等，1=源大数1大于源大数2,-1表示源大数2大于源大数1，-2=参数出错
+ *
+ */
+int huint128_compare(const huint128_t *src1,const huint128_t *src2);
+
+/** \brief 求补码
+ *
+ * \param dst huint128_t* 目标大数
+ * \param src const huint128_t* 源大数
+ *
+ */
+void huint128_complement(huint128_t *dst,const huint128_t *src);
+
+/** \brief 左移
+ *
+ * \param dst huint128_t* 目标大数
+ * \param src const huint128_t* 源大数
+ * \param bits size_t 左移位数
+ *
+ */
+void huint128_left_shift(huint128_t *dst,const huint128_t *src,size_t bits);
+
+/** \brief 右移
+ *
+ * \param dst huint128_t* 目标大数
+ * \param src const huint128_t* 源大数
+ * \param bits size_t 右移位数
+ *
+ */
+void huint128_right_shift(huint128_t *dst,const huint128_t *src,size_t bits);
+
+/** \brief 设置位
+ *
+ * \param dst huint128_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint128_bit_set(huint128_t *dst,size_t bits);
+
+/** \brief 清除位
+ *
+ * \param dst huint128_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint128_bit_clear(huint128_t *dst,size_t bits);
+
+/** \brief 获取位
+ *
+ * \param dst huint128_t* 目标大数
+ * \param bits size_t 位
+ * \return bool 位上的值
+ *
+ */
+bool huint128_bit(const huint128_t *dst,size_t bits);
+
+/** \brief 前导0的个数
+ *
+ * \param dst huint128_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint128_clz(const huint128_t *dst);
+
+/** \brief 尾部0的个数
+ *
+ * \param dst huint128_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint128_ctz(const huint128_t *dst);
+
+/** \brief 加
+ *
+ * \param dst huint128_t* 目标大数
+ * \param src1 const huint128_t* 源大数1
+ * \param src2 const huint128_t* 源大数2
+ *
+ */
+void huint128_add(huint128_t *dst,const huint128_t *src1,const huint128_t *src2);
+
+
+/** \brief 减
+ *
+ * \param dst huint128_t* 目标大数,dst=src1-src2
+ * \param src1 const huint128_t* 源大数1
+ * \param src2 const huint128_t* 源大数2
+ *
+ */
+void huint128_sub(huint128_t *dst,const huint128_t *src1,const huint128_t *src2);
+
+/** \brief 乘
+ *
+ * \param state huint128_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint128_t* 目标大数,dst=src1*src2
+ * \param src1 const huint128_t* 源大数1
+ * \param src2 const huint128_t* 源大数2
+ *
+ */
+void huint128_mul(huint128_t *state,huint128_t *dst,const huint128_t *src1,const huint128_t *src2);
+
+
+/** \brief 除
+ *
+ * \param state huint128_t* 状态值，存储余数。state=src1%src2
+ * \param state1 huint128_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint128_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint128_t* 目标大数,dst=src1/src2
+ * \param src1 const huint128_t* 源大数1
+ * \param src2 const huint128_t* 源大数2
+ *
+ */
+void huint128_div(huint128_t *state,huint128_t *state1,huint128_t *state2,huint128_t *dst,const huint128_t *src1,const huint128_t *src2);
+
+
+/** \brief 幂函数
+ *
+ * \param state huint128_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint128_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint128_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint128_t* 目标大数,dst=src1的src2次方
+ * \param src1 const huint128_t* 源大数1
+ * \param src2 const huint128_t* 源大数2
+ *
+ */
+void huint128_power(huint128_t *state,huint128_t *state1,huint128_t *state2,huint128_t *dst,const huint128_t *src1,const huint128_t *src2);
+
+
+/** \brief 幂取模函数（常用于RSA等加密算法）
+ *
+ * \param state huint128_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint128_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint128_t* 状态值，用于中间状态存储,不可为空
+ * \param state3 huint128_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint128_t* 目标大数,dst=src1的src2次方对src3取模
+ * \param src1 const huint128_t* 源大数1
+ * \param src2 const huint128_t* 源大数2
+ * \param src3 const huint128_t* 源大数3
+ *
+ */
+void huint128_power_mod(huint128_t *state,huint128_t *state1,huint128_t *state2,huint128_t *state3,huint128_t *dst,const huint128_t *src1,const huint128_t *src2,const huint128_t *src3);
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HUINT128_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint2048.c

@@ -0,0 +1,711 @@
+/***************************************************************
+ * Name:      huint2048.c
+ * Purpose:   实现huint2048接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "huint2048.h"
+
+void huint2048_load(huint2048_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[i+3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[i+2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[i+1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[i+0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint2048_load_be(huint2048_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    if(bytes_count > sizeof(num->val))
+    {
+        //丢弃高位
+        size_t bytes_overflow=bytes_count-sizeof(huint2048_t);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint2048_load_uint32(huint2048_t *num,uint32_t uint32_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=uint32_num;
+
+    //清零剩余值
+    for(size_t i=(1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint2048_load_uint64(huint2048_t *num,uint64_t uint64_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=((uint64_num>>0)&0xFFFFFFFF);
+    num->val[1]=((uint64_num>>32)&0xFFFFFFFF);
+
+    //清零剩余值
+    for(size_t i=(2); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint2048_store(huint2048_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[sizeof(num->val[0])*i+0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[sizeof(num->val[0])*i+1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[sizeof(num->val[0])*i+2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[sizeof(num->val[0])*i+3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint2048_store_be(huint2048_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    if(bytes_count > sizeof(num->val))
+    {
+        //高位置零
+        size_t bytes_overflow=bytes_count-sizeof(huint2048_t);
+        memset(bytes,0,bytes_overflow);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint2048_store_uint32(const huint2048_t *num,uint32_t* uint32_num)
+{
+    if(num==NULL || uint32_num ==NULL)
+    {
+        return;
+    }
+    (*uint32_num)=num->val[0];
+}
+
+void huint2048_store_uint64(const huint2048_t *num,uint64_t* uint64_num)
+{
+    if(num==NULL || uint64_num ==NULL)
+    {
+        return;
+    }
+    (*uint64_num)=num->val[0]+(((uint64_t)num->val[1]) << 32);
+}
+
+void huint2048_copy(huint2048_t *dst,const huint2048_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=src->val[i];
+    }
+}
+
+void huint2048_bitwise_not(huint2048_t *dst,const huint2048_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(~src->val[i]);
+    }
+}
+
+void huint2048_bitwise_and(huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] & src2->val[i]);
+    }
+}
+
+void huint2048_bitwise_or(huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] | src2->val[i]);
+    }
+}
+
+void huint2048_bitwise_xor(huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] ^ src2->val[i]);
+    }
+}
+
+int huint2048_compare(const huint2048_t *src1,const huint2048_t *src2)
+{
+    if(src1==NULL || src2==NULL)
+    {
+        return -2;
+    }
+    for(int i=((sizeof(src1->val)/sizeof(src2->val[0]))-1); i>=0 ; i--)
+    {
+        if(src1->val[i] > src2->val[i])
+        {
+            return 1;
+        }
+        if(src1->val[i] < src2->val[i])
+        {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+void huint2048_complement(huint2048_t *dst,const huint2048_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    //取反
+    huint2048_bitwise_not(dst,src);
+
+    //加1
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        if(i==0)
+        {
+            temp+=((uint64_t)dst->val[i])+1;
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+        else
+        {
+            temp+=((uint64_t)dst->val[i]);
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+    }
+}
+
+static size_t huint2048_left_shift_internal(huint2048_t *dst,const huint2048_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((((uint64_t)src->val[i]) << (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)temp;
+        temp >>= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+void huint2048_left_shift(huint2048_t *dst,const huint2048_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT2048_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint2048_load_uint32(dst,0);
+        return;
+    }
+
+    huint2048_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint2048_left_shift_internal(dst,dst,bits);
+    }
+}
+
+static size_t huint2048_right_shift_internal(huint2048_t *dst,const huint2048_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(int i=((sizeof(dst->val)/sizeof(dst->val[0]))-1); i>=0 ; i--)
+    {
+        temp = (((((uint64_t)src->val[i]) << (sizeof(uint32_t)*8)) >> (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)(temp >> (sizeof(uint32_t)*8));
+        temp <<= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+
+void huint2048_right_shift(huint2048_t *dst,const huint2048_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT2048_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint2048_load_uint32(dst,0);
+        return;
+    }
+
+    huint2048_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint2048_right_shift_internal(dst,dst,bits);
+    }
+}
+
+void huint2048_bit_set(huint2048_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT2048_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] |= (1ULL << (bits%(sizeof(dst->val[0])*8)));
+    }
+}
+
+void huint2048_bit_clear(huint2048_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT2048_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] &= (~(1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+}
+
+bool huint2048_bit(const huint2048_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT2048_BITS_COUNT)
+        {
+            return false;
+        }
+
+        return 0!=(dst->val[bits/(sizeof(dst->val[0])*8)] & (1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+
+    return false;
+}
+
+size_t huint2048_clz(const huint2048_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT2048_BITS_COUNT; i++)
+        {
+            if(huint2048_bit(dst,HUINT2048_BITS_COUNT-1-i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT2048_BITS_COUNT;
+}
+
+size_t huint2048_ctz(const huint2048_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT2048_BITS_COUNT; i++)
+        {
+            if(huint2048_bit(dst,i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT2048_BITS_COUNT;
+}
+
+void huint2048_add(huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((uint64_t)src1->val[i])+src2->val[i]+temp;
+        dst->val[i]=(uint32_t)temp;
+        temp>>=32;
+    }
+}
+
+void huint2048_sub(huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    //求补码
+    huint2048_complement(dst,src2);
+
+    //对补码进行加
+    huint2048_add(dst,dst,src1);
+}
+
+void huint2048_mul(huint2048_t *state,huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2)
+{
+    if(state == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint2048_load_uint32(dst,0);
+    size_t clz=huint2048_clz(src2);
+    size_t ctz=huint2048_ctz(src2);
+    for(size_t i=ctz; i < (HUINT2048_BITS_COUNT-clz); i++)
+    {
+        if(huint2048_bit(src2,i))
+        {
+            //当前位是1, src1左移后累加至结果
+            huint2048_left_shift(state,src1,i);
+            huint2048_add(dst,dst,state);
+        }
+    }
+}
+
+void huint2048_div(huint2048_t *state,huint2048_t *state1,huint2048_t *state2,huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+
+    huint2048_load_uint32(dst,0);
+    if(huint2048_compare(src2,state)==0 )
+    {
+        huint2048_load_uint32(state,0);
+        //除0错误
+        return;
+    }
+
+    if(huint2048_compare(src2,src1) > 0)
+    {
+        //除数大于被除数
+        huint2048_copy(state,src1);
+        huint2048_load_uint32(dst,0);
+        return;
+    }
+
+    size_t clz1=huint2048_clz(src1);
+    size_t clz2=huint2048_clz(src2);
+    if(clz1 > clz2)
+    {
+        //除数大于被除数
+        huint2048_copy(state,src1);
+        huint2048_load_uint32(dst,0);
+        return;
+    }
+
+    huint2048_copy(state,src1);
+
+    for(size_t i=0; i<= clz2-clz1; i++)
+    {
+        huint2048_left_shift(state1,src2,(clz2-clz1)-i);
+        if(huint2048_compare(state,state1) >= 0)
+        {
+            //被除数大于左移后的除数，直接相减并将相应位置1
+            huint2048_sub(state2,state,state1);
+            huint2048_bit_set(dst,(clz2-clz1)-i);
+            //余数保存至state
+            huint2048_copy(state,state2);
+        }
+    }
+
+}
+
+void huint2048_power(huint2048_t *state,huint2048_t *state1,huint2048_t *state2,huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint2048_load_uint32(state,0);
+    huint2048_load_uint32(dst,1);
+    if(huint2048_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint2048_load_uint32(dst,0);
+        return;
+    }
+    if(huint2048_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint2048_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint2048_clz(src2);
+    huint2048_copy(state,src1);
+    for(size_t i=0; i<(HUINT2048_BITS_COUNT - clz2); i++)
+    {
+        if(huint2048_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint2048_mul(state1,state2,dst,state);
+            huint2048_copy(dst,state2);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint2048_mul(state1,state2,state,state);
+        huint2048_copy(state,state2);
+    }
+
+}
+
+void huint2048_power_mod(huint2048_t *state,huint2048_t *state1,huint2048_t *state2,huint2048_t *state3,huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2,const huint2048_t *src3)
+{
+    if(state == NULL || state1==NULL || state2== NULL || state3 == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint2048_load_uint32(state,0);
+    huint2048_load_uint32(dst,1);
+    if(huint2048_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint2048_load_uint32(dst,0);
+        return;
+    }
+    if(huint2048_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint2048_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint2048_clz(src2);
+    huint2048_copy(state,src1);
+    for(size_t i=0; i<(HUINT2048_BITS_COUNT - clz2); i++)
+    {
+        if(huint2048_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint2048_mul(state1,state2,dst,state);
+            huint2048_copy(dst,state2);
+
+            //对dst提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+            huint2048_div(dst,state1,state2,state3,dst,src3);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint2048_mul(state1,state2,state,state);
+        huint2048_copy(state,state2);
+
+        //对state提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+        huint2048_div(state,state1,state2,state3,state,src3);
+    }
+
+}

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint2048.h

@@ -0,0 +1,294 @@
+/***************************************************************
+ * Name:      huint2048.h
+ * Purpose:   声明huint2048接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HUINT2048_H__
+#define __HUINT2048_H__
+#include "stdint.h"
+#include "stdbool.h"
+#include "stdlib.h"
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#define HUINT2048_BITS_COUNT 2048
+
+typedef struct huint2048 huint2048_t;
+struct huint2048
+{
+    uint32_t val[(HUINT2048_BITS_COUNT/(sizeof(uint32_t)*8))+((HUINT2048_BITS_COUNT%(sizeof(uint32_t)*8))!=0?1:0)];
+};
+
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint2048_t* 大数指针
+ * \param bytes const uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint2048_load(huint2048_t *num,const uint8_t *bytes,size_t bytes_count);
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint2048_t* 大数指针
+ * \param bytes const uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint2048_load_be(huint2048_t *num,const uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint2048_t* 大数
+ * \param uint32_num uint32_t 数字
+ *
+ */
+void huint2048_load_uint32(huint2048_t *num,uint32_t uint32_num);
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint2048_t* 大数
+ * \param uint64_num uint64_t 数字
+ *
+ */
+void huint2048_load_uint64(huint2048_t *num,uint64_t uint64_num);
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint2048_t* 大数指针
+ * \param bytes uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint2048_store(huint2048_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint2048_t* 大数指针
+ * \param bytes uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint2048_store_be(huint2048_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数数字
+ *
+ * \param num huint2048_t* 大数
+ * \param uint32_num uint32_t* 数字
+ *
+ */
+void huint2048_store_uint32(const huint2048_t *num,uint32_t* uint32_num);
+
+/** \brief 保存大数数字
+ *
+ * \param num huint2048_t* 大数
+ * \param uint64_num uint64_t* 数字
+ *
+ */
+void huint2048_store_uint64(const huint2048_t *num,uint64_t* uint64_num);
+
+/** \brief 复制
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param src const huint2048_t* 源大数
+ *
+ */
+void huint2048_copy(huint2048_t *dst,const huint2048_t *src);
+
+/** \brief 按位非
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param src const huint2048_t* 源大数
+ *
+ */
+void huint2048_bitwise_not(huint2048_t *dst,const huint2048_t *src);
+
+/** \brief 按位与
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param src1 const huint2048_t* 源大数1
+ * \param src2 const huint2048_t* 源大数2
+ *
+ */
+void huint2048_bitwise_and(huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2);
+
+/** \brief 按位或
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param src1 const huint2048_t* 源大数1
+ * \param src2 const huint2048_t* 源大数2
+ *
+ */
+void huint2048_bitwise_or(huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2);
+
+/** \brief 按位异或
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param src1 const huint2048_t* 源大数1
+ * \param src2 const huint2048_t* 源大数2
+ *
+ */
+void huint2048_bitwise_xor(huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2);
+
+/** \brief 比较
+ *
+ * \param src1 const huint2048_t* 源大数1
+ * \param src2 const huint2048_t* 源大数2
+ * \return int 0=相等，1=源大数1大于源大数2,-1表示源大数2大于源大数1，-2=参数出错
+ *
+ */
+int huint2048_compare(const huint2048_t *src1,const huint2048_t *src2);
+
+/** \brief 求补码
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param src const huint2048_t* 源大数
+ *
+ */
+void huint2048_complement(huint2048_t *dst,const huint2048_t *src);
+
+/** \brief 左移
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param src const huint2048_t* 源大数
+ * \param bits size_t 左移位数
+ *
+ */
+void huint2048_left_shift(huint2048_t *dst,const huint2048_t *src,size_t bits);
+
+/** \brief 右移
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param src const huint2048_t* 源大数
+ * \param bits size_t 右移位数
+ *
+ */
+void huint2048_right_shift(huint2048_t *dst,const huint2048_t *src,size_t bits);
+
+/** \brief 设置位
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint2048_bit_set(huint2048_t *dst,size_t bits);
+
+/** \brief 清除位
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint2048_bit_clear(huint2048_t *dst,size_t bits);
+
+/** \brief 获取位
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param bits size_t 位
+ * \return bool 位上的值
+ *
+ */
+bool huint2048_bit(const huint2048_t *dst,size_t bits);
+
+/** \brief 前导0的个数
+ *
+ * \param dst huint2048_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint2048_clz(const huint2048_t *dst);
+
+/** \brief 尾部0的个数
+ *
+ * \param dst huint2048_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint2048_ctz(const huint2048_t *dst);
+
+/** \brief 加
+ *
+ * \param dst huint2048_t* 目标大数
+ * \param src1 const huint2048_t* 源大数1
+ * \param src2 const huint2048_t* 源大数2
+ *
+ */
+void huint2048_add(huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2);
+
+
+/** \brief 减
+ *
+ * \param dst huint2048_t* 目标大数,dst=src1-src2
+ * \param src1 const huint2048_t* 源大数1
+ * \param src2 const huint2048_t* 源大数2
+ *
+ */
+void huint2048_sub(huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2);
+
+/** \brief 乘
+ *
+ * \param state huint2048_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint2048_t* 目标大数,dst=src1*src2
+ * \param src1 const huint2048_t* 源大数1
+ * \param src2 const huint2048_t* 源大数2
+ *
+ */
+void huint2048_mul(huint2048_t *state,huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2);
+
+
+/** \brief 除
+ *
+ * \param state huint2048_t* 状态值，存储余数。state=src1%src2
+ * \param state1 huint2048_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint2048_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint2048_t* 目标大数,dst=src1/src2
+ * \param src1 const huint2048_t* 源大数1
+ * \param src2 const huint2048_t* 源大数2
+ *
+ */
+void huint2048_div(huint2048_t *state,huint2048_t *state1,huint2048_t *state2,huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2);
+
+
+/** \brief 幂函数
+ *
+ * \param state huint2048_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint2048_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint2048_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint2048_t* 目标大数,dst=src1的src2次方
+ * \param src1 const huint2048_t* 源大数1
+ * \param src2 const huint2048_t* 源大数2
+ *
+ */
+void huint2048_power(huint2048_t *state,huint2048_t *state1,huint2048_t *state2,huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2);
+
+
+/** \brief 幂取模函数（常用于RSA等加密算法）
+ *
+ * \param state huint2048_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint2048_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint2048_t* 状态值，用于中间状态存储,不可为空
+ * \param state3 huint2048_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint2048_t* 目标大数,dst=src1的src2次方对src3取模
+ * \param src1 const huint2048_t* 源大数1
+ * \param src2 const huint2048_t* 源大数2
+ * \param src3 const huint2048_t* 源大数3
+ *
+ */
+void huint2048_power_mod(huint2048_t *state,huint2048_t *state1,huint2048_t *state2,huint2048_t *state3,huint2048_t *dst,const huint2048_t *src1,const huint2048_t *src2,const huint2048_t *src3);
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HUINT2048_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint256.c

@@ -0,0 +1,711 @@
+/***************************************************************
+ * Name:      huint256.c
+ * Purpose:   实现huint256接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "huint256.h"
+
+void huint256_load(huint256_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[i+3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[i+2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[i+1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[i+0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint256_load_be(huint256_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    if(bytes_count > sizeof(num->val))
+    {
+        //丢弃高位
+        size_t bytes_overflow=bytes_count-sizeof(huint256_t);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint256_load_uint32(huint256_t *num,uint32_t uint32_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=uint32_num;
+
+    //清零剩余值
+    for(size_t i=(1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint256_load_uint64(huint256_t *num,uint64_t uint64_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=((uint64_num>>0)&0xFFFFFFFF);
+    num->val[1]=((uint64_num>>32)&0xFFFFFFFF);
+
+    //清零剩余值
+    for(size_t i=(2); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint256_store(huint256_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[sizeof(num->val[0])*i+0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[sizeof(num->val[0])*i+1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[sizeof(num->val[0])*i+2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[sizeof(num->val[0])*i+3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint256_store_be(huint256_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    if(bytes_count > sizeof(num->val))
+    {
+        //高位置零
+        size_t bytes_overflow=bytes_count-sizeof(huint256_t);
+        memset(bytes,0,bytes_overflow);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint256_store_uint32(const huint256_t *num,uint32_t* uint32_num)
+{
+    if(num==NULL || uint32_num ==NULL)
+    {
+        return;
+    }
+    (*uint32_num)=num->val[0];
+}
+
+void huint256_store_uint64(const huint256_t *num,uint64_t* uint64_num)
+{
+    if(num==NULL || uint64_num ==NULL)
+    {
+        return;
+    }
+    (*uint64_num)=num->val[0]+(((uint64_t)num->val[1]) << 32);
+}
+
+void huint256_copy(huint256_t *dst,const huint256_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=src->val[i];
+    }
+}
+
+void huint256_bitwise_not(huint256_t *dst,const huint256_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(~src->val[i]);
+    }
+}
+
+void huint256_bitwise_and(huint256_t *dst,const huint256_t *src1,const huint256_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] & src2->val[i]);
+    }
+}
+
+void huint256_bitwise_or(huint256_t *dst,const huint256_t *src1,const huint256_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] | src2->val[i]);
+    }
+}
+
+void huint256_bitwise_xor(huint256_t *dst,const huint256_t *src1,const huint256_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] ^ src2->val[i]);
+    }
+}
+
+int huint256_compare(const huint256_t *src1,const huint256_t *src2)
+{
+    if(src1==NULL || src2==NULL)
+    {
+        return -2;
+    }
+    for(int i=((sizeof(src1->val)/sizeof(src2->val[0]))-1); i>=0 ; i--)
+    {
+        if(src1->val[i] > src2->val[i])
+        {
+            return 1;
+        }
+        if(src1->val[i] < src2->val[i])
+        {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+void huint256_complement(huint256_t *dst,const huint256_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    //取反
+    huint256_bitwise_not(dst,src);
+
+    //加1
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        if(i==0)
+        {
+            temp+=((uint64_t)dst->val[i])+1;
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+        else
+        {
+            temp+=((uint64_t)dst->val[i]);
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+    }
+}
+
+static size_t huint256_left_shift_internal(huint256_t *dst,const huint256_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((((uint64_t)src->val[i]) << (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)temp;
+        temp >>= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+void huint256_left_shift(huint256_t *dst,const huint256_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT256_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint256_load_uint32(dst,0);
+        return;
+    }
+
+    huint256_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint256_left_shift_internal(dst,dst,bits);
+    }
+}
+
+static size_t huint256_right_shift_internal(huint256_t *dst,const huint256_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(int i=((sizeof(dst->val)/sizeof(dst->val[0]))-1); i>=0 ; i--)
+    {
+        temp = (((((uint64_t)src->val[i]) << (sizeof(uint32_t)*8)) >> (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)(temp >> (sizeof(uint32_t)*8));
+        temp <<= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+
+void huint256_right_shift(huint256_t *dst,const huint256_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT256_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint256_load_uint32(dst,0);
+        return;
+    }
+
+    huint256_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint256_right_shift_internal(dst,dst,bits);
+    }
+}
+
+void huint256_bit_set(huint256_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT256_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] |= (1ULL << (bits%(sizeof(dst->val[0])*8)));
+    }
+}
+
+void huint256_bit_clear(huint256_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT256_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] &= (~(1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+}
+
+bool huint256_bit(const huint256_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT256_BITS_COUNT)
+        {
+            return false;
+        }
+
+        return 0!=(dst->val[bits/(sizeof(dst->val[0])*8)] & (1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+
+    return false;
+}
+
+size_t huint256_clz(const huint256_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT256_BITS_COUNT; i++)
+        {
+            if(huint256_bit(dst,HUINT256_BITS_COUNT-1-i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT256_BITS_COUNT;
+}
+
+size_t huint256_ctz(const huint256_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT256_BITS_COUNT; i++)
+        {
+            if(huint256_bit(dst,i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT256_BITS_COUNT;
+}
+
+void huint256_add(huint256_t *dst,const huint256_t *src1,const huint256_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((uint64_t)src1->val[i])+src2->val[i]+temp;
+        dst->val[i]=(uint32_t)temp;
+        temp>>=32;
+    }
+}
+
+void huint256_sub(huint256_t *dst,const huint256_t *src1,const huint256_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    //求补码
+    huint256_complement(dst,src2);
+
+    //对补码进行加
+    huint256_add(dst,dst,src1);
+}
+
+void huint256_mul(huint256_t *state,huint256_t *dst,const huint256_t *src1,const huint256_t *src2)
+{
+    if(state == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint256_load_uint32(dst,0);
+    size_t clz=huint256_clz(src2);
+    size_t ctz=huint256_ctz(src2);
+    for(size_t i=ctz; i < (HUINT256_BITS_COUNT-clz); i++)
+    {
+        if(huint256_bit(src2,i))
+        {
+            //当前位是1, src1左移后累加至结果
+            huint256_left_shift(state,src1,i);
+            huint256_add(dst,dst,state);
+        }
+    }
+}
+
+void huint256_div(huint256_t *state,huint256_t *state1,huint256_t *state2,huint256_t *dst,const huint256_t *src1,const huint256_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+
+    huint256_load_uint32(dst,0);
+    if(huint256_compare(src2,state)==0 )
+    {
+        huint256_load_uint32(state,0);
+        //除0错误
+        return;
+    }
+
+    if(huint256_compare(src2,src1) > 0)
+    {
+        //除数大于被除数
+        huint256_copy(state,src1);
+        huint256_load_uint32(dst,0);
+        return;
+    }
+
+    size_t clz1=huint256_clz(src1);
+    size_t clz2=huint256_clz(src2);
+    if(clz1 > clz2)
+    {
+        //除数大于被除数
+        huint256_copy(state,src1);
+        huint256_load_uint32(dst,0);
+        return;
+    }
+
+    huint256_copy(state,src1);
+
+    for(size_t i=0; i<= clz2-clz1; i++)
+    {
+        huint256_left_shift(state1,src2,(clz2-clz1)-i);
+        if(huint256_compare(state,state1) >= 0)
+        {
+            //被除数大于左移后的除数，直接相减并将相应位置1
+            huint256_sub(state2,state,state1);
+            huint256_bit_set(dst,(clz2-clz1)-i);
+            //余数保存至state
+            huint256_copy(state,state2);
+        }
+    }
+
+}
+
+void huint256_power(huint256_t *state,huint256_t *state1,huint256_t *state2,huint256_t *dst,const huint256_t *src1,const huint256_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint256_load_uint32(state,0);
+    huint256_load_uint32(dst,1);
+    if(huint256_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint256_load_uint32(dst,0);
+        return;
+    }
+    if(huint256_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint256_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint256_clz(src2);
+    huint256_copy(state,src1);
+    for(size_t i=0; i<(HUINT256_BITS_COUNT - clz2); i++)
+    {
+        if(huint256_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint256_mul(state1,state2,dst,state);
+            huint256_copy(dst,state2);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint256_mul(state1,state2,state,state);
+        huint256_copy(state,state2);
+    }
+
+}
+
+void huint256_power_mod(huint256_t *state,huint256_t *state1,huint256_t *state2,huint256_t *state3,huint256_t *dst,const huint256_t *src1,const huint256_t *src2,const huint256_t *src3)
+{
+    if(state == NULL || state1==NULL || state2== NULL || state3 == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint256_load_uint32(state,0);
+    huint256_load_uint32(dst,1);
+    if(huint256_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint256_load_uint32(dst,0);
+        return;
+    }
+    if(huint256_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint256_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint256_clz(src2);
+    huint256_copy(state,src1);
+    for(size_t i=0; i<(HUINT256_BITS_COUNT - clz2); i++)
+    {
+        if(huint256_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint256_mul(state1,state2,dst,state);
+            huint256_copy(dst,state2);
+
+            //对dst提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+            huint256_div(dst,state1,state2,state3,dst,src3);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint256_mul(state1,state2,state,state);
+        huint256_copy(state,state2);
+
+        //对state提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+        huint256_div(state,state1,state2,state3,state,src3);
+    }
+
+}

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint256.h

@@ -0,0 +1,294 @@
+/***************************************************************
+ * Name:      huint256.h
+ * Purpose:   声明huint256接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HUINT256_H__
+#define __HUINT256_H__
+#include "stdint.h"
+#include "stdbool.h"
+#include "stdlib.h"
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#define HUINT256_BITS_COUNT 256
+
+typedef struct huint256 huint256_t;
+struct huint256
+{
+    uint32_t val[(HUINT256_BITS_COUNT/(sizeof(uint32_t)*8))+((HUINT256_BITS_COUNT%(sizeof(uint32_t)*8))!=0?1:0)];
+};
+
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint256_t* 大数指针
+ * \param bytes const uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint256_load(huint256_t *num,const uint8_t *bytes,size_t bytes_count);
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint256_t* 大数指针
+ * \param bytes const uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint256_load_be(huint256_t *num,const uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint256_t* 大数
+ * \param uint32_num uint32_t 数字
+ *
+ */
+void huint256_load_uint32(huint256_t *num,uint32_t uint32_num);
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint256_t* 大数
+ * \param uint64_num uint64_t 数字
+ *
+ */
+void huint256_load_uint64(huint256_t *num,uint64_t uint64_num);
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint256_t* 大数指针
+ * \param bytes uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint256_store(huint256_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint256_t* 大数指针
+ * \param bytes uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint256_store_be(huint256_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数数字
+ *
+ * \param num huint256_t* 大数
+ * \param uint32_num uint32_t* 数字
+ *
+ */
+void huint256_store_uint32(const huint256_t *num,uint32_t* uint32_num);
+
+/** \brief 保存大数数字
+ *
+ * \param num huint256_t* 大数
+ * \param uint64_num uint64_t* 数字
+ *
+ */
+void huint256_store_uint64(const huint256_t *num,uint64_t* uint64_num);
+
+/** \brief 复制
+ *
+ * \param dst huint256_t* 目标大数
+ * \param src const huint256_t* 源大数
+ *
+ */
+void huint256_copy(huint256_t *dst,const huint256_t *src);
+
+/** \brief 按位非
+ *
+ * \param dst huint256_t* 目标大数
+ * \param src const huint256_t* 源大数
+ *
+ */
+void huint256_bitwise_not(huint256_t *dst,const huint256_t *src);
+
+/** \brief 按位与
+ *
+ * \param dst huint256_t* 目标大数
+ * \param src1 const huint256_t* 源大数1
+ * \param src2 const huint256_t* 源大数2
+ *
+ */
+void huint256_bitwise_and(huint256_t *dst,const huint256_t *src1,const huint256_t *src2);
+
+/** \brief 按位或
+ *
+ * \param dst huint256_t* 目标大数
+ * \param src1 const huint256_t* 源大数1
+ * \param src2 const huint256_t* 源大数2
+ *
+ */
+void huint256_bitwise_or(huint256_t *dst,const huint256_t *src1,const huint256_t *src2);
+
+/** \brief 按位异或
+ *
+ * \param dst huint256_t* 目标大数
+ * \param src1 const huint256_t* 源大数1
+ * \param src2 const huint256_t* 源大数2
+ *
+ */
+void huint256_bitwise_xor(huint256_t *dst,const huint256_t *src1,const huint256_t *src2);
+
+/** \brief 比较
+ *
+ * \param src1 const huint256_t* 源大数1
+ * \param src2 const huint256_t* 源大数2
+ * \return int 0=相等，1=源大数1大于源大数2,-1表示源大数2大于源大数1，-2=参数出错
+ *
+ */
+int huint256_compare(const huint256_t *src1,const huint256_t *src2);
+
+/** \brief 求补码
+ *
+ * \param dst huint256_t* 目标大数
+ * \param src const huint256_t* 源大数
+ *
+ */
+void huint256_complement(huint256_t *dst,const huint256_t *src);
+
+/** \brief 左移
+ *
+ * \param dst huint256_t* 目标大数
+ * \param src const huint256_t* 源大数
+ * \param bits size_t 左移位数
+ *
+ */
+void huint256_left_shift(huint256_t *dst,const huint256_t *src,size_t bits);
+
+/** \brief 右移
+ *
+ * \param dst huint256_t* 目标大数
+ * \param src const huint256_t* 源大数
+ * \param bits size_t 右移位数
+ *
+ */
+void huint256_right_shift(huint256_t *dst,const huint256_t *src,size_t bits);
+
+/** \brief 设置位
+ *
+ * \param dst huint256_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint256_bit_set(huint256_t *dst,size_t bits);
+
+/** \brief 清除位
+ *
+ * \param dst huint256_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint256_bit_clear(huint256_t *dst,size_t bits);
+
+/** \brief 获取位
+ *
+ * \param dst huint256_t* 目标大数
+ * \param bits size_t 位
+ * \return bool 位上的值
+ *
+ */
+bool huint256_bit(const huint256_t *dst,size_t bits);
+
+/** \brief 前导0的个数
+ *
+ * \param dst huint256_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint256_clz(const huint256_t *dst);
+
+/** \brief 尾部0的个数
+ *
+ * \param dst huint256_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint256_ctz(const huint256_t *dst);
+
+/** \brief 加
+ *
+ * \param dst huint256_t* 目标大数
+ * \param src1 const huint256_t* 源大数1
+ * \param src2 const huint256_t* 源大数2
+ *
+ */
+void huint256_add(huint256_t *dst,const huint256_t *src1,const huint256_t *src2);
+
+
+/** \brief 减
+ *
+ * \param dst huint256_t* 目标大数,dst=src1-src2
+ * \param src1 const huint256_t* 源大数1
+ * \param src2 const huint256_t* 源大数2
+ *
+ */
+void huint256_sub(huint256_t *dst,const huint256_t *src1,const huint256_t *src2);
+
+/** \brief 乘
+ *
+ * \param state huint256_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint256_t* 目标大数,dst=src1*src2
+ * \param src1 const huint256_t* 源大数1
+ * \param src2 const huint256_t* 源大数2
+ *
+ */
+void huint256_mul(huint256_t *state,huint256_t *dst,const huint256_t *src1,const huint256_t *src2);
+
+
+/** \brief 除
+ *
+ * \param state huint256_t* 状态值，存储余数。state=src1%src2
+ * \param state1 huint256_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint256_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint256_t* 目标大数,dst=src1/src2
+ * \param src1 const huint256_t* 源大数1
+ * \param src2 const huint256_t* 源大数2
+ *
+ */
+void huint256_div(huint256_t *state,huint256_t *state1,huint256_t *state2,huint256_t *dst,const huint256_t *src1,const huint256_t *src2);
+
+
+/** \brief 幂函数
+ *
+ * \param state huint256_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint256_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint256_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint256_t* 目标大数,dst=src1的src2次方
+ * \param src1 const huint256_t* 源大数1
+ * \param src2 const huint256_t* 源大数2
+ *
+ */
+void huint256_power(huint256_t *state,huint256_t *state1,huint256_t *state2,huint256_t *dst,const huint256_t *src1,const huint256_t *src2);
+
+
+/** \brief 幂取模函数（常用于RSA等加密算法）
+ *
+ * \param state huint256_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint256_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint256_t* 状态值，用于中间状态存储,不可为空
+ * \param state3 huint256_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint256_t* 目标大数,dst=src1的src2次方对src3取模
+ * \param src1 const huint256_t* 源大数1
+ * \param src2 const huint256_t* 源大数2
+ * \param src3 const huint256_t* 源大数3
+ *
+ */
+void huint256_power_mod(huint256_t *state,huint256_t *state1,huint256_t *state2,huint256_t *state3,huint256_t *dst,const huint256_t *src1,const huint256_t *src2,const huint256_t *src3);
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HUINT256_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint4096.c

@@ -0,0 +1,711 @@
+/***************************************************************
+ * Name:      huint4096.c
+ * Purpose:   实现huint4096接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "huint4096.h"
+
+void huint4096_load(huint4096_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[i+3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[i+2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[i+1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[i+0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint4096_load_be(huint4096_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    if(bytes_count > sizeof(num->val))
+    {
+        //丢弃高位
+        size_t bytes_overflow=bytes_count-sizeof(huint4096_t);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint4096_load_uint32(huint4096_t *num,uint32_t uint32_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=uint32_num;
+
+    //清零剩余值
+    for(size_t i=(1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint4096_load_uint64(huint4096_t *num,uint64_t uint64_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=((uint64_num>>0)&0xFFFFFFFF);
+    num->val[1]=((uint64_num>>32)&0xFFFFFFFF);
+
+    //清零剩余值
+    for(size_t i=(2); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint4096_store(huint4096_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[sizeof(num->val[0])*i+0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[sizeof(num->val[0])*i+1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[sizeof(num->val[0])*i+2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[sizeof(num->val[0])*i+3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint4096_store_be(huint4096_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    if(bytes_count > sizeof(num->val))
+    {
+        //高位置零
+        size_t bytes_overflow=bytes_count-sizeof(huint4096_t);
+        memset(bytes,0,bytes_overflow);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint4096_store_uint32(const huint4096_t *num,uint32_t* uint32_num)
+{
+    if(num==NULL || uint32_num ==NULL)
+    {
+        return;
+    }
+    (*uint32_num)=num->val[0];
+}
+
+void huint4096_store_uint64(const huint4096_t *num,uint64_t* uint64_num)
+{
+    if(num==NULL || uint64_num ==NULL)
+    {
+        return;
+    }
+    (*uint64_num)=num->val[0]+(((uint64_t)num->val[1]) << 32);
+}
+
+void huint4096_copy(huint4096_t *dst,const huint4096_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=src->val[i];
+    }
+}
+
+void huint4096_bitwise_not(huint4096_t *dst,const huint4096_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(~src->val[i]);
+    }
+}
+
+void huint4096_bitwise_and(huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] & src2->val[i]);
+    }
+}
+
+void huint4096_bitwise_or(huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] | src2->val[i]);
+    }
+}
+
+void huint4096_bitwise_xor(huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] ^ src2->val[i]);
+    }
+}
+
+int huint4096_compare(const huint4096_t *src1,const huint4096_t *src2)
+{
+    if(src1==NULL || src2==NULL)
+    {
+        return -2;
+    }
+    for(int i=((sizeof(src1->val)/sizeof(src2->val[0]))-1); i>=0 ; i--)
+    {
+        if(src1->val[i] > src2->val[i])
+        {
+            return 1;
+        }
+        if(src1->val[i] < src2->val[i])
+        {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+void huint4096_complement(huint4096_t *dst,const huint4096_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    //取反
+    huint4096_bitwise_not(dst,src);
+
+    //加1
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        if(i==0)
+        {
+            temp+=((uint64_t)dst->val[i])+1;
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+        else
+        {
+            temp+=((uint64_t)dst->val[i]);
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+    }
+}
+
+static size_t huint4096_left_shift_internal(huint4096_t *dst,const huint4096_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((((uint64_t)src->val[i]) << (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)temp;
+        temp >>= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+void huint4096_left_shift(huint4096_t *dst,const huint4096_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT4096_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint4096_load_uint32(dst,0);
+        return;
+    }
+
+    huint4096_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint4096_left_shift_internal(dst,dst,bits);
+    }
+}
+
+static size_t huint4096_right_shift_internal(huint4096_t *dst,const huint4096_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(int i=((sizeof(dst->val)/sizeof(dst->val[0]))-1); i>=0 ; i--)
+    {
+        temp = (((((uint64_t)src->val[i]) << (sizeof(uint32_t)*8)) >> (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)(temp >> (sizeof(uint32_t)*8));
+        temp <<= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+
+void huint4096_right_shift(huint4096_t *dst,const huint4096_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT4096_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint4096_load_uint32(dst,0);
+        return;
+    }
+
+    huint4096_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint4096_right_shift_internal(dst,dst,bits);
+    }
+}
+
+void huint4096_bit_set(huint4096_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT4096_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] |= (1ULL << (bits%(sizeof(dst->val[0])*8)));
+    }
+}
+
+void huint4096_bit_clear(huint4096_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT4096_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] &= (~(1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+}
+
+bool huint4096_bit(const huint4096_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT4096_BITS_COUNT)
+        {
+            return false;
+        }
+
+        return 0!=(dst->val[bits/(sizeof(dst->val[0])*8)] & (1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+
+    return false;
+}
+
+size_t huint4096_clz(const huint4096_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT4096_BITS_COUNT; i++)
+        {
+            if(huint4096_bit(dst,HUINT4096_BITS_COUNT-1-i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT4096_BITS_COUNT;
+}
+
+size_t huint4096_ctz(const huint4096_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT4096_BITS_COUNT; i++)
+        {
+            if(huint4096_bit(dst,i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT4096_BITS_COUNT;
+}
+
+void huint4096_add(huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((uint64_t)src1->val[i])+src2->val[i]+temp;
+        dst->val[i]=(uint32_t)temp;
+        temp>>=32;
+    }
+}
+
+void huint4096_sub(huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    //求补码
+    huint4096_complement(dst,src2);
+
+    //对补码进行加
+    huint4096_add(dst,dst,src1);
+}
+
+void huint4096_mul(huint4096_t *state,huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2)
+{
+    if(state == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint4096_load_uint32(dst,0);
+    size_t clz=huint4096_clz(src2);
+    size_t ctz=huint4096_ctz(src2);
+    for(size_t i=ctz; i < (HUINT4096_BITS_COUNT-clz); i++)
+    {
+        if(huint4096_bit(src2,i))
+        {
+            //当前位是1, src1左移后累加至结果
+            huint4096_left_shift(state,src1,i);
+            huint4096_add(dst,dst,state);
+        }
+    }
+}
+
+void huint4096_div(huint4096_t *state,huint4096_t *state1,huint4096_t *state2,huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+
+    huint4096_load_uint32(dst,0);
+    if(huint4096_compare(src2,state)==0 )
+    {
+        huint4096_load_uint32(state,0);
+        //除0错误
+        return;
+    }
+
+    if(huint4096_compare(src2,src1) > 0)
+    {
+        //除数大于被除数
+        huint4096_copy(state,src1);
+        huint4096_load_uint32(dst,0);
+        return;
+    }
+
+    size_t clz1=huint4096_clz(src1);
+    size_t clz2=huint4096_clz(src2);
+    if(clz1 > clz2)
+    {
+        //除数大于被除数
+        huint4096_copy(state,src1);
+        huint4096_load_uint32(dst,0);
+        return;
+    }
+
+    huint4096_copy(state,src1);
+
+    for(size_t i=0; i<= clz2-clz1; i++)
+    {
+        huint4096_left_shift(state1,src2,(clz2-clz1)-i);
+        if(huint4096_compare(state,state1) >= 0)
+        {
+            //被除数大于左移后的除数，直接相减并将相应位置1
+            huint4096_sub(state2,state,state1);
+            huint4096_bit_set(dst,(clz2-clz1)-i);
+            //余数保存至state
+            huint4096_copy(state,state2);
+        }
+    }
+
+}
+
+void huint4096_power(huint4096_t *state,huint4096_t *state1,huint4096_t *state2,huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint4096_load_uint32(state,0);
+    huint4096_load_uint32(dst,1);
+    if(huint4096_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint4096_load_uint32(dst,0);
+        return;
+    }
+    if(huint4096_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint4096_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint4096_clz(src2);
+    huint4096_copy(state,src1);
+    for(size_t i=0; i<(HUINT4096_BITS_COUNT - clz2); i++)
+    {
+        if(huint4096_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint4096_mul(state1,state2,dst,state);
+            huint4096_copy(dst,state2);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint4096_mul(state1,state2,state,state);
+        huint4096_copy(state,state2);
+    }
+
+}
+
+void huint4096_power_mod(huint4096_t *state,huint4096_t *state1,huint4096_t *state2,huint4096_t *state3,huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2,const huint4096_t *src3)
+{
+    if(state == NULL || state1==NULL || state2== NULL || state3 == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint4096_load_uint32(state,0);
+    huint4096_load_uint32(dst,1);
+    if(huint4096_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint4096_load_uint32(dst,0);
+        return;
+    }
+    if(huint4096_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint4096_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint4096_clz(src2);
+    huint4096_copy(state,src1);
+    for(size_t i=0; i<(HUINT4096_BITS_COUNT - clz2); i++)
+    {
+        if(huint4096_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint4096_mul(state1,state2,dst,state);
+            huint4096_copy(dst,state2);
+
+            //对dst提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+            huint4096_div(dst,state1,state2,state3,dst,src3);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint4096_mul(state1,state2,state,state);
+        huint4096_copy(state,state2);
+
+        //对state提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+        huint4096_div(state,state1,state2,state3,state,src3);
+    }
+
+}

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint4096.h

@@ -0,0 +1,294 @@
+/***************************************************************
+ * Name:      huint4096.h
+ * Purpose:   声明huint4096接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HUINT4096_H__
+#define __HUINT4096_H__
+#include "stdint.h"
+#include "stdbool.h"
+#include "stdlib.h"
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#define HUINT4096_BITS_COUNT 4096
+
+typedef struct huint4096 huint4096_t;
+struct huint4096
+{
+    uint32_t val[(HUINT4096_BITS_COUNT/(sizeof(uint32_t)*8))+((HUINT4096_BITS_COUNT%(sizeof(uint32_t)*8))!=0?1:0)];
+};
+
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint4096_t* 大数指针
+ * \param bytes const uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint4096_load(huint4096_t *num,const uint8_t *bytes,size_t bytes_count);
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint4096_t* 大数指针
+ * \param bytes const uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint4096_load_be(huint4096_t *num,const uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint4096_t* 大数
+ * \param uint32_num uint32_t 数字
+ *
+ */
+void huint4096_load_uint32(huint4096_t *num,uint32_t uint32_num);
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint4096_t* 大数
+ * \param uint64_num uint64_t 数字
+ *
+ */
+void huint4096_load_uint64(huint4096_t *num,uint64_t uint64_num);
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint4096_t* 大数指针
+ * \param bytes uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint4096_store(huint4096_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint4096_t* 大数指针
+ * \param bytes uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint4096_store_be(huint4096_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数数字
+ *
+ * \param num huint4096_t* 大数
+ * \param uint32_num uint32_t* 数字
+ *
+ */
+void huint4096_store_uint32(const huint4096_t *num,uint32_t* uint32_num);
+
+/** \brief 保存大数数字
+ *
+ * \param num huint4096_t* 大数
+ * \param uint64_num uint64_t* 数字
+ *
+ */
+void huint4096_store_uint64(const huint4096_t *num,uint64_t* uint64_num);
+
+/** \brief 复制
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param src const huint4096_t* 源大数
+ *
+ */
+void huint4096_copy(huint4096_t *dst,const huint4096_t *src);
+
+/** \brief 按位非
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param src const huint4096_t* 源大数
+ *
+ */
+void huint4096_bitwise_not(huint4096_t *dst,const huint4096_t *src);
+
+/** \brief 按位与
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param src1 const huint4096_t* 源大数1
+ * \param src2 const huint4096_t* 源大数2
+ *
+ */
+void huint4096_bitwise_and(huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2);
+
+/** \brief 按位或
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param src1 const huint4096_t* 源大数1
+ * \param src2 const huint4096_t* 源大数2
+ *
+ */
+void huint4096_bitwise_or(huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2);
+
+/** \brief 按位异或
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param src1 const huint4096_t* 源大数1
+ * \param src2 const huint4096_t* 源大数2
+ *
+ */
+void huint4096_bitwise_xor(huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2);
+
+/** \brief 比较
+ *
+ * \param src1 const huint4096_t* 源大数1
+ * \param src2 const huint4096_t* 源大数2
+ * \return int 0=相等，1=源大数1大于源大数2,-1表示源大数2大于源大数1，-2=参数出错
+ *
+ */
+int huint4096_compare(const huint4096_t *src1,const huint4096_t *src2);
+
+/** \brief 求补码
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param src const huint4096_t* 源大数
+ *
+ */
+void huint4096_complement(huint4096_t *dst,const huint4096_t *src);
+
+/** \brief 左移
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param src const huint4096_t* 源大数
+ * \param bits size_t 左移位数
+ *
+ */
+void huint4096_left_shift(huint4096_t *dst,const huint4096_t *src,size_t bits);
+
+/** \brief 右移
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param src const huint4096_t* 源大数
+ * \param bits size_t 右移位数
+ *
+ */
+void huint4096_right_shift(huint4096_t *dst,const huint4096_t *src,size_t bits);
+
+/** \brief 设置位
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint4096_bit_set(huint4096_t *dst,size_t bits);
+
+/** \brief 清除位
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint4096_bit_clear(huint4096_t *dst,size_t bits);
+
+/** \brief 获取位
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param bits size_t 位
+ * \return bool 位上的值
+ *
+ */
+bool huint4096_bit(const huint4096_t *dst,size_t bits);
+
+/** \brief 前导0的个数
+ *
+ * \param dst huint4096_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint4096_clz(const huint4096_t *dst);
+
+/** \brief 尾部0的个数
+ *
+ * \param dst huint4096_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint4096_ctz(const huint4096_t *dst);
+
+/** \brief 加
+ *
+ * \param dst huint4096_t* 目标大数
+ * \param src1 const huint4096_t* 源大数1
+ * \param src2 const huint4096_t* 源大数2
+ *
+ */
+void huint4096_add(huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2);
+
+
+/** \brief 减
+ *
+ * \param dst huint4096_t* 目标大数,dst=src1-src2
+ * \param src1 const huint4096_t* 源大数1
+ * \param src2 const huint4096_t* 源大数2
+ *
+ */
+void huint4096_sub(huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2);
+
+/** \brief 乘
+ *
+ * \param state huint4096_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint4096_t* 目标大数,dst=src1*src2
+ * \param src1 const huint4096_t* 源大数1
+ * \param src2 const huint4096_t* 源大数2
+ *
+ */
+void huint4096_mul(huint4096_t *state,huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2);
+
+
+/** \brief 除
+ *
+ * \param state huint4096_t* 状态值，存储余数。state=src1%src2
+ * \param state1 huint4096_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint4096_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint4096_t* 目标大数,dst=src1/src2
+ * \param src1 const huint4096_t* 源大数1
+ * \param src2 const huint4096_t* 源大数2
+ *
+ */
+void huint4096_div(huint4096_t *state,huint4096_t *state1,huint4096_t *state2,huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2);
+
+
+/** \brief 幂函数
+ *
+ * \param state huint4096_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint4096_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint4096_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint4096_t* 目标大数,dst=src1的src2次方
+ * \param src1 const huint4096_t* 源大数1
+ * \param src2 const huint4096_t* 源大数2
+ *
+ */
+void huint4096_power(huint4096_t *state,huint4096_t *state1,huint4096_t *state2,huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2);
+
+
+/** \brief 幂取模函数（常用于RSA等加密算法）
+ *
+ * \param state huint4096_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint4096_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint4096_t* 状态值，用于中间状态存储,不可为空
+ * \param state3 huint4096_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint4096_t* 目标大数,dst=src1的src2次方对src3取模
+ * \param src1 const huint4096_t* 源大数1
+ * \param src2 const huint4096_t* 源大数2
+ * \param src3 const huint4096_t* 源大数3
+ *
+ */
+void huint4096_power_mod(huint4096_t *state,huint4096_t *state1,huint4096_t *state2,huint4096_t *state3,huint4096_t *dst,const huint4096_t *src1,const huint4096_t *src2,const huint4096_t *src3);
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HUINT4096_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint512.c

@@ -0,0 +1,711 @@
+/***************************************************************
+ * Name:      huint512.c
+ * Purpose:   实现huint512接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "huint512.h"
+
+void huint512_load(huint512_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[i+3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[i+2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[i+1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[i+0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint512_load_be(huint512_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    if(bytes_count > sizeof(num->val))
+    {
+        //丢弃高位
+        size_t bytes_overflow=bytes_count-sizeof(huint512_t);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint512_load_uint32(huint512_t *num,uint32_t uint32_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=uint32_num;
+
+    //清零剩余值
+    for(size_t i=(1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint512_load_uint64(huint512_t *num,uint64_t uint64_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=((uint64_num>>0)&0xFFFFFFFF);
+    num->val[1]=((uint64_num>>32)&0xFFFFFFFF);
+
+    //清零剩余值
+    for(size_t i=(2); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint512_store(huint512_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[sizeof(num->val[0])*i+0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[sizeof(num->val[0])*i+1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[sizeof(num->val[0])*i+2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[sizeof(num->val[0])*i+3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint512_store_be(huint512_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    if(bytes_count > sizeof(num->val))
+    {
+        //高位置零
+        size_t bytes_overflow=bytes_count-sizeof(huint512_t);
+        memset(bytes,0,bytes_overflow);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint512_store_uint32(const huint512_t *num,uint32_t* uint32_num)
+{
+    if(num==NULL || uint32_num ==NULL)
+    {
+        return;
+    }
+    (*uint32_num)=num->val[0];
+}
+
+void huint512_store_uint64(const huint512_t *num,uint64_t* uint64_num)
+{
+    if(num==NULL || uint64_num ==NULL)
+    {
+        return;
+    }
+    (*uint64_num)=num->val[0]+(((uint64_t)num->val[1]) << 32);
+}
+
+void huint512_copy(huint512_t *dst,const huint512_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=src->val[i];
+    }
+}
+
+void huint512_bitwise_not(huint512_t *dst,const huint512_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(~src->val[i]);
+    }
+}
+
+void huint512_bitwise_and(huint512_t *dst,const huint512_t *src1,const huint512_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] & src2->val[i]);
+    }
+}
+
+void huint512_bitwise_or(huint512_t *dst,const huint512_t *src1,const huint512_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] | src2->val[i]);
+    }
+}
+
+void huint512_bitwise_xor(huint512_t *dst,const huint512_t *src1,const huint512_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] ^ src2->val[i]);
+    }
+}
+
+int huint512_compare(const huint512_t *src1,const huint512_t *src2)
+{
+    if(src1==NULL || src2==NULL)
+    {
+        return -2;
+    }
+    for(int i=((sizeof(src1->val)/sizeof(src2->val[0]))-1); i>=0 ; i--)
+    {
+        if(src1->val[i] > src2->val[i])
+        {
+            return 1;
+        }
+        if(src1->val[i] < src2->val[i])
+        {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+void huint512_complement(huint512_t *dst,const huint512_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    //取反
+    huint512_bitwise_not(dst,src);
+
+    //加1
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        if(i==0)
+        {
+            temp+=((uint64_t)dst->val[i])+1;
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+        else
+        {
+            temp+=((uint64_t)dst->val[i]);
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+    }
+}
+
+static size_t huint512_left_shift_internal(huint512_t *dst,const huint512_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((((uint64_t)src->val[i]) << (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)temp;
+        temp >>= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+void huint512_left_shift(huint512_t *dst,const huint512_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT512_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint512_load_uint32(dst,0);
+        return;
+    }
+
+    huint512_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint512_left_shift_internal(dst,dst,bits);
+    }
+}
+
+static size_t huint512_right_shift_internal(huint512_t *dst,const huint512_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(int i=((sizeof(dst->val)/sizeof(dst->val[0]))-1); i>=0 ; i--)
+    {
+        temp = (((((uint64_t)src->val[i]) << (sizeof(uint32_t)*8)) >> (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)(temp >> (sizeof(uint32_t)*8));
+        temp <<= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+
+void huint512_right_shift(huint512_t *dst,const huint512_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT512_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint512_load_uint32(dst,0);
+        return;
+    }
+
+    huint512_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint512_right_shift_internal(dst,dst,bits);
+    }
+}
+
+void huint512_bit_set(huint512_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT512_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] |= (1ULL << (bits%(sizeof(dst->val[0])*8)));
+    }
+}
+
+void huint512_bit_clear(huint512_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT512_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] &= (~(1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+}
+
+bool huint512_bit(const huint512_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT512_BITS_COUNT)
+        {
+            return false;
+        }
+
+        return 0!=(dst->val[bits/(sizeof(dst->val[0])*8)] & (1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+
+    return false;
+}
+
+size_t huint512_clz(const huint512_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT512_BITS_COUNT; i++)
+        {
+            if(huint512_bit(dst,HUINT512_BITS_COUNT-1-i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT512_BITS_COUNT;
+}
+
+size_t huint512_ctz(const huint512_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT512_BITS_COUNT; i++)
+        {
+            if(huint512_bit(dst,i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT512_BITS_COUNT;
+}
+
+void huint512_add(huint512_t *dst,const huint512_t *src1,const huint512_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((uint64_t)src1->val[i])+src2->val[i]+temp;
+        dst->val[i]=(uint32_t)temp;
+        temp>>=32;
+    }
+}
+
+void huint512_sub(huint512_t *dst,const huint512_t *src1,const huint512_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    //求补码
+    huint512_complement(dst,src2);
+
+    //对补码进行加
+    huint512_add(dst,dst,src1);
+}
+
+void huint512_mul(huint512_t *state,huint512_t *dst,const huint512_t *src1,const huint512_t *src2)
+{
+    if(state == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint512_load_uint32(dst,0);
+    size_t clz=huint512_clz(src2);
+    size_t ctz=huint512_ctz(src2);
+    for(size_t i=ctz; i < (HUINT512_BITS_COUNT-clz); i++)
+    {
+        if(huint512_bit(src2,i))
+        {
+            //当前位是1, src1左移后累加至结果
+            huint512_left_shift(state,src1,i);
+            huint512_add(dst,dst,state);
+        }
+    }
+}
+
+void huint512_div(huint512_t *state,huint512_t *state1,huint512_t *state2,huint512_t *dst,const huint512_t *src1,const huint512_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+
+    huint512_load_uint32(dst,0);
+    if(huint512_compare(src2,state)==0 )
+    {
+        huint512_load_uint32(state,0);
+        //除0错误
+        return;
+    }
+
+    if(huint512_compare(src2,src1) > 0)
+    {
+        //除数大于被除数
+        huint512_copy(state,src1);
+        huint512_load_uint32(dst,0);
+        return;
+    }
+
+    size_t clz1=huint512_clz(src1);
+    size_t clz2=huint512_clz(src2);
+    if(clz1 > clz2)
+    {
+        //除数大于被除数
+        huint512_copy(state,src1);
+        huint512_load_uint32(dst,0);
+        return;
+    }
+
+    huint512_copy(state,src1);
+
+    for(size_t i=0; i<= clz2-clz1; i++)
+    {
+        huint512_left_shift(state1,src2,(clz2-clz1)-i);
+        if(huint512_compare(state,state1) >= 0)
+        {
+            //被除数大于左移后的除数，直接相减并将相应位置1
+            huint512_sub(state2,state,state1);
+            huint512_bit_set(dst,(clz2-clz1)-i);
+            //余数保存至state
+            huint512_copy(state,state2);
+        }
+    }
+
+}
+
+void huint512_power(huint512_t *state,huint512_t *state1,huint512_t *state2,huint512_t *dst,const huint512_t *src1,const huint512_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint512_load_uint32(state,0);
+    huint512_load_uint32(dst,1);
+    if(huint512_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint512_load_uint32(dst,0);
+        return;
+    }
+    if(huint512_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint512_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint512_clz(src2);
+    huint512_copy(state,src1);
+    for(size_t i=0; i<(HUINT512_BITS_COUNT - clz2); i++)
+    {
+        if(huint512_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint512_mul(state1,state2,dst,state);
+            huint512_copy(dst,state2);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint512_mul(state1,state2,state,state);
+        huint512_copy(state,state2);
+    }
+
+}
+
+void huint512_power_mod(huint512_t *state,huint512_t *state1,huint512_t *state2,huint512_t *state3,huint512_t *dst,const huint512_t *src1,const huint512_t *src2,const huint512_t *src3)
+{
+    if(state == NULL || state1==NULL || state2== NULL || state3 == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint512_load_uint32(state,0);
+    huint512_load_uint32(dst,1);
+    if(huint512_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint512_load_uint32(dst,0);
+        return;
+    }
+    if(huint512_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint512_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint512_clz(src2);
+    huint512_copy(state,src1);
+    for(size_t i=0; i<(HUINT512_BITS_COUNT - clz2); i++)
+    {
+        if(huint512_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint512_mul(state1,state2,dst,state);
+            huint512_copy(dst,state2);
+
+            //对dst提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+            huint512_div(dst,state1,state2,state3,dst,src3);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint512_mul(state1,state2,state,state);
+        huint512_copy(state,state2);
+
+        //对state提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+        huint512_div(state,state1,state2,state3,state,src3);
+    }
+
+}

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint512.h

@@ -0,0 +1,294 @@
+/***************************************************************
+ * Name:      huint512.h
+ * Purpose:   声明huint512接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HUINT512_H__
+#define __HUINT512_H__
+#include "stdint.h"
+#include "stdbool.h"
+#include "stdlib.h"
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#define HUINT512_BITS_COUNT 512
+
+typedef struct huint512 huint512_t;
+struct huint512
+{
+    uint32_t val[(HUINT512_BITS_COUNT/(sizeof(uint32_t)*8))+((HUINT512_BITS_COUNT%(sizeof(uint32_t)*8))!=0?1:0)];
+};
+
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint512_t* 大数指针
+ * \param bytes const uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint512_load(huint512_t *num,const uint8_t *bytes,size_t bytes_count);
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint512_t* 大数指针
+ * \param bytes const uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint512_load_be(huint512_t *num,const uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint512_t* 大数
+ * \param uint32_num uint32_t 数字
+ *
+ */
+void huint512_load_uint32(huint512_t *num,uint32_t uint32_num);
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint512_t* 大数
+ * \param uint64_num uint64_t 数字
+ *
+ */
+void huint512_load_uint64(huint512_t *num,uint64_t uint64_num);
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint512_t* 大数指针
+ * \param bytes uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint512_store(huint512_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint512_t* 大数指针
+ * \param bytes uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint512_store_be(huint512_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数数字
+ *
+ * \param num huint512_t* 大数
+ * \param uint32_num uint32_t* 数字
+ *
+ */
+void huint512_store_uint32(const huint512_t *num,uint32_t* uint32_num);
+
+/** \brief 保存大数数字
+ *
+ * \param num huint512_t* 大数
+ * \param uint64_num uint64_t* 数字
+ *
+ */
+void huint512_store_uint64(const huint512_t *num,uint64_t* uint64_num);
+
+/** \brief 复制
+ *
+ * \param dst huint512_t* 目标大数
+ * \param src const huint512_t* 源大数
+ *
+ */
+void huint512_copy(huint512_t *dst,const huint512_t *src);
+
+/** \brief 按位非
+ *
+ * \param dst huint512_t* 目标大数
+ * \param src const huint512_t* 源大数
+ *
+ */
+void huint512_bitwise_not(huint512_t *dst,const huint512_t *src);
+
+/** \brief 按位与
+ *
+ * \param dst huint512_t* 目标大数
+ * \param src1 const huint512_t* 源大数1
+ * \param src2 const huint512_t* 源大数2
+ *
+ */
+void huint512_bitwise_and(huint512_t *dst,const huint512_t *src1,const huint512_t *src2);
+
+/** \brief 按位或
+ *
+ * \param dst huint512_t* 目标大数
+ * \param src1 const huint512_t* 源大数1
+ * \param src2 const huint512_t* 源大数2
+ *
+ */
+void huint512_bitwise_or(huint512_t *dst,const huint512_t *src1,const huint512_t *src2);
+
+/** \brief 按位异或
+ *
+ * \param dst huint512_t* 目标大数
+ * \param src1 const huint512_t* 源大数1
+ * \param src2 const huint512_t* 源大数2
+ *
+ */
+void huint512_bitwise_xor(huint512_t *dst,const huint512_t *src1,const huint512_t *src2);
+
+/** \brief 比较
+ *
+ * \param src1 const huint512_t* 源大数1
+ * \param src2 const huint512_t* 源大数2
+ * \return int 0=相等，1=源大数1大于源大数2,-1表示源大数2大于源大数1，-2=参数出错
+ *
+ */
+int huint512_compare(const huint512_t *src1,const huint512_t *src2);
+
+/** \brief 求补码
+ *
+ * \param dst huint512_t* 目标大数
+ * \param src const huint512_t* 源大数
+ *
+ */
+void huint512_complement(huint512_t *dst,const huint512_t *src);
+
+/** \brief 左移
+ *
+ * \param dst huint512_t* 目标大数
+ * \param src const huint512_t* 源大数
+ * \param bits size_t 左移位数
+ *
+ */
+void huint512_left_shift(huint512_t *dst,const huint512_t *src,size_t bits);
+
+/** \brief 右移
+ *
+ * \param dst huint512_t* 目标大数
+ * \param src const huint512_t* 源大数
+ * \param bits size_t 右移位数
+ *
+ */
+void huint512_right_shift(huint512_t *dst,const huint512_t *src,size_t bits);
+
+/** \brief 设置位
+ *
+ * \param dst huint512_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint512_bit_set(huint512_t *dst,size_t bits);
+
+/** \brief 清除位
+ *
+ * \param dst huint512_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint512_bit_clear(huint512_t *dst,size_t bits);
+
+/** \brief 获取位
+ *
+ * \param dst huint512_t* 目标大数
+ * \param bits size_t 位
+ * \return bool 位上的值
+ *
+ */
+bool huint512_bit(const huint512_t *dst,size_t bits);
+
+/** \brief 前导0的个数
+ *
+ * \param dst huint512_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint512_clz(const huint512_t *dst);
+
+/** \brief 尾部0的个数
+ *
+ * \param dst huint512_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint512_ctz(const huint512_t *dst);
+
+/** \brief 加
+ *
+ * \param dst huint512_t* 目标大数
+ * \param src1 const huint512_t* 源大数1
+ * \param src2 const huint512_t* 源大数2
+ *
+ */
+void huint512_add(huint512_t *dst,const huint512_t *src1,const huint512_t *src2);
+
+
+/** \brief 减
+ *
+ * \param dst huint512_t* 目标大数,dst=src1-src2
+ * \param src1 const huint512_t* 源大数1
+ * \param src2 const huint512_t* 源大数2
+ *
+ */
+void huint512_sub(huint512_t *dst,const huint512_t *src1,const huint512_t *src2);
+
+/** \brief 乘
+ *
+ * \param state huint512_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint512_t* 目标大数,dst=src1*src2
+ * \param src1 const huint512_t* 源大数1
+ * \param src2 const huint512_t* 源大数2
+ *
+ */
+void huint512_mul(huint512_t *state,huint512_t *dst,const huint512_t *src1,const huint512_t *src2);
+
+
+/** \brief 除
+ *
+ * \param state huint512_t* 状态值，存储余数。state=src1%src2
+ * \param state1 huint512_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint512_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint512_t* 目标大数,dst=src1/src2
+ * \param src1 const huint512_t* 源大数1
+ * \param src2 const huint512_t* 源大数2
+ *
+ */
+void huint512_div(huint512_t *state,huint512_t *state1,huint512_t *state2,huint512_t *dst,const huint512_t *src1,const huint512_t *src2);
+
+
+/** \brief 幂函数
+ *
+ * \param state huint512_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint512_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint512_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint512_t* 目标大数,dst=src1的src2次方
+ * \param src1 const huint512_t* 源大数1
+ * \param src2 const huint512_t* 源大数2
+ *
+ */
+void huint512_power(huint512_t *state,huint512_t *state1,huint512_t *state2,huint512_t *dst,const huint512_t *src1,const huint512_t *src2);
+
+
+/** \brief 幂取模函数（常用于RSA等加密算法）
+ *
+ * \param state huint512_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint512_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint512_t* 状态值，用于中间状态存储,不可为空
+ * \param state3 huint512_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint512_t* 目标大数,dst=src1的src2次方对src3取模
+ * \param src1 const huint512_t* 源大数1
+ * \param src2 const huint512_t* 源大数2
+ * \param src3 const huint512_t* 源大数3
+ *
+ */
+void huint512_power_mod(huint512_t *state,huint512_t *state1,huint512_t *state2,huint512_t *state3,huint512_t *dst,const huint512_t *src1,const huint512_t *src2,const huint512_t *src3);
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HUINT512_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint8192.c

@@ -0,0 +1,711 @@
+/***************************************************************
+ * Name:      huint8192.c
+ * Purpose:   实现huint8192接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#include "huint8192.h"
+
+void huint8192_load(huint8192_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[i+3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[i+2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[i+1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[i+0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint8192_load_be(huint8192_t *num,const uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    size_t max_index=0;
+    if(bytes_count > sizeof(num->val))
+    {
+        //丢弃高位
+        size_t bytes_overflow=bytes_count-sizeof(huint8192_t);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    //将已有字节赋值
+    for(size_t i=0; i<bytes_count;)
+    {
+        uint32_t val=0;
+        size_t bytes_remain=bytes_count-i;
+        if(bytes_remain >= 4)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-3];
+        }
+        if(bytes_remain >= 3)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-2];
+        }
+        if(bytes_remain >= 2)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-1];
+        }
+        if(bytes_remain >= 1)
+        {
+            val<<=8;
+            val+=bytes[(bytes_count-1-i)-0];
+        }
+        {
+            size_t index=(i/sizeof(num->val[0]));
+            if(index < (sizeof(num->val)/sizeof(num->val[0])))
+            {
+                num->val[index]=val;
+            }
+            max_index=index;
+        }
+        if(bytes_remain >= sizeof(num->val[0]))
+        {
+            i+=sizeof(num->val[0]);
+        }
+        else
+        {
+            i+=bytes_remain;
+        }
+    }
+
+    //清零剩余值
+    for(size_t i=(max_index+1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint8192_load_uint32(huint8192_t *num,uint32_t uint32_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=uint32_num;
+
+    //清零剩余值
+    for(size_t i=(1); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint8192_load_uint64(huint8192_t *num,uint64_t uint64_num)
+{
+    if(num==NULL)
+    {
+        return;
+    }
+    num->val[0]=((uint64_num>>0)&0xFFFFFFFF);
+    num->val[1]=((uint64_num>>32)&0xFFFFFFFF);
+
+    //清零剩余值
+    for(size_t i=(2); i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        num->val[i]=0;
+    }
+}
+
+void huint8192_store(huint8192_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[sizeof(num->val[0])*i+0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[sizeof(num->val[0])*i+1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[sizeof(num->val[0])*i+2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[sizeof(num->val[0])*i+3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint8192_store_be(huint8192_t *num,uint8_t *bytes,size_t bytes_count)
+{
+    if(num==NULL || bytes==NULL)
+    {
+        return;
+    }
+    if(bytes_count > sizeof(num->val))
+    {
+        //高位置零
+        size_t bytes_overflow=bytes_count-sizeof(huint8192_t);
+        memset(bytes,0,bytes_overflow);
+        bytes+=bytes_overflow;
+        bytes_count-=bytes_overflow;
+    }
+    for(size_t i=0; i< (sizeof(num->val)/sizeof(num->val[0])); i++)
+    {
+        if(sizeof(num->val[0])*i >= bytes_count)
+        {
+            break;
+        }
+        size_t bytes_remain=bytes_count-sizeof(num->val[0])*i;
+        if(bytes_remain >=1)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-0]=((num->val[i] >> 0)&0xFF);
+        }
+        if(bytes_remain >=2)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-1]=((num->val[i] >> 8)&0xFF);
+        }
+        if(bytes_remain >=3)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-2]=((num->val[i] >> 16)&0xFF);
+        }
+        if(bytes_remain >=4)
+        {
+            bytes[(bytes_count-1)-sizeof(num->val[0])*i-3]=((num->val[i] >> 24)&0xFF);
+        }
+    }
+}
+
+void huint8192_store_uint32(const huint8192_t *num,uint32_t* uint32_num)
+{
+    if(num==NULL || uint32_num ==NULL)
+    {
+        return;
+    }
+    (*uint32_num)=num->val[0];
+}
+
+void huint8192_store_uint64(const huint8192_t *num,uint64_t* uint64_num)
+{
+    if(num==NULL || uint64_num ==NULL)
+    {
+        return;
+    }
+    (*uint64_num)=num->val[0]+(((uint64_t)num->val[1]) << 32);
+}
+
+void huint8192_copy(huint8192_t *dst,const huint8192_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=src->val[i];
+    }
+}
+
+void huint8192_bitwise_not(huint8192_t *dst,const huint8192_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(~src->val[i]);
+    }
+}
+
+void huint8192_bitwise_and(huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] & src2->val[i]);
+    }
+}
+
+void huint8192_bitwise_or(huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] | src2->val[i]);
+    }
+}
+
+void huint8192_bitwise_xor(huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2==NULL)
+    {
+        return;
+    }
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        dst->val[i]=(src1->val[i] ^ src2->val[i]);
+    }
+}
+
+int huint8192_compare(const huint8192_t *src1,const huint8192_t *src2)
+{
+    if(src1==NULL || src2==NULL)
+    {
+        return -2;
+    }
+    for(int i=((sizeof(src1->val)/sizeof(src2->val[0]))-1); i>=0 ; i--)
+    {
+        if(src1->val[i] > src2->val[i])
+        {
+            return 1;
+        }
+        if(src1->val[i] < src2->val[i])
+        {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+void huint8192_complement(huint8192_t *dst,const huint8192_t *src)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+    //取反
+    huint8192_bitwise_not(dst,src);
+
+    //加1
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        if(i==0)
+        {
+            temp+=((uint64_t)dst->val[i])+1;
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+        else
+        {
+            temp+=((uint64_t)dst->val[i]);
+            dst->val[i]=(uint32_t)temp;
+            temp>>=32;
+        }
+    }
+}
+
+static size_t huint8192_left_shift_internal(huint8192_t *dst,const huint8192_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((((uint64_t)src->val[i]) << (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)temp;
+        temp >>= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+void huint8192_left_shift(huint8192_t *dst,const huint8192_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT8192_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint8192_load_uint32(dst,0);
+        return;
+    }
+
+    huint8192_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint8192_left_shift_internal(dst,dst,bits);
+    }
+}
+
+static size_t huint8192_right_shift_internal(huint8192_t *dst,const huint8192_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return 0;
+    }
+
+    size_t bit_shift=sizeof(uint32_t)*8;
+    if(bit_shift>bits)
+    {
+        bit_shift=bits;
+    }
+
+    uint64_t temp=0;
+    for(int i=((sizeof(dst->val)/sizeof(dst->val[0]))-1); i>=0 ; i--)
+    {
+        temp = (((((uint64_t)src->val[i]) << (sizeof(uint32_t)*8)) >> (bit_shift)) | temp);
+        dst->val[i]=(uint32_t)(temp >> (sizeof(uint32_t)*8));
+        temp <<= (sizeof(uint32_t)*8);
+    }
+
+    return bit_shift;
+}
+
+
+void huint8192_right_shift(huint8192_t *dst,const huint8192_t *src,size_t bits)
+{
+    if(dst==NULL || src==NULL)
+    {
+        return;
+    }
+
+    if(bits >= HUINT8192_BITS_COUNT)
+    {
+        //大于等于大数的位数，直接置0
+        huint8192_load_uint32(dst,0);
+        return;
+    }
+
+    huint8192_copy(dst,src);
+
+    while(bits > 0)
+    {
+        bits-=huint8192_right_shift_internal(dst,dst,bits);
+    }
+}
+
+void huint8192_bit_set(huint8192_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT8192_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] |= (1ULL << (bits%(sizeof(dst->val[0])*8)));
+    }
+}
+
+void huint8192_bit_clear(huint8192_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT8192_BITS_COUNT)
+        {
+            return;
+        }
+
+        dst->val[bits/(sizeof(dst->val[0])*8)] &= (~(1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+}
+
+bool huint8192_bit(const huint8192_t *dst,size_t bits)
+{
+    if(dst!=NULL)
+    {
+        if(bits >= HUINT8192_BITS_COUNT)
+        {
+            return false;
+        }
+
+        return 0!=(dst->val[bits/(sizeof(dst->val[0])*8)] & (1ULL << (bits%(sizeof(dst->val[0])*8))));
+    }
+
+    return false;
+}
+
+size_t huint8192_clz(const huint8192_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT8192_BITS_COUNT; i++)
+        {
+            if(huint8192_bit(dst,HUINT8192_BITS_COUNT-1-i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT8192_BITS_COUNT;
+}
+
+size_t huint8192_ctz(const huint8192_t *dst)
+{
+    if(dst!=NULL)
+    {
+        for(size_t i=0; i < HUINT8192_BITS_COUNT; i++)
+        {
+            if(huint8192_bit(dst,i))
+            {
+                return i;
+            }
+        }
+    }
+
+    return HUINT8192_BITS_COUNT;
+}
+
+void huint8192_add(huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    uint64_t temp=0;
+    for(size_t i=0; i< (sizeof(dst->val)/sizeof(dst->val[0])); i++)
+    {
+        temp=((uint64_t)src1->val[i])+src2->val[i]+temp;
+        dst->val[i]=(uint32_t)temp;
+        temp>>=32;
+    }
+}
+
+void huint8192_sub(huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2)
+{
+    if(dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    //求补码
+    huint8192_complement(dst,src2);
+
+    //对补码进行加
+    huint8192_add(dst,dst,src1);
+}
+
+void huint8192_mul(huint8192_t *state,huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2)
+{
+    if(state == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint8192_load_uint32(dst,0);
+    size_t clz=huint8192_clz(src2);
+    size_t ctz=huint8192_ctz(src2);
+    for(size_t i=ctz; i < (HUINT8192_BITS_COUNT-clz); i++)
+    {
+        if(huint8192_bit(src2,i))
+        {
+            //当前位是1, src1左移后累加至结果
+            huint8192_left_shift(state,src1,i);
+            huint8192_add(dst,dst,state);
+        }
+    }
+}
+
+void huint8192_div(huint8192_t *state,huint8192_t *state1,huint8192_t *state2,huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+
+    huint8192_load_uint32(dst,0);
+    if(huint8192_compare(src2,state)==0 )
+    {
+        huint8192_load_uint32(state,0);
+        //除0错误
+        return;
+    }
+
+    if(huint8192_compare(src2,src1) > 0)
+    {
+        //除数大于被除数
+        huint8192_copy(state,src1);
+        huint8192_load_uint32(dst,0);
+        return;
+    }
+
+    size_t clz1=huint8192_clz(src1);
+    size_t clz2=huint8192_clz(src2);
+    if(clz1 > clz2)
+    {
+        //除数大于被除数
+        huint8192_copy(state,src1);
+        huint8192_load_uint32(dst,0);
+        return;
+    }
+
+    huint8192_copy(state,src1);
+
+    for(size_t i=0; i<= clz2-clz1; i++)
+    {
+        huint8192_left_shift(state1,src2,(clz2-clz1)-i);
+        if(huint8192_compare(state,state1) >= 0)
+        {
+            //被除数大于左移后的除数，直接相减并将相应位置1
+            huint8192_sub(state2,state,state1);
+            huint8192_bit_set(dst,(clz2-clz1)-i);
+            //余数保存至state
+            huint8192_copy(state,state2);
+        }
+    }
+
+}
+
+void huint8192_power(huint8192_t *state,huint8192_t *state1,huint8192_t *state2,huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2)
+{
+    if(state == NULL || state1==NULL || state2== NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint8192_load_uint32(state,0);
+    huint8192_load_uint32(dst,1);
+    if(huint8192_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint8192_load_uint32(dst,0);
+        return;
+    }
+    if(huint8192_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint8192_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint8192_clz(src2);
+    huint8192_copy(state,src1);
+    for(size_t i=0; i<(HUINT8192_BITS_COUNT - clz2); i++)
+    {
+        if(huint8192_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint8192_mul(state1,state2,dst,state);
+            huint8192_copy(dst,state2);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint8192_mul(state1,state2,state,state);
+        huint8192_copy(state,state2);
+    }
+
+}
+
+void huint8192_power_mod(huint8192_t *state,huint8192_t *state1,huint8192_t *state2,huint8192_t *state3,huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2,const huint8192_t *src3)
+{
+    if(state == NULL || state1==NULL || state2== NULL || state3 == NULL || dst==NULL || src1==NULL || src2 == NULL)
+    {
+        return;
+    }
+
+    huint8192_load_uint32(state,0);
+    huint8192_load_uint32(dst,1);
+    if(huint8192_compare(src1,state)==0 )
+    {
+        //底数为0
+        huint8192_load_uint32(dst,0);
+        return;
+    }
+    if(huint8192_compare(src2,state)==0 )
+    {
+        //任意数的0次方=1
+        huint8192_load_uint32(dst,1);
+        return;
+    }
+
+    size_t clz2=huint8192_clz(src2);
+    huint8192_copy(state,src1);
+    for(size_t i=0; i<(HUINT8192_BITS_COUNT - clz2); i++)
+    {
+        if(huint8192_bit(src2,i))
+        {
+            //,结果应当乘上当前state的值(将幂函数的指数按照2进制进行拆分成乘法表达式)
+            huint8192_mul(state1,state2,dst,state);
+            huint8192_copy(dst,state2);
+
+            //对dst提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+            huint8192_div(dst,state1,state2,state3,dst,src3);
+        }
+        //计算state的平方（state的平方相当于state的指数乘2，正好对应src2下一个二进制位）
+        huint8192_mul(state1,state2,state,state);
+        huint8192_copy(state,state2);
+
+        //对state提前取模，防止计算过程溢出(先取模再做乘法=先做乘法再取模)
+        huint8192_div(state,state1,state2,state3,state,src3);
+    }
+
+}

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/huint8192.h

@@ -0,0 +1,294 @@
+/***************************************************************
+ * Name:      huint8192.h
+ * Purpose:   声明huint8192接口
+ * Author:    HYH (hyhsystem.cn)
+ * Created:   2025-04-23
+ * Copyright: HYH (hyhsystem.cn)
+ * License:   MIT
+ **************************************************************/
+#ifndef __HUINT8192_H__
+#define __HUINT8192_H__
+#include "stdint.h"
+#include "stdbool.h"
+#include "stdlib.h"
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+#define HUINT8192_BITS_COUNT 8192
+
+typedef struct huint8192 huint8192_t;
+struct huint8192
+{
+    uint32_t val[(HUINT8192_BITS_COUNT/(sizeof(uint32_t)*8))+((HUINT8192_BITS_COUNT%(sizeof(uint32_t)*8))!=0?1:0)];
+};
+
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint8192_t* 大数指针
+ * \param bytes const uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint8192_load(huint8192_t *num,const uint8_t *bytes,size_t bytes_count);
+
+/** \brief 从字节中加载大数
+ *
+ * \param num huint8192_t* 大数指针
+ * \param bytes const uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint8192_load_be(huint8192_t *num,const uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint8192_t* 大数
+ * \param uint32_num uint32_t 数字
+ *
+ */
+void huint8192_load_uint32(huint8192_t *num,uint32_t uint32_num);
+
+/** \brief 从数字中加载大数
+ *
+ * \param num huint8192_t* 大数
+ * \param uint64_num uint64_t 数字
+ *
+ */
+void huint8192_load_uint64(huint8192_t *num,uint64_t uint64_num);
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint8192_t* 大数指针
+ * \param bytes uint8_t* 字节（小端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint8192_store(huint8192_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数到字节
+ *
+ * \param num huint8192_t* 大数指针
+ * \param bytes uint8_t* 字节（大端模式）
+ * \param bytes_count size_t 字节长度
+ *
+ */
+void huint8192_store_be(huint8192_t *num,uint8_t *bytes,size_t bytes_count);
+
+
+/** \brief 保存大数数字
+ *
+ * \param num huint8192_t* 大数
+ * \param uint32_num uint32_t* 数字
+ *
+ */
+void huint8192_store_uint32(const huint8192_t *num,uint32_t* uint32_num);
+
+/** \brief 保存大数数字
+ *
+ * \param num huint8192_t* 大数
+ * \param uint64_num uint64_t* 数字
+ *
+ */
+void huint8192_store_uint64(const huint8192_t *num,uint64_t* uint64_num);
+
+/** \brief 复制
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param src const huint8192_t* 源大数
+ *
+ */
+void huint8192_copy(huint8192_t *dst,const huint8192_t *src);
+
+/** \brief 按位非
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param src const huint8192_t* 源大数
+ *
+ */
+void huint8192_bitwise_not(huint8192_t *dst,const huint8192_t *src);
+
+/** \brief 按位与
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param src1 const huint8192_t* 源大数1
+ * \param src2 const huint8192_t* 源大数2
+ *
+ */
+void huint8192_bitwise_and(huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2);
+
+/** \brief 按位或
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param src1 const huint8192_t* 源大数1
+ * \param src2 const huint8192_t* 源大数2
+ *
+ */
+void huint8192_bitwise_or(huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2);
+
+/** \brief 按位异或
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param src1 const huint8192_t* 源大数1
+ * \param src2 const huint8192_t* 源大数2
+ *
+ */
+void huint8192_bitwise_xor(huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2);
+
+/** \brief 比较
+ *
+ * \param src1 const huint8192_t* 源大数1
+ * \param src2 const huint8192_t* 源大数2
+ * \return int 0=相等，1=源大数1大于源大数2,-1表示源大数2大于源大数1，-2=参数出错
+ *
+ */
+int huint8192_compare(const huint8192_t *src1,const huint8192_t *src2);
+
+/** \brief 求补码
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param src const huint8192_t* 源大数
+ *
+ */
+void huint8192_complement(huint8192_t *dst,const huint8192_t *src);
+
+/** \brief 左移
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param src const huint8192_t* 源大数
+ * \param bits size_t 左移位数
+ *
+ */
+void huint8192_left_shift(huint8192_t *dst,const huint8192_t *src,size_t bits);
+
+/** \brief 右移
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param src const huint8192_t* 源大数
+ * \param bits size_t 右移位数
+ *
+ */
+void huint8192_right_shift(huint8192_t *dst,const huint8192_t *src,size_t bits);
+
+/** \brief 设置位
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint8192_bit_set(huint8192_t *dst,size_t bits);
+
+/** \brief 清除位
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param bits size_t 位
+ *
+ */
+void huint8192_bit_clear(huint8192_t *dst,size_t bits);
+
+/** \brief 获取位
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param bits size_t 位
+ * \return bool 位上的值
+ *
+ */
+bool huint8192_bit(const huint8192_t *dst,size_t bits);
+
+/** \brief 前导0的个数
+ *
+ * \param dst huint8192_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint8192_clz(const huint8192_t *dst);
+
+/** \brief 尾部0的个数
+ *
+ * \param dst huint8192_t* 目标大数
+ * \return size_t 前导0的个数
+ *
+ */
+size_t huint8192_ctz(const huint8192_t *dst);
+
+/** \brief 加
+ *
+ * \param dst huint8192_t* 目标大数
+ * \param src1 const huint8192_t* 源大数1
+ * \param src2 const huint8192_t* 源大数2
+ *
+ */
+void huint8192_add(huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2);
+
+
+/** \brief 减
+ *
+ * \param dst huint8192_t* 目标大数,dst=src1-src2
+ * \param src1 const huint8192_t* 源大数1
+ * \param src2 const huint8192_t* 源大数2
+ *
+ */
+void huint8192_sub(huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2);
+
+/** \brief 乘
+ *
+ * \param state huint8192_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint8192_t* 目标大数,dst=src1*src2
+ * \param src1 const huint8192_t* 源大数1
+ * \param src2 const huint8192_t* 源大数2
+ *
+ */
+void huint8192_mul(huint8192_t *state,huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2);
+
+
+/** \brief 除
+ *
+ * \param state huint8192_t* 状态值，存储余数。state=src1%src2
+ * \param state1 huint8192_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint8192_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint8192_t* 目标大数,dst=src1/src2
+ * \param src1 const huint8192_t* 源大数1
+ * \param src2 const huint8192_t* 源大数2
+ *
+ */
+void huint8192_div(huint8192_t *state,huint8192_t *state1,huint8192_t *state2,huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2);
+
+
+/** \brief 幂函数
+ *
+ * \param state huint8192_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint8192_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint8192_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint8192_t* 目标大数,dst=src1的src2次方
+ * \param src1 const huint8192_t* 源大数1
+ * \param src2 const huint8192_t* 源大数2
+ *
+ */
+void huint8192_power(huint8192_t *state,huint8192_t *state1,huint8192_t *state2,huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2);
+
+
+/** \brief 幂取模函数（常用于RSA等加密算法）
+ *
+ * \param state huint8192_t* 状态值，用于中间状态存储,不可为空
+ * \param state1 huint8192_t* 状态值，用于中间状态存储,不可为空
+ * \param state2 huint8192_t* 状态值，用于中间状态存储,不可为空
+ * \param state3 huint8192_t* 状态值，用于中间状态存储,不可为空
+ * \param dst huint8192_t* 目标大数,dst=src1的src2次方对src3取模
+ * \param src1 const huint8192_t* 源大数1
+ * \param src2 const huint8192_t* 源大数2
+ * \param src3 const huint8192_t* 源大数3
+ *
+ */
+void huint8192_power_mod(huint8192_t *state,huint8192_t *state1,huint8192_t *state2,huint8192_t *state3,huint8192_t *dst,const huint8192_t *src1,const huint8192_t *src2,const huint8192_t *src3);
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+
+#endif // __HUINT8192_H__

FW/package/3rdparty/HCppBox/master/hbox/hcrypto/hbignum/update.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+
+#检查工具是否存在,$1为待检查的工具名。
+function CheckTool
+{
+	[  -n "$1"  ] ||
+	{
+		echo -e  "\033[41;37mCheckTool 参数错误!!\r\n\033[40;37m";
+		return 255;
+	};
+	ToolPath=`which $1`;
+	[ -e "$ToolPath" ] ||
+	{
+		 echo -e "\033[41;37m$1 不存在，请先安装此工具\r\n\033[40;37m";
+		 return 255;
+	};
+	return 0;
+}
+
+CheckTool git
+[ $? -eq 0 ] || exit;
+CheckTool mkdir
+[ $? -eq 0 ] || exit;
+CheckTool sed
+[ $? -eq 0 ] || exit;
+
+
+#获取当前目录
+slef_path=
+# shellcheck disable=SC2128  # ignore array expansion warning
+if [ -n "${BASH_SOURCE-}" ]
+then
+        self_path="${BASH_SOURCE}"
+elif [ -n "${ZSH_VERSION-}" ]
+then
+        self_path="${(%):-%x}"
+else
+        return 1
+fi
+# shellcheck disable=SC2169,SC2169,SC2039  # unreachable with 'dash'
+if [[ "$OSTYPE" == "darwin"* ]]; then
+        # convert possibly relative path to absolute
+        script_dir="$(realpath_int "${self_path}")"
+        # resolve any ../ references to make the path shorter
+        script_dir="$(cd "${script_dir}" || exit 1; pwd)"
+else
+        # convert to full path and get the directory name of that
+        script_name="$(readlink -f "${self_path}")"
+        script_dir="$(dirname "${script_name}")"
+fi
+
+
+pushd "${script_dir}"
+
+#uint128为基础模板
+
+##uint256
+cp huint128.h huint256.h
+cp huint128.c huint256.c
+sed -i "s/128/256/g" huint256.*
+
+##uint512
+cp huint128.h huint512.h
+cp huint128.c huint512.c
+sed -i "s/128/512/g" huint512.*
+
+##uint1024
+cp huint128.h huint1024.h
+cp huint128.c huint1024.c
+sed -i "s/128/1024/g" huint1024.*
+
+
+##uint2048
+cp huint128.h huint2048.h
+cp huint128.c huint2048.c
+sed -i "s/128/2048/g" huint2048.*
+
+##uint4096
+cp huint128.h huint4096.h
+cp huint128.c huint4096.c
+sed -i "s/128/4096/g" huint4096.*
+
+##uint8192
+cp huint128.h huint8192.h
+cp huint128.c huint8192.c
+sed -i "s/128/8192/g" huint8192.*
+
+
+popd