A method for dynamic updating of key-split shares

Abstract

The application provides a method for dynamically updating key split shares, and belongs to the technical field of data encryption. The method establishes an event partial order relation by initializing a distributed node vector clock, generates a candidate share set from a physical entropy source by a master node, and broadcasts a share pre-distribution message. Each participating node locks an old share and writes the candidate share into a temporary storage area. The master performs entropy value maintenance processing on the candidate share, injects supplementary randomness, and modulates the share distribution characteristics through an entropy value recovery equation group. When the node state matrix is full rank, an activation instruction is broadcast to realize atomic share switching. Finally, the rank loss detection algorithm of the update verification matrix is used to confirm the completion of the share update, thereby solving the technical problem of share synchronization consistency failure caused by network delay and node asynchrony in the distributed key share update process.

Description

Technical Field

[0001] This invention belongs to the field of data encryption technology, and more specifically, relates to a method for dynamically updating key splitting shares. Background Technology

[0002] In distributed key management systems, secret sharing technology enhances security by splitting the key into multiple shares and distributing them across different nodes. Traditional share update methods employ centralized timestamp synchronization mechanisms or two-phase commit protocols to coordinate share replacement operations across nodes. However, in large-scale distributed environments, due to uneven network transmission latency and differences in node processing capabilities, traditional synchronization mechanisms struggle to accurately determine the actual state order of each node. This can lead to some nodes using old shares while others have switched to new shares, creating a window of share version inconsistency. If a key reconstruction operation is triggered during this period, it will fail due to share version conflicts. In other words, existing technologies suffer from the technical problem of share synchronization consistency failure during distributed key share updates due to network latency and node asynchrony. Summary of the Invention

[0003] In view of this, the present invention provides a method for dynamic updating of key split shares, which can solve the technical problem of share synchronization consistency failure caused by network latency and node asynchrony during the distributed key share update process in the prior art.

[0004] This invention is implemented as follows: A method for dynamic updating of key-split shares includes the following steps: initializing a distributed node vector clock, assigning a unique node identifier to all nodes in the distributed system, and establishing a vector clock record table for each node; triggering a key share update request, where the master node collects raw entropy data from a physical entropy source to generate a fresh random seed, and uses the fresh random seed to generate a candidate share set; performing a share update preparation phase, where the master node broadcasts a share pre-distribution message to all participating nodes, and each participating node locks its current old share and writes candidate share data into a temporary storage area; performing share synchronization verification, where the master node constructs a node state matrix and calculates the rank change of the node state matrix to determine the synchronization degrees of freedom of the system; performing share entropy preservation processing, calculating a share entropy index for each candidate share in the candidate share set, and injecting supplementary random data to obtain a modulated share when the entropy deviation is greater than 0; performing a share activation phase, where the master node broadcasts an activation command message to all participating nodes, and each participating node synchronously deletes its old share and transfers the modulated share to the formal storage area; and performing share update verification, where the master node constructs an update verification matrix, and automatically supplements a synchronization correction vector to restore the full-rank characteristic of the matrix when a rank deficiency is detected in the update verification matrix.

[0005] The vector clock record table is used to establish a partial order relationship of events in a distributed system, and the order of events is determined by recording the logical timestamps of all nodes observed by each node.

[0006] In the step of triggering the key share update request, the master node receives the update instruction and inputs the original entropy value data into the entropy mixing function to generate a fresh random seed.

[0007] The physical entropy source is a quantum random number generator, a thermal noise generator, or a radioactive decay detector, and the raw entropy data is an unprocessed random bit stream directly collected from the physical entropy source.

[0008] The entropy mixing function is a randomness extractor based on a cryptographic hash function, employing the SHA-3 or BLAKE3 algorithm. The input includes the original entropy value data, the system timestamp, and the node identifier.

[0009] The candidate share set is a set of multiple key shares generated using a secret sharing algorithm with a fresh random seed, and the number of candidate shares in the candidate share set is equal to the number of participating nodes.

[0010] In the share update preparation phase, each participating node updates its local vector clock and returns a pre-confirmation message to the master node after receiving the share pre-distribution message.

[0011] The pre-distribution message adopts the first-stage message format of the two-stage commit protocol, which includes message type identifier, candidate share data, expected activation timestamp, and master node signature.

[0012] Locking the current old share means marking the old share as read-only to prevent any modification operations. The temporary storage area is an independent buffer area in memory, physically isolated from the formal storage area.

[0013] In the step of performing share synchronization verification, the master node collects the pre-confirmation messages from all participating nodes and then constructs the node state matrix.

[0014] Wherein, the node state matrix is 3D matrix Indicates the number of participating nodes. This indicates the number of state attributes, which includes node response time, vector clock value, and pre-acknowledgment flag.

[0015] The synchronization degree of freedom is the number of state dimensions that change independently for each node in the system. It is represented by the matrix rank. When the matrix rank is less than 80% of the number of participating nodes, synchronization dimensionality reduction is performed to redistribute the shares.

[0016] In the step of performing share entropy preservation processing, the share entropy index is compared with the standard entropy threshold through the share entropy evaluation function to obtain the entropy deviation, and the statistical distribution characteristics of the candidate shares are readjusted through the entropy recovery equation system.

[0017] The share entropy index is the Shannon entropy value of the candidate share data. It is a dimensionless quantity, and the standard entropy threshold is 7.9.

[0018] The entropy recovery equation set includes an entropy mixing equation and a distribution modulation equation. The entropy mixing equation is used to mix candidate share data with supplementary randomness data, and the distribution modulation equation has a modulation intensity factor. The range of values ​​is ∈[0.5, 1.5].

[0019] During the share activation phase, each participating node updates its local vector clock and returns an activation completion message to the master node after receiving the activation instruction message. The activation instruction message adopts the second-phase message format of the two-phase commit protocol.

[0020] The synchronous deletion is an atomic operation that is executed immediately after receiving the activation instruction message, ensuring that the old share and the modulated share do not coexist in the formal storage area at the same time.

[0021] In the step of performing share update verification, the master node collects the activation completion messages of all participating nodes and constructs an update verification matrix, and designs a matrix rank loss detection algorithm for verification.

