Optimizing a sponge's hash supertree structure

Abstract

The application discloses an optimized sponge hash super-tree structure. The structure can effectively improve the confusion and diffusion performance in the traditional sponge structure, and reduce the problem of excessive key generation and complex calculation process in the quantum-resistant password. Based on the Feistel optimized sponge structure, the birthday paradox problem in the hash function can be effectively improved, and the data generated by the hash super-tree is ensured to have good confusion and diffusion. In the structure, the optimized sponge hash super-tree is divided into a hash nested hash super-tree structure and a Feistel improved sponge structure, wherein the hash nested hash super-tree structure adopts different hash functions for nodes with different heights according to the height of the tree, so as to complete the construction of the whole tree structure; the Feistel improved sponge structure designs different functions for the "absorption" and "extrusion" stages, so as to improve the confusion and diffusion performance of the hash function, applies the output result of the sponge structure as a leaf node to the sub-tree, sets different types of hash functions for nodes with different heights, and then obtains the whole hash super-tree, and stores all the nodes in a database system, and stores part of the nodes as different types of keys in a key pool.

Description

Technical Field

[0001] This invention belongs to the field of information security and relates to an active defense method based on hash and tree structure. Background Technology

[0002] With the advent of quantum computers, traditional cryptographic algorithms based on mathematically difficult problems are no longer secure. Currently, the main types of quantum-resistant cryptography include hash-based, grid-based, encoding-based, and multivariate-based algorithms. Among these, hash-based quantum-resistant cryptographic algorithms have a significant advantage in key generation and computational complexity, while grid-based quantum-resistant cryptographic algorithms offer the best balance between data privacy and integrity. In 2011, Johannes Buchmann et al. proposed the extended Merkle Signature Scheme (XMSS), which is currently the most secure digital signature algorithm based on hash functions. Meanwhile, in 2008, Johannes Buchmann et al. improved upon existing grid-based solutions by proposing a lattice basis sequence with increased dimension to solve the Shortest Vector Problem (SVP) difficult instance. In 2013, Thijs Laarhoven et al. applied the Grover quantum search algorithm to random lattice algorithms to solve the shortest vector problem. Later, Florian... They proposed a quantum attack model based on the Learning With Errors (LWE) problem and demonstrated the terrifying destructive power of quantum hybrid attacks.

[0003] While grid-based quantum-resistant cryptographic algorithms can achieve good quantum-resistant properties, they suffer from problems such as excessive key quantity and cumbersome operation process. To address this issue, we propose an optimized sponge-based hash nested hash supertree structure to construct the key pool, thereby obtaining a smaller key generation quantity and reducing the computational complexity of the cryptographic algorithm. This achieves a balanced and more effective proactive defense strategy, further improving the structure and privacy of the quantum-resistant cryptographic algorithm, and ensuring the confidentiality, integrity, and availability of data. Summary of the Invention

[0004] This invention addresses the problems of excessive key generation and cumbersome operation and design processes in quantum-resistant cryptography algorithms, thereby improving data privacy, integrity, and availability. It enhances the obfuscation and diffusion performance of the data processing flow by optimizing the sponge structure in the hash function, and manages the hash nodes of the optimized sponge using a supertree structure.

[0005] Its technical solution is:

[0006] To address the issues of large key generation quantities and complex computation processes in quantum-resistant cryptography algorithms, an optimized sponge-based hash supertree structure is employed to protect data privacy and verify its integrity.

[0007] a. Optimize the hash tree structure by nesting hashes in the ordinary tree structure and optimizing the sponge structure within it, focusing on optimizing and updating its obfuscation and diffusion performance;

[0008] b. The supertree structure is improved by using a hash nested hash pattern. In a tree structure, different hash functions are used for nodes at different heights.

[0009] c. Optimize the processing of hash supertrees, focusing on improving their obfuscation and diffusion performance, corresponding to the "absorption" and "squeeze" stages, to increase the complexity and completeness of the data processing flow;

[0010] To optimize the confusion and diffusion performance of the sponge structure, the Feistel Structure (hereinafter referred to as Feistel) is used to optimize and improve the "absorption" and "extrusion" stages of the sponge structure separately:

[0011] First, based on Feistel, the confusion process in the sponge structure is optimized by improving the function f(M, d) in the "absorption" stage:

[0012] f(M,d)=f[f(r,i)+padding10*1,r](M,i)+f[f(c,i′)+padding′10*1,r](M,i′) (1)

[0013] Here, variables M and d represent the number of bits absorbed by the message and structure, respectively. In the function body, padding represents adding r bits to the data block, padding′ represents adding c bits to the data block, and r+c represents the status bits. The padding and use of f(M, d) are completed through f(r, i) and f(c, i′).

[0014] Secondly, the function for the "squeezing" stage in the sponge structure is optimized using Feistel:

[0015] g(M, d′)=g(M||(01)) d ,d′) (2)

[0016] Where d′ represents the number of bits squeezed into the data block, that is, d bits are first absorbed into message M and then d′ bits are squeezed out.

[0017] d. Apply the outputs of the "absorption" and "squeeze" functions in the sponge structure as leaf nodes to the subtree:

[0018] First, through a hash function Solve for the leaf nodes to obtain their parent nodes, iterating upwards layer by layer until the height of the tree is h:

[0019]

[0020] Secondly, starting from the tree height h, through the hash function The calculations are completed for each node, iterating upwards layer by layer until the height of the tree is h+h':

[0021]

[0022] Considering the cycle problem caused by nodes having the same value, non-linear operations such as substitution and permutation are used to ensure the uniqueness of each node, thereby ensuring that the tree structure can become a full binary tree without cycles.

[0023] Finally, the node ω is divided into two parts: ω1 and ω2. r And perform an XOR operation on the two parts:

[0024]

[0025] Then, nonlinear operations of ι, γ, π, and θ are performed on the nodes to achieve numerical substitution, permutation, and left / right rotation:

[0026]

[0027] For any two child nodes, solve for their parent node using the above formula, iterating upwards until the height of the tree is h+h'+H;

[0028] e. After constructing the supertree structure of nested hashes, store all nodes in the database, and store nodes of different heights in different types of databases, thereby updating and using the key data in the key pool.

[0029] The present invention has the following beneficial technical effects:

[0030] This invention combines a supertree structure with a hash function to design a novel data structure for quantum-resistant cryptographic algorithms. It optimizes the confusion and diffusion of the functions in the "absorption" and "squeezing" stages of the sponge structure, implementing the nonlinear processing flow of the algorithm based on Feistel. The output of the optimized sponge is stored as leaf nodes in the subtree. Different hash functions are set for different heights of the tree structure, ultimately constructing a complete nested hash supertree. All generated supertree nodes are stored in a database system, with nodes of different heights stored in different types of database systems, further constructing the key data in the key pool. Attached Figure Description

[0031] Figure 1 For Feistel-optimized sponge structure

[0032] Figure 2 Subtree structure in a hash nested hash supertree

[0033] Figure 3 A hash tree nested within a hash supertree structure Detailed Implementation

[0034] The accompanying drawings are for illustrative purposes only and should not be construed as limiting the scope of this patent.

[0035] The present invention will be further described below with reference to the accompanying drawings and embodiments:

[0036] The basic idea of ​​this invention is to optimize the complexity of key generation and distribution in quantum-resistant cryptographic algorithms. Assuming that the key pool generation and distribution volume in quantum-resistant cryptographic algorithms is extremely large, in order to simplify the key quantity and reduce the computational complexity of the cryptographic algorithm, the hash tree structure is optimized. The main steps include two parts: supertree design and sponge optimization. The supertree adopts a hash nested hash supertree structure, while the sponge structure is optimized using Feistel to achieve confusion and diffusion of functions in the "absorption" and "diffusion" stages.

[0037] Combination Figure 1 An optimized sponge-based hash supertree is used to generate and distribute the key pool.

[0038] For the "absorption" stage in the sponge structure, confusion optimization is performed based on Feistel, using a hash function f(M, d); the main calculation steps are as follows:

[0039] f(M,d)=f[f(r,i)+padding10*1,r](M,i)+f[f(c,i′)+padding′10*1,r](M,i′) (1)

[0040] Here, padding and padding′ represent the padding bits for the sponge, filling bits r and c in the sponge with i bits and i′ bits respectively, while r+c represents the state bits.