[0022] Wherein, the updated verification matrix is 3D matrix Indicates the number of participating nodes. This indicates the number of verification attributes, which includes the activation completion flag, share integrity check value, and vector clock consistency flag.

[0023] This invention establishes a partial order relationship of distributed events by deploying a vector clock record table on each node. It quantifies the system's synchronization degrees of freedom by combining the rank analysis of the node state matrix. During the share pre-distribution phase, old shares are locked and candidate shares are written to a temporary storage area. The rank of the node state matrix is ​​calculated to determine whether each node has reached an activatable state. When the matrix rank equals the number of participating nodes, it indicates that all nodes have completed the preparatory phase of synchronization. At this point, a unified broadcast activation command is used to achieve atomic share switching, avoiding the version inconsistency problem caused by relying on global clock synchronization in traditional methods. This invention uses the matrix rank as an algebraic representation of synchronization, transforming the node state consistency problem, which is difficult to directly observe in a distributed system, into a computable linear algebraic problem. When a matrix rank deficit is detected, a synchronization correction vector is automatically added to restore the full rank characteristic, ensuring that the share activation operation is only performed when all node states are fully synchronized. This guarantees global consistency of share updates in a distributed environment with network latency and node asynchrony. In summary, this invention solves the technical problem of share synchronization consistency failure caused by network latency and node asynchrony during distributed key share updates mentioned in the background art. Attached Figure Description

[0024] Figure 1 This is a flowchart of the method of the present invention.

[0025] Figure 2 This is a statistical chart showing the distribution of candidate share entropy values ​​in Example 2. Detailed Implementation

[0026] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings.

[0027] like Figure 1 The diagram shows a flowchart of a method for dynamically updating key splitting shares provided by the present invention. This method includes the following steps:

[0028] S01. Initialize the distributed node vector clock, assign a unique node identifier to all nodes in the distributed system, and establish a vector clock record table for each node. The vector clock record table records the logical timestamps of all nodes observed by the node.

[0029] S02. Trigger a key share update request. The master node receives the update instruction. The master node collects raw entropy data from the physical entropy source, inputs the raw entropy data into the entropy mixing function to generate a fresh random seed, and uses the fresh random seed to generate a candidate share set.

[0030] S03. In the share update preparation stage, the master node broadcasts a share pre-distribution message to all participating nodes. The share pre-distribution message includes candidate share data and expected activation timestamp. After receiving the share pre-distribution message, each participating node locks its current old share, writes the candidate share data into the temporary storage area, updates its local vector clock, and returns a pre-confirmation message to the master node.

[0031] S04. Execute share synchronization verification. The master node collects the pre-confirmation messages of all participating nodes, constructs a node state matrix, and calculates the change in the rank of the node state matrix to determine the synchronization degree of freedom of the system. When the matrix rank is less than 80% of the number of participating nodes, perform synchronization dimensionality reduction processing to redistribute shares. When the matrix rank is equal to the number of participating nodes, perform share activation processing.

[0032] S05. Perform share entropy preservation processing: calculate the share entropy index for each candidate share in the candidate share set; compare the share entropy index with the standard entropy threshold through the share entropy evaluation function to obtain the entropy deviation; when the entropy deviation is greater than 0, inject supplementary random data; and remodulate the statistical distribution characteristics of the candidate shares through the entropy recovery equation set to obtain the modulated share.

[0033] S06. During the share activation phase, the master node broadcasts an activation instruction message to all participating nodes. After receiving the activation instruction message, each participating node synchronously deletes the old share, transfers the modulated share in the temporary storage area to the formal storage area, updates the local vector clock, and returns an activation completion message to the master node.

[0034] S07. Execute share update verification. The master node collects activation completion messages from all participating nodes, constructs an update verification matrix, and designs a matrix rank deficit detection algorithm. When a rank deficit is detected in the update verification matrix, a synchronization correction vector is automatically added to restore the full rank characteristic of the matrix. When the update verification matrix is ​​full rank, the share update is confirmed to be complete.

[0035] The vector clock record table is used to establish a partial order relationship of events in a distributed system. It determines the order of events by recording the logical timestamps of all nodes observed by each node. When a node sends a message, it increments its local timestamp. When a node receives a message, it merges the vector clock of the sender and increments its local timestamp, thereby solving the problem of inconsistent event order caused by network latency and clock deviation in a distributed environment.

[0036] The physical entropy source is a quantum random number generator, a thermal noise generator, or a radioactive decay detector, used to provide a source of true randomness. The original entropy data is an unprocessed random bit stream directly collected from the physical entropy source. The fresh random seed is a high-quality random number processed by an entropy mixing function, used to initialize the key share generation algorithm.

[0037] The entropy mixing function is a randomness extractor based on a cryptographic hash function. It mixes the original entropy values ​​from multiple entropy sources and extracts a uniformly distributed random output. The entropy mixing function uses the SHA-3 or BLAKE3 algorithm. The input includes the original entropy values, system timestamps, and node identifiers. The output is a fixed-length fresh random seed. The candidate share set is a set of multiple key shares generated using the fresh random seed through a secret sharing algorithm. The number of candidate shares in the candidate share set is equal to the number of participating nodes.

[0038] The pre-distribution message adopts the first-stage message format of the two-phase commit protocol, which includes message type identifier, candidate share data, expected activation timestamp, and master node signature. Locking the current old share means marking the old share as read-only and prohibiting any modification operations. The temporary storage area is an independent buffer area in memory, which is physically isolated from the formal storage area.

[0039] Wherein, the node state matrix is 3D matrix Indicates the number of participating nodes. The number of state attributes is represented by the node response time, vector clock value, and pre-acknowledgment flag. The synchronization degree of freedom is the number of state dimensions that change independently for each node in the system, which is represented by the matrix rank. The synchronization dimensionality reduction process involves removing nodes that have timed out and recalculating the minimum set of participating nodes.

[0040] The share entropy index is the Shannon entropy value of the candidate share data, and its calculation formula is as follows: ,in Represents byte value Frequency of occurrence in candidate share data, expressed in times. The maximum possible frequency is used for dimensionless processing, with the unit being times; the share entropy index is... It is a dimensionless quantity, the standard entropy threshold is 7.9, and the supplementary randomness data is random bits additionally collected from the physical entropy source.

[0041] The share entropy evaluation function is used to calculate the deviation between the share entropy index and the standard entropy threshold. The inputs include the share entropy index and the standard entropy threshold, and the output is the entropy deviation. The calculation formula for the share entropy evaluation function is as follows: ,in Indicates the standard entropy threshold. This represents the share entropy value index. This represents the entropy deviation, the entropy deviation... The entropy deviation is a dimensionless quantity. The range of values ​​is .

[0042] The entropy recovery equation set includes entropy mixing equations and distribution modulation equations.

[0043] The entropy mixing equation is used to mix candidate share data with supplementary randomness data. The inputs include candidate share data, supplementary randomness data, and mixing weight coefficients. The output is the mixed intermediate share data. The calculation formula for the entropy mixing equation is as follows: ,in This represents the intermediate share data after mixing. Represents candidate share data, This indicates supplementary random data. Indicates the mixed weighting coefficient. The maximum value of the mixed weighting coefficient is used for dimensionless processing. The maximum value of the supplementary random data is used for dimensionless processing; the mixed weighting coefficient... The range of values ​​is .

[0044] The distribution modulation equation is used to adjust the statistical distribution characteristics of the mixed intermediate share data to make it closer to a uniform distribution. The inputs include the mixed intermediate share data, the target distribution parameters, and the modulation intensity factor. The output is the modulated share. The calculation formula of the distribution modulation equation is expressed as follows: ,in Indicates the modulated portion. This represents the intermediate share data after mixing. This indicates a bitwise XOR operation. Indicates the modulation intensity factor. Represents the target distribution parameters. The maximum value of the modulation intensity factor is used for dimensionless processing. This indicates a floor operation, where the modulation intensity factor is... The range of values ​​is The target distribution parameters A numerical vector describing the characteristics of a uniform distribution.

[0045] The activation instruction message adopts the second-phase message format of the two-phase commit protocol, which includes a message type identifier, an activation timestamp, and a master node signature. The synchronous deletion is an atomic operation that is executed immediately after receiving the activation instruction message, ensuring that the old share and the modulated share do not exist in the formal storage area at the same time.

[0046] Wherein, the updated verification matrix is 3D matrix Indicates the number of participating nodes. The number of verification attributes is indicated, including activation completion flag, share integrity check value, and vector clock consistency flag. The matrix rank deficit occurs when the matrix rank is less than the number of rows, indicating that a node has not successfully completed the activation operation. The synchronization correction vector is a column vector containing compensation information for missing nodes. The full rank characteristic of the matrix is ​​restored by adding the synchronization correction vector to the matrix.

[0047] As an improvement, the present invention also provides a method implemented by a computer to form a key splitting share dynamic update system, wherein the computer is provided with a readable storage medium, the readable storage medium storing program instructions, and the program instructions executing the above method when running in the computer.

[0048] The specific implementation methods of the above steps are described in detail below.

[0049] The specific implementation of step S01 involves first assigning a globally unique node identifier to each node in the distributed system. This identifier is typically generated using a 128-bit UUID generation algorithm or a hash value based on the MAC address and timestamp, ensuring that identifier conflicts do not occur in a distributed environment. Subsequently, a vector clock record table is created in the local storage of each node. This table uses a key-value pair structure, where the key is the node identifier and the value is the logical timestamp observed by the node, initially set to 0. The design of the vector clock record table is based on an extension of Lamport's logical clock theory. By maintaining a multi-dimensional time vector, it captures causal relationships in the distributed system. When a node performs a local operation, it increments its corresponding timestamp component by 1. When a node receives a message from another node, it compares its local vector clock with the vector clock carried in the message component by component and takes the maximum value, then increments its corresponding timestamp component by 1. This mechanism effectively solves the problem of event order determination caused by network latency and node clock asynchrony in a distributed environment, providing a reliable timing basis for subsequent share update operations.

[0050] The specific implementation of step S02 is as follows: upon receiving the key share update command, the master node immediately activates the physical entropy source acquisition module. This module continuously acquires truly random data using hardware devices such as quantum random number generators or thermal noise generators. The acquisition duration is generally set to 100–500 milliseconds to ensure sufficient entropy accumulation. The acquired raw entropy data is an unprocessed random bit stream, and its statistical characteristics may contain biases or correlations. Therefore, it needs to be post-processed using an entropy mixing function. The entropy mixing function is implemented based on a cryptographic hash function. It uses the SHA-3 or BLAKE3 algorithm to concatenate the raw entropy data with the system timestamp and the master node identifier to calculate the hash value. The avalanche effect of the hash function can fully mix the input data and eliminate statistical biases, outputting a fresh random seed of fixed length. The secret sharing algorithm is initialized using this fresh random seed. Typically, the Shamir threshold scheme or the Feldman verifiable secret sharing scheme is adopted. A corresponding number of candidate shares are generated according to the number of participating nodes in the system. Each candidate share mathematically satisfies a polynomial interpolation relationship. Any combination of shares that reaches the threshold number can recover the original key, while shares that are less than the threshold number cannot obtain any information about the original key.

[0051] The specific implementation of step S03 involves the master node constructing a share pre-distribution message. This message follows the first-phase message format of a two-phase commit protocol, including a message type identifier field to distinguish different protocol phases, a candidate share data field carrying the key share generated for that node, an expected activation timestamp field specifying the time when the share officially takes effect, and a master node signature field using a digital signature algorithm to ensure message integrity and source authentication. The master node concurrently broadcasts this message to all participating nodes through the network layer. Upon receiving the message, participating nodes first verify the validity of the master node's signature. If the verification is successful, the currently used old share is marked as read-only and any modification operations are prohibited. This locking mechanism prevents the old share from being accidentally used or tampered with during the share update process. The participating nodes then allocate an independent temporary storage area in memory, which is completely isolated from the formal storage area in terms of physical address, and write the received candidate share data into the temporary storage area. Participating nodes update their local vector clock record table, increment their corresponding timestamp component by 1, and merge the master node vector clock carried in the message. Then, they construct a pre-confirmation message and return it to the master node. This message contains information such as the node identifier, the current vector clock value, and the pre-confirmation success flag.