[0041] For the "squeezing" stage in the sponge, the hash function g(M, d′) is used for diffusion, and its main steps are as follows;

[0042] g(M, d′)=g(M||(01)) d ,d′) (2)

[0043] Where d represents the number of bits "absorbed" by the sponge structure, and d′ represents the number of bits "squeezed".

[0044] Figure 2 This is a subtree structure of a hash nested hash supertree. The output of the optimized sponge structure is used as leaves in the subtree, assuming... This represents the value of the i-th node at level j in the subtree. The identifier representing this node is obtained using a hash function. For any two child nodes, find their parent node, and proceed upwards layer by layer until the height of the tree structure is h;

[0045]

[0046] Figure 3 This is a supertree structure where hashes are nested within hashes. First, the root node of each subtree is used as a leaf node of the entire tree. Let's assume... This represents the value of the i-th node at level j in the tree structure. The identifier representing this node is generated using a hash function. Find the parent node for any two child nodes:

[0047]

[0048] Iterate through the above formula until the height of the tree is h+h'. Considering the problem of cycles caused by nodes having the same value, non-linear operations such as substitution and permutation are used to ensure the uniqueness of each node, thereby ensuring that a full binary tree can be constructed.

[0049] First, divide node ω into two parts: left and right: ω l With ω r And perform an XOR operation on the two parts:

[0050] ω=ω l +ω r (5)

[0051] Then, nonlinear operations such as ι, γ, π, and θ are performed on the nodes to achieve substitution, permutation, and left / right rotation of the values ​​in the nodes:

[0052]

[0053] The parent node of any two nodes is determined using the above formula, and this process is iterated until the height of the tree is h + h′ + H.

[0054] This completes the design of the optimized sponge's hash supertree structure. The next step is to populate the key pool with key data.

[0055] All nodes in the hash supertree are stored in the database system. Nodes at different heights are stored in different types of key pool databases to complete the key pool filling and optimization.

[0056] This invention proposes an optimized sponge hash supertree structure. Based on the Feistel optimized sponge structure, different obfuscation and diffusion processing steps are designed for different functions in the "absorption" and "diffusion" stages of the sponge to obtain a novel tree structure capable of generating keys. The output of the sponge structure is used as leaf nodes in subtrees, and different types of hash functions are used for nodes at different heights to obtain the entire tree. Finally, all nodes are stored in a database system, and nodes at different heights are stored in different types of key database systems to obtain all data in the key pool.

[0057] It should be noted that, based on the teachings of this specification, those skilled in the art can make various easy variations, such as equivalent or obvious modifications. All such variations should be within the scope of protection of this invention.

[0058] Finally, the details of the above examples of the present invention are merely illustrative of the invention. Any modifications, improvements, and substitutions to the above embodiments by those skilled in the art should be included within the scope of protection of the claims of the present invention.

Claims

1. A method for generating keys using an optimized sponge-based hash supertree structure, characterized in that, Includes the following steps: a. The sponge structure is optimized. The optimization is based on the Feistel structure. The message M is processed in two stages: "absorption" and "squeezing". The absorption stage achieves the absorption of d bits, and the squeezing stage achieves the squeezing of d' bits, thereby realizing the obfuscation and diffusion optimization of message m. b. Input the output of the optimized sponge structure as leaf nodes into the hash supertree; c. Construct a hash supertree, dividing the entire tree into three stages based on its height: h, h+h', and h+h'+H. Different hash functions are set for different heights of the tree structure to ultimately construct a complete hash supertree. Specifically: The parent node of a leaf node is obtained by hashing the leaf node using a hash function, and the process is repeated upwards layer by layer until the height of the tree is h. Starting from the height h, the parent node is calculated using a hash function, and the process is repeated upwards layer by layer until the height of the tree is h+h'. For any two child nodes, the parent node is obtained by XOR, numerical substitution, permutation, and left / right rotation, and the process is repeated until the height of the tree is h+h'+H. d. After completing the entire tree structure, nodes of different tree heights are stored in different types of key database systems, which are then applied to the key pool to ultimately realize the generation and distribution of keys in the key pool, so as to facilitate the encryption and decryption of privacy data.

Images