[0052] The specific implementation of step S04 involves the master node collecting pre-acknowledgment messages from all participating nodes, extracting status attributes such as response time, vector clock value, and pre-acknowledgment flag for each node, and constructing... A dimensional node state matrix, where The number of participating nodes. The number of state attributes is used. The concept of matrix rank is used to quantify the synchronization degrees of freedom of the system. Matrix rank represents the maximum number of linearly independent row or column vectors in the matrix, reflecting the independently changing state dimension of each node in the system. The rank of the node state matrix is ​​calculated using Gaussian elimination or singular value decomposition. When the matrix rank is less than 80% of the number of participating nodes, it indicates that a large number of node states are correlated or some nodes have failed to respond normally. At this time, synchronization dimensionality reduction is performed. Specifically, nodes with timed-out responses or abnormal states are identified and removed from the participating set. The minimum set of participating nodes that meets the threshold requirement is recalculated, and candidate shares are regenerated for this set. When the matrix rank equals the number of participating nodes, it indicates that all node states are linearly independent and have successfully completed the preparatory phase, and the system is ready to continue with share activation.

[0053] The specific implementation of step S05 involves calculating the Shannon entropy value of each candidate share in the candidate share set as a share entropy index. Shannon entropy reflects the randomness and unpredictability of the data. During calculation, the frequency of each byte value in the candidate share data is statistically analyzed. The frequency of each byte value is divided by the maximum possible frequency, dimensionlessly processed, and then the weighted sum of the negative logarithms is calculated. The calculated share entropy index is compared with a preset standard entropy threshold of 7.9. The standard entropy threshold of 7.9 is close to the theoretical entropy value of 8 bits per byte for ideal random data. The relative deviation between the two is calculated using the share entropy evaluation function to obtain the entropy deviation. When the entropy deviation is greater than 0, it indicates insufficient randomness of the candidate share, requiring additional randomness data to be collected from the physical entropy source. The collection amount is generally 10% to 30% of the candidate share data length. The candidate shares are modulated using the entropy recovery equation system. First, the entropy mixing equation is executed to weight and combine the candidate share data and the supplementary random data according to the mixing weight coefficient. The mixing weight coefficient is usually set in the range of 0.3 to 0.7 to balance the original share structure and the added randomness, generating mixed intermediate share data. The distribution modulation equation is then executed, and the intermediate share data is modulated with the target distribution parameter by bitwise XOR operation. The target distribution parameter is a numerical vector describing the characteristics of a uniform distribution. The modulation intensity factor controls the intensity of the modulation, with a value range of 0.5 to 1.5. The floor operation ensures that the modulation result is an integer, and finally the modulated share with statistical distribution characteristics close to a uniform distribution is obtained.

[0054] The specific implementation of step S06 is as follows: After confirming that all participating nodes have completed the preparation phase and the share entropy value meets the requirements, the master node constructs an activation instruction message and broadcasts it to all participating nodes. This message adopts the second-phase message format of the two-phase commit protocol, including fields such as message type identifier, activation timestamp, and master node signature. Upon receiving the activation instruction message, participating nodes first verify the validity of the message and the rationality of the timestamp. After successful verification, they immediately perform an atomic synchronous deletion operation to completely remove the old shares from the formal storage area. The atomic operation ensures that the deletion process is uninterrupted and that there is no intermediate state where old and new shares coexist. Next, the modulated shares in the temporary storage area are transferred to the formal storage area. The transfer process uses memory copying or pointer redirection mechanisms to ensure data integrity and consistency. Participating nodes update their local vector clock record table, incrementing their corresponding timestamp component by 1 and merging the vector clock information from the activation instruction message. Then, they construct an activation completion message and return it to the master node. This message includes information such as node identifier, activation completion flag, share integrity check value, and current vector clock value.

[0055] The specific implementation of step S07 involves the master node collecting activation completion messages from all participating nodes, extracting verification attributes such as the activation completion flag, share integrity check value, and vector clock consistency flag for each node, and constructing... The updated verification matrix of dimension, where The number of participating nodes. To verify the number of attributes, a matrix rank deficit detection algorithm is designed. This algorithm calculates the rank of the updated verification matrix and compares it to the number of rows. A rank deficit occurs when the rank is less than the number of rows, indicating that some nodes have failed to complete the activation operation or that there is a linear correlation between the verification attributes. For rank deficit cases, a synchronization correction vector is automatically generated. This vector is a column vector containing compensation information for missing nodes. By adding this synchronization correction vector to the updated verification matrix, the number of columns is increased, restoring the full-rank property of the matrix. Under full-rank conditions, the rank of the matrix equals the number of rows, indicating that all nodes have successfully completed activation and the verification attributes are completely independent. When the updated verification matrix meets the full-rank condition, the master node confirms the successful completion of the entire key share update process. The updated share officially takes effect and can be used for subsequent key reconstruction and cryptographic operations.

[0056] It should be noted that the key technical ideas of this invention include a distributed event sequence coordination mechanism based on vector clocks and a system synchronization evaluation method based on matrix rank analysis. The vector clock mechanism establishes causal relationships between distributed nodes by maintaining multi-dimensional logical time vectors. Compared to traditional physical clock synchronization schemes, it does not rely on a global clock server, avoiding single-point failures and clock drift accumulation problems. It can accurately determine the partial order relationship of events in asynchronous network environments, ensuring the logical consistency of each node's operations during share updates. The matrix rank analysis method abstracts node states and verification attributes into matrix representations. By calculating the matrix rank value, it quantifies the system's synchronization degrees of freedom and verification integrity. Compared to the traditional node-by-node polling verification method, it can evaluate the system state from a holistic perspective, promptly detect node anomalies and state correlation problems, and achieve adaptive fault tolerance through synchronization dimensionality reduction and rank recovery algorithms. When these two technical ideas work together, the vector clock provides a reliable time-series data source for matrix rank analysis, and matrix rank analysis performs global state evaluation based on the partial order relationship established by the vector clock. The combination of the two achieves strong consistency guarantees for distributed key share updates, maintaining system security and availability even in network partitioning and node failure scenarios, significantly improving the robustness and reliability of the key management system in complex distributed environments.

[0057] It should be noted that this invention also solves the following technical problem: During the dynamic update of key shares, the repeated use of the same random source or insufficient randomness can lead to statistical correlation between newly generated shares and old shares. Attackers may infer part of the original key information by analyzing share samples after multiple updates, reducing the long-term security of the system. This invention ensures that the randomness used in each update comes from an unpredictable physical process by collecting original entropy data from the physical entropy source in step S02 and processing it with an entropy mixing function to generate fresh random seeds. In step S05, the Shannon entropy index is calculated for candidate shares. When the entropy deviation is detected to be greater than zero, additional randomness data is injected from the physical entropy source. The candidate shares and the supplementary random data are mixed with weighted coefficients by the entropy mixing equation. Then, the statistical distribution characteristics of the shares are adjusted to be close to a uniform distribution by using a bitwise XOR operation through the distribution modulation equation. This method ensures that each share has sufficient unpredictability from an information theory perspective, so that there is no exploitable statistical correlation between new and old shares. Even if an attacker obtains multiple generations of share samples, they cannot infer key information through correlation analysis, thereby maintaining the cryptographic strength of the distributed key system in long-term operation.

[0058] Specifically, the principle of this invention is as follows: The fundamental reason why the technical solution of this invention can solve the problem of share synchronization consistency failure lies in the use of a vector clock mechanism to replace the global timestamp to establish the causal relationship of events. Each node maintains a vector recording the logical time of all nodes. When a node sends a message, it increments its local timestamp. When it receives a message, it merges the sending direction and updates its local timestamp. By comparing the partial order of the vector clock, the order of events on different nodes can be accurately determined without relying on physical clock synchronization. This invention constructs a node state matrix, encoding the response time, vector clock value, pre-acknowledgment flag, and other state attributes of each node into matrix elements. The rank of the matrix is ​​used to quantify the number of independently changing state dimensions in the system. When the rank of the matrix equals the number of nodes, it means that the state vector of each node is linearly independent, that is, all nodes have independently completed the state transition and reached the synchronization point. At this time, executing share activation can ensure that all nodes switch simultaneously without version mixing. This method formalizes the distributed synchronization problem into a decisionable mathematical condition through algebraic tools, avoiding the uncertainty of the timeout mechanism in traditional methods.

[0059] The following provides a specific embodiment 1 of the present invention, and the specific implementation of each step in this embodiment 1 is described in detail below.

[0060] The specific implementation of step S01 involves first assigning a globally unique node identifier to each node in the distributed system. This identifier is typically generated using a 128-bit universally unique identifier generation algorithm or a hash value based on the media access control address and timestamp, ensuring that identifier conflicts do not occur in a distributed environment. Subsequently, a vector clock record table is created in the local storage of each node. This table uses a key-value pair structure, where the key is the node identifier and the value is the logical timestamp observed by the node, initially set to 0. The design of the vector clock record table is based on an extension of Lambert's logical clock theory, capturing causal relationships in the distributed system by maintaining a multi-dimensional time vector. When a node performs a local operation, it increments its corresponding timestamp component by 1. When a node receives a message from another node, the update formula for the node's local vector clock is as follows:

[0061] ;

[0062] In the formula, The first local vector clock of the node Each component, in units of times; The vector clock carried for receiving messages Each component, in units of times; This is the node identifier index, with a value ranging from 1 to the total number of nodes; This is the function for finding the maximum value.

[0063] After completing the vector clock merging, the node increments its corresponding timestamp component by 1. The formula for this operation is as follows:

[0064] ;

[0065] In the formula, This is the identifier index of the current node itself, with a value ranging from 1 to the total number of nodes.

[0066] This mechanism can effectively solve the problem of event order determination caused by network latency and node clock asynchrony in a distributed environment, providing a reliable timing basis for subsequent share update operations.

[0067] The specific implementation of step S02 is that the master node immediately starts the physical entropy source acquisition module after receiving the key share update instruction. This module continuously acquires truly random data through hardware devices such as quantum random number generators or thermal noise generators. The acquisition time is generally set to 100-500 milliseconds to ensure sufficient entropy accumulation. The acquired raw entropy data is an unprocessed random bit stream, and its statistical characteristics may have biases or correlations. Therefore, it needs to be post-processed using an entropy mixing function. The entropy mixing function is implemented based on a cryptographic hash function, using Secure Hash Algorithm Version 3 or Black-3 algorithm to mix the raw entropy data. With system timestamp and master node identifier After concatenation, the hash value is calculated, where The raw entropy data is collected directly from the physical entropy source, and the unit is bits. This is the system's current timestamp, in milliseconds. The hash function is a unique identifier for the master node, a dimensionless quantity. Its avalanche effect effectively mixes the input data and eliminates statistical bias, outputting a fresh random seed of fixed length. , This is a high-quality random number processed by an entropy mixing function, measured in bits, typically 256 or 512 bits in length. This fresh random seed is used to initialize the secret-sharing algorithm, usually employing the Shamir threshold scheme or the Feldman verifiable secret-sharing scheme. A corresponding number of candidate shares are generated based on the number of participating nodes in the system. Each candidate share mathematically satisfies a polynomial interpolation relationship. Any combination of shares reaching the threshold number can recover the original key, while shares below the threshold number cannot obtain any information about the original key.

[0068] The specific implementation of step S03 involves the master node constructing a share pre-distribution message. This message follows the first-phase message format of a two-phase commit protocol, including a message type identifier field to distinguish different protocol phases, a candidate share data field carrying the key share generated for that node, an expected activation timestamp field specifying the time when the share officially takes effect, and a master node signature field using a digital signature algorithm to ensure message integrity and source authentication. The master node concurrently broadcasts this message to all participating nodes through the network layer. Upon receiving the message, participating nodes first verify the validity of the master node's signature. If the verification is successful, the currently used old share is marked as read-only and any modification operations are prohibited. This locking mechanism prevents the old share from being accidentally used or tampered with during the share update process. The participating nodes then allocate an independent temporary storage area in memory, which is completely isolated from the formal storage area in terms of physical address, and write the received candidate share data into the temporary storage area. Participating nodes update their local vector clock record table, increment their corresponding timestamp component by 1, and merge the master node vector clock carried in the message. Then, they construct a pre-confirmation message and return it to the master node. This message contains information such as the node identifier, the current vector clock value, and the pre-confirmation success flag.

[0069] The specific implementation of step S04 is that the master node collects pre-acknowledgment messages from all participating nodes, extracts the response time, vector clock value, pre-acknowledgment flag, and other state attributes of each node, and constructs a node state matrix. The expression of this matrix is ​​as follows:

[0070] ;

[0071] In the formula, is the node state matrix, a dimensionless quantity; For the first The response time of each node, in milliseconds; The maximum response time of all nodes is used for dimensionless processing, with the unit being milliseconds; For the first The cumulative value of the vector clock for each node, in units of clock cycles; The maximum value of the cumulative clock values ​​of all node vectors is used for dimensionless processing, with the unit being times; For the first The pre-confirmation flag for each node, with a value of 0 or 1, is a dimensionless quantity, where 0 indicates unconfirmed and 1 indicates confirmed. The total number of participating nodes; This is the node index, with values ​​ranging from 1 to... .

[0072] The concept of matrix rank is used to quantify the synchronous degrees of freedom of a system. Matrix rank represents the maximum number of linearly independent row or column vectors in the matrix, reflecting the independently changing state dimension of each node in the system. The rank of the node state matrix is ​​calculated using Gaussian elimination or singular value decomposition algorithms. ,in Let be the rank of the node state matrix, a dimensionless quantity, when This indicates that a large number of nodes are in a state-related state or that some nodes have failed to respond normally. At this point, synchronous dimensionality reduction is performed. Specifically, this involves identifying nodes that have timed out or are in an abnormal state and removing them from the participating set. The minimum set of participating nodes that meets the threshold requirement is then recalculated, and candidate shares are regenerated for this set. This indicates that all node states are linearly independent and have successfully completed the preparatory phase, and the system is ready to continue executing share activation.

[0073] The specific implementation of step S05 involves calculating the Shannon entropy value of each candidate share in the candidate share set as a share entropy index. The calculation formula is as follows:

[0074] ;

[0075] In the formula, It is a dimensionless quantity, representing the entropy value of the share. Byte value Frequency of appearance in candidate share data, in times; The maximum frequency of occurrence among all byte values ​​is used for dimensionless processing, with the unit being times; This is a byte value index, with a value range of 1 to 256; It is a logarithmic function with base 2; This is the summation symbol.

[0076] The calculated share entropy value is compared with the preset standard entropy threshold of 7.9. The relative deviation between the two is calculated using the share entropy evaluation function to obtain the entropy deviation. The formula for this function is as follows:

[0077] ;

[0078] In the formula, This is the entropy deviation, a dimensionless quantity, with a value range from 0 to 1; The standard entropy threshold is 7.9, and it is a dimensionless quantity. It is a dimensionless quantity and is an index of entropy.

[0079] When the entropy deviation is greater than 0, it indicates that the randomness of the candidate shares is insufficient, and additional randomness data needs to be collected from the physical entropy source. ,in Additional random bit data, measured in bits, is collected from the physical entropy source. The amount collected is typically 10% to 30% of the candidate share data length. The candidate shares are modulated using entropy recovery equations. First, the entropy mixing equation is executed, and its calculation formula is as follows:

[0080] ;

[0081] In the formula, The intermediate share data after mixing is dimensionless. Candidate share data, in bits; To supplement random data, the unit is bits; This is a mixed weighting coefficient, a dimensionless quantity, with a value range of 0.3 to 0.7, and an empirical value of 0.5; The maximum value of the mixed weight coefficient is used for dimensionless processing; its value is 1, and it is a dimensionless quantity. The maximum bit value in the random data is used for dimensionless processing, and is usually 1, a dimensionless quantity.

[0082] The distributed modulation equation is then executed, and its calculation formula is as follows:

[0083] ;

[0084] In the formula, The modulated fraction is a dimensionless quantity. The intermediate share data after mixing is dimensionless. This is the bitwise XOR operator; The modulation intensity factor is a dimensionless quantity with a value ranging from 0.5 to 1.5, and an empirical value of 1.0. Let be the target distribution parameter, a dimensionless quantity, and be a numerical vector describing the characteristics of the uniform distribution. The maximum value of the modulation intensity factor is used for dimensionless processing; its value is 2, and it is a dimensionless quantity. This is the floor operator.

[0085] The specific implementation of step S06 is as follows: After confirming that all participating nodes have completed the preparation phase and the share entropy value meets the requirements, the master node constructs an activation command message and broadcasts it to all participating nodes. This message adopts the second-phase message format of the two-phase commit protocol and includes a message type identifier and an activation timestamp. Fields such as master node signature, among which The activation timestamp, in milliseconds, specifies the moment when the share is officially activated. Upon receiving the activation command message, participating nodes first verify the message's validity and the timestamp's rationality. If verification is successful, they immediately execute an atomic synchronous deletion operation, completely clearing the old share from the formal storage area. This atomic operation ensures the deletion process is uninterrupted and avoids any intermediate state where old and new shares coexist. Next, the modulated share from the temporary storage area is transferred to the formal storage area. This transfer process uses memory copying or pointer redirection mechanisms to ensure data integrity and consistency. Participating nodes update their local vector clock record table, incrementing their corresponding timestamp component by 1 and merging it with the vector clock information from the activation command message. They then construct an activation completion message and return it to the master node. This message includes the node identifier, activation completion flag, share integrity check value, and current vector clock value.

[0086] The specific implementation of step S07 is that the master node collects activation completion messages from all participating nodes, extracts the activation completion flag, share integrity check value, vector clock consistency flag, and other verification attributes of each node, and constructs an update verification matrix. The expression of this matrix is ​​as follows:

[0087] ;

[0088] In the formula, For updating the verification matrix, dimensionless quantities are used; For the first The activation completion flag for each node, which takes the value 0 or 1 and is a dimensionless quantity, where 0 indicates that activation is not complete and 1 indicates that activation is complete. For the first The share integrity check value of each node, in bits; The maximum value of the integrity check value for all nodes is used for dimensionless processing, with the unit being bits; For the first The vector clock consistency flag for each node, which takes the value 0 or 1, is a dimensionless quantity, where 0 indicates that the vector clocks are inconsistent and 1 indicates that the vector clocks are consistent. The total number of participating nodes; This is the node index, with values ​​ranging from 1 to... .

[0089] Design a matrix rank deficit detection algorithm, which calculates and updates the rank of the verification matrix. And compare it with the number of rows in the matrix, where To update the rank of the verification matrix, a dimensionless quantity, when The occurrence of rank deficit indicates that some nodes failed to complete the activation operation or that there is a linear correlation between verification attributes. For rank deficit cases, a synchronization correction vector is automatically generated. This vector is a column vector containing compensation information for missing nodes. By adding this synchronization correction vector to the updated verification matrix, the number of columns in the matrix is ​​increased, and the full-rank property of the matrix is ​​restored. When the matrix satisfies the full rank condition, it indicates that all nodes have been successfully activated and their verification attributes are completely independent. The master node confirms that the entire key share update process has been successfully completed, and the updated share has officially taken effect and can be used for subsequent key reconstruction and cryptographic operations.

[0090] It needs to be explained that the vector clock update formula By employing a maximum-value operation to ensure causal consistency among distributed nodes, this formula compares the local vector clock with the vector clock carried in the received message component by component and retains the larger value. This effectively solves the problem of event order disorder caused by network latency, providing reliable timing guarantees for the synchronous update of key shares. Node State Matrix By quantifying the synchronization degrees of freedom of the system through rank quantization, the construction of the node state matrix normalizes and organizes multi-dimensional state attributes such as response time, cumulative vector clock value, and pre-acknowledgment flag into a matrix form. Each matrix element is dimensionless by dividing by the maximum value of that column. The number of independently changing state dimensions in the system can be quantified by calculating the matrix rank. When the matrix rank decreases, abnormal nodes can be identified in a timely manner and dimensionality reduction can be performed, ensuring fault tolerance and robustness in the key share update process. The share entropy evaluation function combines Shannon entropy theory to quantify the randomness of candidate shares. The Shannon entropy calculation formula is as follows. Data uncertainty is measured by statistically analyzing the frequency distribution of byte values. Frequency normalization ensures the dimensionless nature of the entropy metric. Comparison with the standard entropy threshold of 7.9 automatically triggers the entropy recovery process, guaranteeing that the generated key share possesses high-quality randomness characteristics and enhancing cryptographic security. Entropy deviation calculation formula. The degree of entropy missing value in candidate shares is assessed using a relative deviation form. The numerator of this formula is the difference between the standard entropy value and the actual entropy value, while the denominator is the standard entropy value used for normalization, limiting the deviation value to between 0 and 1. This facilitates subsequent determination of whether additional randomness needs to be injected. The entropy recovery equation system is processed through a cascade of hybrid and modulation equations. A weighted average method is used to fuse candidate share data with supplemental randomness data, and the mixed weight coefficients are... Controlling the ratio of the original share to random data, and achieving dimensionless processing by dividing by their respective maximum values, the distribution modulation equation... The intermediate component of the mixture is nonlinearly modulated using bitwise XOR operation, with modulation intensity factor... The product of the target distribution parameter and the modulated share is normalized and rounded down, then XORed bit-by-bit with the intermediate share. This preserves the secret-sharing structure of the original share while injecting supplementary randomness to eliminate statistical bias, making the statistical distribution characteristics of the modulated share approach an ideal uniform distribution, thereby enhancing the key share's resistance to statistical analysis attacks. The rank deficiency detection mechanism for updating the verification matrix automatically identifies anomalies during share activation using linear algebraic methods and updates the verification matrix accordingly. The verification attributes, such as the activation completion flag, share integrity check value, and vector clock consistency flag, are organized into a matrix structure. When the matrix rank... Less than the number of rows This indicates the presence of linearly correlated verification attributes or nodes that have not been activated. By adding a synchronization correction vector to compensate for the missing information and restoring the full rank property of the matrix, it ensures that all participating nodes reach a consistent state when the share update is completed. This avoids the risk of key reconstruction failure due to node out-of-sync, and improves the overall reliability and security of the distributed key management system.

[0091] To better understand and implement this invention, the following is a specific application scenario of this invention, Example 2:

[0092] A technical team is responsible for maintaining a distributed financial trading system. This system employs a secret sharing mechanism to protect the core key, dividing the key into 12 shares distributed across nodes in different regions. Due to long-term operation, some nodes' key shares may experience potential statistical degradation. Therefore, the technical team decided to use the dynamic update method of this invention to synchronously update all key shares.

[0093] During system initialization, the technical team assigned unique identifiers to each of the 12 distributed nodes, coded as NODE-001 to NODE-012. Each node established a vector clock record table to track the partial order of events in the distributed environment. The initial vector clock values ​​for each node were all zero vectors, and the master node was selected as NODE-001. The system's physical entropy source was configured as a thermal noise-based quantum random number generator, capable of continuously providing a high-quality true random bitstream.

[0094] After receiving the share update command, the master node collects 2048 bits of raw entropy data from the quantum random number generator. This raw entropy data is processed using an entropy mixing function implemented with the SHA-3 algorithm. The mixing input also includes the system timestamp 1698745632 and the master node identifier NODE-001, ultimately generating a 256-bit fresh random seed. Using this fresh random seed, the master node generates 12 candidate shares, each 256 bits long, using the Shamir secret sharing algorithm.

[0095] During the share update preparation phase, the master node broadcast a share pre-distribution message to all 11 participating nodes. The message included candidate share data for each node and the expected activation timestamp 1698745732. Upon receiving the pre-distribution message, each participating node immediately locked its current old share, marked it as read-only, and simultaneously wrote the received candidate share data into a temporary storage area in memory. As shown in Table 1, each node completed the pre-confirmation operation at different times.

[0096] Table 1. Statistics on pre-confirmation response time for each node

[0097]

[0098] After the master node collects the pre-acknowledgment messages from all 11 participating nodes, it constructs a 12×3 dimensional node state matrix. The three state attributes of the matrix are node response time, vector clock value, and pre-acknowledgment flag. By calculating the rank of the node state matrix, we find that the rank is 12, which is equal to the total number of participating nodes. This indicates that the system has sufficient degrees of freedom for synchronization and meets the conditions for executing share activation processing.

[0099] During the share entropy preservation phase, the technical team calculated the Shannon entropy index for each of the 12 candidate shares. For example... Figure 2 As shown, the share entropy value index corresponding to candidate share NODE-005 is obtained after statistical analysis. The value is 7.42, which is lower than the standard entropy threshold of 7.9. The entropy deviation was calculated using the share entropy evaluation function. The value is 0.061. Since the entropy deviation is greater than zero, the master node additionally collects 512 bits of supplementary randomness data from the quantum random number generator. In the entropy recovery equation processing, the candidate share data and supplementary randomness data are first mixed using an entropy mixing equation, with mixing weight coefficients... The value was set to 0.55 to obtain the mixed intermediate share data. Subsequently, statistical distribution modulation was applied to the intermediate share data using a distribution modulation equation, with the modulation intensity factor... Set to 1.12, target distribution parameter To describe the 256-dimensional vector of an ideal uniform distribution, the modulated share was finally obtained. The modulated NODE-005 share entropy value increased to 7.88, meeting the system's randomness requirements.

[0100] During the share activation phase, the master node broadcasts an activation command message to all participating nodes at the expected timestamp of 1698745732. Upon receiving the activation command, each participating node performs an atomic synchronous deletion operation, completely erasing the old shares from the formal storage area, and then transferring the modulated shares from the temporary storage area to the formal storage area. The entire activation process is completed within 200ms, ensuring that old and new shares do not coexist in the formal storage area.

[0101] During the share update verification phase, the master node collected activation completion messages from all 12 nodes and constructed a 12×3 dimensional update verification matrix. The matrix's three verification attributes were an activation completion flag, a share integrity check value, and a vector clock consistency flag. The initial calculation showed the update verification matrix to have a rank of 12, indicating full rank and that all nodes had successfully completed the share activation operation. The technical team continuously monitored the rank changes of the update verification matrix using a matrix rank deficit detection algorithm and found no rank deficit, ultimately confirming the successful completion of the share update process.

[0102] Compared to traditional static key share management methods, this invention introduces a distributed event partial-order tracking mechanism based on vector clocks, fundamentally solving the problem of chaotic share update timing caused by network latency and node clock asynchrony in distributed environments. By constructing a node state matrix and using the matrix rank to represent the system's synchronization degrees of freedom, it achieves accurate quantitative evaluation of the synchronization state of distributed nodes, avoiding the limitations of relying on global clock synchronization in traditional methods. The share entropy preservation mechanism supplements randomness through dynamic injection and modulates the statistical distribution characteristics of shares using entropy recovery equations, ensuring that updated shares always maintain a high entropy value and preventing statistical feature degradation that may occur with long-term use. The two-phase commit protocol combined with the physical isolation design of the temporary storage area guarantees the atomicity of the share update process, completely eliminating the security risks caused by the simultaneous activation of old and new shares. The matrix rank deficit detection algorithm, combined with the automatic compensation mechanism of the synchronization correction vector, enables the system to have self-healing capabilities for node activation failures, significantly improving the robustness and reliability of the distributed key management system in complex network environments.

[0103] It should be noted that the variables involved in this invention are explained in detail in Table 2.

[0104] Table 2 Variable Explanation Table

[0105]

[0106] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any changes or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in the present invention should be included within the scope of protection of the present invention.

Claims

1. A method for dynamically updating key splitting shares, characterized in that, Includes the following steps: Initialize the distributed node vector clock, assign a unique node identifier to all nodes in the distributed system, and establish a vector clock record table for each node; trigger a key share update request, where the master node collects raw entropy data from the physical entropy source to generate a fresh random seed, and uses the fresh random seed to generate a candidate share set; perform a share update preparation phase, where the master node broadcasts a share pre-distribution message to all participating nodes, and each participating node locks its current old share and writes the candidate share data to a temporary storage area; perform share synchronization verification, where the master node constructs a node state matrix and calculates the rank change of the node state matrix to determine the synchronization degree of freedom of the system; perform share entropy preservation processing, where the share entropy index is calculated for each candidate share in the candidate share set, and when the entropy deviation is greater than 0, supplementary random data is injected to obtain the modulated share; During the share activation phase, the master node broadcasts activation command messages to all participating nodes. Each participating node synchronously deletes the old shares and transfers the modulated shares to the formal storage area. Share update verification is then performed. The master node constructs an update verification matrix. When a rank deficiency is detected in the update verification matrix, a synchronization correction vector is automatically added to restore the full rank characteristic of the matrix.

2. The method for dynamically updating key splitting shares according to claim 1, characterized in that, The vector clock record table is used to establish a partial order relationship of events in a distributed system. The order of events is determined by recording the logical timestamps of all nodes observed by each node.

3. The method for dynamically updating key splitting shares according to claim 2, characterized in that, In the step of triggering the key share update request, the master node receives the update instruction and inputs the original entropy value data into the entropy mixing function to generate a fresh random seed.

4. The method for dynamically updating key splitting shares according to claim 3, characterized in that, The physical entropy source is a quantum random number generator, a thermal noise generator, or a radioactive decay detector, and the raw entropy data is an unprocessed random bit stream directly collected from the physical entropy source.

5. The method for dynamically updating key splitting shares according to claim 4, characterized in that, The entropy mixing function is a randomness extractor based on a cryptographic hash function, using the SHA-3 or BLAKE3 algorithm. The input includes the original entropy value data, the system timestamp, and the node identifier.

6. The method for dynamically updating key splitting shares according to claim 5, characterized in that, The candidate share set is a set of multiple key shares generated using a secret sharing algorithm with a fresh random seed, and the number of candidate shares in the candidate share set is equal to the number of participating nodes.

7. The method for dynamically updating key splitting shares according to claim 6, characterized in that, During the share update preparation phase, each participating node updates its local vector clock and returns a pre-acknowledgment message to the master node after receiving the share pre-distribution message.

8. The method for dynamically updating key splitting shares according to claim 7, characterized in that, The pre-distribution message adopts the first-stage message format of the two-stage commit protocol, which includes message type identifier, candidate share data, expected activation timestamp, and master node signature.

9. The method for dynamically updating key splitting shares according to claim 8, characterized in that, Locking the current old share means marking the old share as read-only and prohibiting any modification operations. The temporary storage area is an independent buffer area in memory, which is physically isolated from the formal storage area.

10. The method for dynamically updating key splitting shares according to claim 9, characterized in that, In the step of performing share synchronization verification, the master node collects the pre-confirmation messages from all participating nodes and then constructs the node state matrix.

Images