A group key agreement method based on quantum key distribution and multi-tree structure

Abstract

The application belongs to the technical field of secret communication, and discloses a group key negotiation method based on quantum key distribution and multi-ary tree structure, which is suitable for safe and efficient group communication. The method constructs group communication nodes into a multi-ary tree structure, establishes a safe QKD key between the sub-nodes and the parent nodes by using QKD technology, generates an intermediate key through key operation between the intermediate nodes and the sub-nodes, and then uses the quantum key to encrypt and upload to the parent node. Finally, the root node decrypts to generate a group key, which is transmitted to all nodes layer by layer through a secure channel. By optimizing the branching factor of the multi-ary tree, the calculation and communication overhead of the center node is significantly reduced, and the demand of different group sizes is adapted. In addition, a branching factor optimization calculation model is provided to minimize the key negotiation time and improve the performance. For the scene of new members joining and old members leaving, key update and synchronization mechanisms are provided respectively to ensure the security and consistency of the group key.

Description

Technical Field

[0001] This invention relates to the field of secure communication technology, and in particular to a group key negotiation method based on quantum key distribution and multi-branch tree structure. Background Technology

[0002] In modern communication networks, group communication is a common communication mode, widely used in scenarios such as multi-user collaboration, data sharing, and distributed computing. To ensure the security of group communication, group key agreement technology is crucial, ensuring that the communication content between group members is not eavesdropped on or tampered with from outside. The core of group key agreement lies in generating a shared encryption key for all group members and ensuring that this key is only available to legitimate members within the group. However, as group size increases and security requirements rise, traditional key agreement technologies face performance bottlenecks and security threats.

[0003] Traditional group key negotiation techniques face the problem of decreased communication and computational efficiency as the group size expands. For example, while centralized key distribution methods are simple and easy to implement, the computational and communication burden on the central node increases exponentially with the number of group members, leading to performance bottlenecks. Furthermore, the complexity of key updates increases significantly when group members change dynamically (e.g., members join or leave), further reducing the overall system efficiency. Therefore, designing a secure and efficient group key negotiation method in large-scale distributed communication environments is a pressing challenge.

[0004] Quantum key distribution (QKD) is based on the principles of quantum mechanics and distributes keys through the quantum state encoding of photons. Due to the non-cloning and indivisible nature of quantum measurements, any eavesdropping will be detected, theoretically providing an unconditionally secure key distribution mechanism. Therefore, QKD technology is considered one of the important solutions to mitigate the threats of quantum computing. However, current applications of QKD are mainly concentrated in point-to-point communication, and its application in multi-node group communication still faces many technical challenges. For example, since QKD requires physical quantum channels, directly distributing keys to all nodes would waste communication resources and increase the deployment and operating costs of the system. Summary of the Invention

[0005] To address the aforementioned shortcomings of existing technologies, this invention proposes a group key negotiation method based on quantum key distribution and a multi-branch tree structure.

[0006] The technical solution of this invention is implemented as follows:

[0007] A group key negotiation method based on quantum key distribution and multi-branch tree structure includes the following steps:

[0008] 1) Construct all communication nodes in the group into a multi-way tree structure including a root node, intermediate nodes, and leaf nodes;

[0009] 2) Assign a corresponding QKD key to each pair of parent and child nodes in the multi-way tree structure;

[0010] 3) Intermediate key generation and uploading:

[0011] 31) An intermediate node whose child nodes contain only leaf nodes generates an intermediate key by using all the QKD keys between it and its child nodes;

[0012] 32) An intermediate node whose child nodes contain only leaf nodes encrypts the intermediate key using the QKD key between itself and its parent node, and then uploads the encrypted result to its parent node.

[0013] 33) The intermediate node whose child node contains non-leaf nodes acts as the parent node to decrypt the intermediate key uploaded by all its child nodes, and uses the intermediate keys corresponding to all its child nodes and the QKD key to generate a new intermediate key through calculation.

[0014] 4) The root node, as the parent node, decrypts all received intermediate keys and performs calculations on the intermediate keys and their QKD keys with the corresponding child nodes to generate the final group key;

[0015] 5) The root node sends the group key down layer by layer until all intermediate nodes and leaf nodes have obtained the group key.

[0016] Preferably, in step 5), the root node uses the QKD key between itself and each of its child nodes to encrypt the result of the operation between the group key and the QKD key, and sends each encryption result to the corresponding child node. Each child node that receives the encryption result decrypts it using the corresponding QKD key and calculates the group key. Then, it uses the QKD key between itself and each of its child nodes to encrypt the result of the operation between the group key and the QKD key again, and sends each encryption result to the corresponding child node. This process continues to send the group key down layer by layer until all leaf nodes have obtained the group key.

[0017] Preferably, the operation is an XOR operation.

[0018] Preferably, it also includes step 6):

[0019] New Node Joining: When a new node joins, the root node and the new node exchange QKD keys through quantum key distribution, and use the QKD keys and the old group key to generate a new group key; the root node securely distributes the new group key to the existing nodes and the new node, so that all nodes update their keys synchronously.

[0020] Preferably, it also includes step 7):

[0021] Old node leaving: When an old node leaves, the root node generates a random number and uses the random number and the current group key to generate a new group key. The random number is encrypted and distributed to all nodes through a layer-by-layer transmission method, so that the remaining nodes update the group key.

[0022] Preferably, the process of adding a new node includes:

[0023] 61) Key exchange: The root node and the new node exchange keys via QKD;

[0024] 62) Generate a new group key: The root node performs an XOR operation between the newly exchanged QKD key and the current group key to generate a new group key;

[0025] 63) Key distribution:

[0026] The root node encrypts the new group key using the current group key and broadcasts it to existing nodes;

[0027] The root node encrypts the current group key with the newly exchanged QKD key and sends it to the new node. The new node decrypts the key to obtain the current group key and calculates and generates a new group key by combining it with the newly exchanged QKD key.

[0028] 64) Group key synchronization: Existing nodes use the old group key to decrypt received messages, and all nodes update to the new group key to complete the overall synchronization.

[0029] Preferably, the node leaving process is as follows:

[0030] 71) Generate random number: The root node generates a random number and XORs it with the current group key to generate a new group key;

[0031] 72) Random number encryption and distribution: The root node uses the QKD key exchanged with its direct child nodes to encrypt the result of the XOR operation between the random number and the QKD key, and then distributes the encrypted result to each child node;

[0032] 73) Layer-by-layer transmission: After the child node decrypts and obtains the random number, it XORs the random number with the current group key to calculate the new group key, and uses the QKD key exchanged with the direct child node to encrypt the XOR result of the random number and the QKD key, and then transmits the encrypted result down;

[0033] 74) Group key update: Through layer-by-layer transmission, all nodes receive the encryption result and complete the decryption and calculation of the new group key, thus updating the group key for the entire group.

[0034] Preferably, the multi-way tree construction process in step 1) is as follows:

[0035] 11) In the network Each node is denoted as ,by It is the root node;

[0036] 12) From Select from the nodes other than Communication nodes As The child nodes, where Let be the branching factor of the multi-way tree; if excluding Insufficient nodes If there are 1, then all the remaining nodes will be treated as 2. child nodes;

[0037] 13) Regarding this For each of the nodes, continue selecting from the remaining nodes. Each node is designated as its child node; if there are insufficient remaining nodes... If there is one, then all remaining nodes will be considered as children of that node.

[0038] Multi-branch trees are divided into The structure of each layer is shown below. In each layer, the node to the right of the arrow is the node contained in that layer, and the node to the left of the arrow is the parent node of the node corresponding to the node to the right of the arrow.

[0039] Level 1:

[0040] (Root node)

[0041] The mth layer ( ):

[0042] ,

[0043]

[0044] …

[0045] ,

[0046] ,

[0047] nth level:

[0048] ,

[0049] ...

[0051] ,

[0052] .

[0053] Preferably, the bifurcation factor The calculation process is as follows:

[0054] Solve for the parameters using the following equations. :

[0055] ,

[0056] in:

[0057] The average time required for a parent node to process information for a single child node;

[0058] The average time required for a parent node to process information for a single child node, including:

[0059] The time required to generate a new intermediate key by performing an XOR operation on the key obtained from QKD communication with the child node or the received intermediate key;

[0060] The time spent communicating with the parent node using QKD;

[0061] The time required to send the encrypted intermediate key to its parent node;

[0062] The time it takes to decrypt the information received from its parent node and calculate the group key;

[0063] The time when the group key is processed, encrypted, and sent to its child nodes;

[0064] The average concurrency of processing information for a single child node for a parent node;

[0065] Solving Then round it down; whether it's rounded up or down depends on which value makes it rounded down. Smaller;

[0066] Derive the bifurcation factor The calculation formula is:

[0067] .

[0068] Compared with the prior art, the present invention has the following beneficial effects:

[0069] This invention presents a group key negotiation method based on quantum key distribution (QKD) and a multi-branch tree structure, suitable for secure and efficient group communication. The method constructs group communication nodes into a multi-branch tree structure, uses QKD technology to establish secure QKD keys between child and parent nodes, generates an intermediate key by XORing the child node keys with the intermediate node, and then encrypts it using quantum key distribution before uploading it to the parent node. Finally, the root node decrypts the key to generate the group key, which is then transmitted layer by layer to all nodes through a secure channel. By optimizing the branching factor of the multi-branch tree, the computational and communication overhead of the central node is significantly reduced, adapting to the needs of groups of different sizes. Furthermore, a branching factor optimization calculation model is proposed to minimize key negotiation time and improve performance. For scenarios of new members joining and old members leaving, key update and synchronization mechanisms are provided respectively to ensure the security and consistency of the group key. Attached Figure Description

[0070] Figure 1 This is a flowchart of the group key negotiation method based on quantum key distribution and multi-branch tree structure of the present invention;

[0071] Figure 2 This is a schematic diagram illustrating the bottom-up generation of group keys according to the present invention. For nodes With nodes QKD keys exchanged between them (for the final group key).

[0072] Figure 3 This is a schematic diagram of the top-down transmission of the group key according to the present invention. For nodes With nodes QKD keys exchanged between them (for the final group key).

[0073] Figure 4 for Compared to The curve (where point A is) The point that reaches the minimum value, As an auxiliary variable, (Minimum duration of key exchange in this group when auxiliary variables change). Detailed Implementation

[0074] The present invention will now be clearly and completely described with reference to the accompanying drawings in the embodiments of the present invention.

[0075] like Figure 1 As shown, the specific process of the group key negotiation method based on quantum key distribution and multi-branch tree structure in this invention is as follows:

[0076] 1) Multi-way tree construction: Construct all communication nodes in the group into a multi-way tree structure including a root node, intermediate nodes, and leaf nodes;

[0077] 2) Quantum key distribution: Assigning a corresponding QKD key to each pair of parent and child nodes in a multi-way tree structure;

[0078] 3) Intermediate key generation and uploading:

[0079] 31) An intermediate node whose child nodes contain only leaf nodes generates an intermediate key by XORing all the QKD keys between it and its child nodes;

[0080] 32) An intermediate node whose child nodes contain only leaf nodes encrypts the intermediate key using the QKD key between itself and its parent node, and then uploads the encrypted result to its parent node.

[0081] 33) The intermediate node whose child node contains non-leaf nodes acts as the parent node to decrypt the intermediate key uploaded by all its child nodes, and generates a new intermediate key by XOR operation using the intermediate keys corresponding to all its child nodes and the QKD key.

[0082] 4) Group key generation: The root node, as the parent node, decrypts all received intermediate keys and performs an XOR operation on the intermediate keys and their corresponding QKD keys with the child nodes to generate the final group key;

[0083] 5) Group Key Distribution: The root node uses the QKD key between itself and each of its child nodes to encrypt the XOR result of the group key and the QKD key, and sends each encrypted result to the corresponding child node. Each child node that receives the encrypted result decrypts it using the corresponding QKD key and calculates the group key. Then, it uses the QKD key between itself and each of its child nodes to encrypt the XOR result of the group key and the QKD key again, and sends each encrypted result to the corresponding child node. This process continues to send the group key down layer by layer until all leaf nodes have obtained the group key.

[0084] 6) New Node Joining: When a new node joins, the root node and the new node exchange QKD keys through quantum key distribution, and generate a new group key using the QKD key and the old group key; the root node securely distributes the new group key to the existing nodes and the new node, so that all nodes update their keys synchronously.

[0085] 7) Old node leaves: When an old node leaves, the root node generates a random number and uses the random number and the current group key to generate a new group key. The random number is encrypted and distributed to all nodes through a layer-by-layer transmission method, so that the remaining nodes update the group key.

[0086] Consider a communication group consisting of multiple nodes. Construct all communication nodes in the group into a multi-way tree structure. Each node can be a leaf node, an intermediate node, or a root node. Leaf nodes are located at the bottom level of the tree, have no children, and are only directly connected to their parent node. Intermediate nodes are connected to at least one child node and one parent node. The root node is located at the top level of the tree, has only children, and has no parent node.

[0087] The group key negotiation process begins at the leaf nodes, which first securely exchange QKD keys with their direct parent nodes. Each parent node collects the QKD keys from all its child nodes, then processes these keys using an XOR operation to generate a new intermediate key. The parent node then encrypts this intermediate key using the QKD key it shared with its parent node at the next higher level, and passes the encryption result up to its parent node. This process continues until the root node.

[0088] At the root node, after receiving the encryption keys from each child node, it decrypts them and generates a group key using an XOR operation. Once the group key is generated, the root node encrypts it using the key obtained through QKD exchange and then transmits the encrypted key back to each child node. Each child node, upon receiving the encrypted group key from its parent node, decrypts it to obtain the group key and continues this process securely passing the key down to the next lower-level node until all nodes have obtained the group key.

[0089] It is assumed that all QKD processes reliably provide secure keys in an information-theoretic sense, and that communication between nodes relies on these secure keys to ensure the confidentiality and integrity of data. Furthermore, it is assumed that no node in the network can be controlled by an insider attacker, meaning that all nodes are trustworthy.

[0090] Based on the above model settings, a secure group key negotiation system is constructed, which can leverage the advantages of quantum key distribution to enhance the security of traditional key negotiation protocols and is suitable for network environments requiring highly secure communication.

[0091] like Figure 2 As shown, the specific steps for key negotiation are as follows:

[0092] Key generation process:

[0093] 1) Key exchange from leaf node to parent node: Each leaf node first securely exchanges QKD keys with its direct parent node using quantum key distribution technology. .

[0094] 2) Generation of the intermediate key: After receiving the QKD key or encrypted intermediate key from all child nodes, the intermediate node performs an XOR operation on these keys to generate a new intermediate key. For example, if an intermediate node has three child nodes, it will receive three keys. If you also receive the intermediate key Then the intermediate key of the parent node is .

[0095] 3) Key encryption and transmission: Intermediate nodes use the QKD key exchanged between themselves and their parent nodes. For the intermediate key Encryption is performed, and the encrypted result is passed up to its parent node. This step ensures the security of key transmission between nodes.

[0096] 4) Group Key Generation at the Root Node: The root node collects the encryption keys from all its direct child nodes, decrypts them, and generates the final group key by XORing them with the QKD key. For example, the root node receives QKD keys from two child nodes. , and intermediate key The group key is .

[0097] like Figure 3 As shown, the key distribution process is as follows:

[0098] Key distribution from root node to child nodes: After generating the group key, the root node uses the QKD key exchanged with the direct child nodes to encrypt the XOR result of the group key and the QKD key, and sends the encrypted result to each child node.

[0099] Layer-by-layer key distribution: Each child node that receives the encryption result decrypts it using the corresponding QKD key to obtain the group key. Then, the node uses the QKD key shared with its child nodes to encrypt the XOR result of the group key and the QKD key, and passes the encrypted result to the next layer of nodes.

[0100] All nodes obtain the group key: In this way, the encrypted group key is passed down layer by layer until all nodes have securely received the group key.

[0101] New member joining process

[0102] Here are the detailed steps for a new node to join the group:

[0103] Key exchange: The root node and the new node exchange new QKD keys through QKD to ensure the security of the exchange process.

[0104] Generate a new group key: The root node performs an XOR operation between the newly exchanged QKD key and the original group key to generate a new group key.

[0105] Key Broadcast: The root node encrypts the newly generated group key using the original group key and broadcasts it to all existing group members. This step ensures that only existing group members can correctly decrypt and obtain the new group key. Simultaneously, the root node also needs to encrypt the original group key using the newly exchanged QKD key and send it to the new node. Upon receiving the new node, it decrypts the original group key using the newly exchanged QKD key, and then XORs it with the original QKD key to generate the new group key.

[0106] Synchronization of the new group key: After all members of the old group receive the encrypted new group key, they decrypt it with the original group key and update their own group key to ensure that the keys of the entire group are synchronized.

[0107] The process of old members leaving

[0108] When a node leaves the group, the group key must be updated to ensure secure communication for the remaining members. The following are the steps for updating the group key after a node leaves:

[0109] The root node generates a random number: The root node generates a random number, and then performs an XOR operation with the original group key to generate an updated group key.

[0110] Random number distribution from root node to child nodes: The root node encrypts the random number by XORing it with the QKD key exchanged with its direct child nodes, and sends the encrypted result to each child node.

[0111] Layer-by-layer random number distribution: Each child node that receives the encrypted result decrypts it using the corresponding QKD key, obtains a random number, and XORs the random number with the original group key to obtain a new group key. Then, the node uses the QKD key shared with its child nodes to encrypt the XOR result of the random number and the new QKD key, and passes the encrypted result to the next layer of nodes.

[0112] All nodes update the group key: In this way, the encrypted random number is passed down layer by layer until all nodes have securely received the random number and combined it to form a new group key.

[0113] The following description is by The specific structure of a multi-way tree composed of communication nodes. Each node is denoted as and will As the root node, it receives intermediate keys sent from other nodes and generates a complete group key. This is for distribution purposes. The computational pressure, in addition to Select from the remaining nodes. Network nodes As its child node, it receives the intermediate keys sent by the remaining nodes and generates further intermediate keys. Just follow its child nodes Interactive interaction is sufficient; if except Insufficient nodes If there are 1, then all the remaining nodes will be treated as 2. child nodes; The value of will be calculated below. For this Each of the nodes can then be selected from the remaining nodes. Each node is designated as its child node; if there are insufficient remaining nodes... If a node has a child node, then all remaining nodes become its children. This process continues until a multi-way tree is formed. Multi-way trees are divided into... The structure of each layer is shown below. In each layer, the node to the right of the arrow is the node contained in that layer, and the node to the left of the arrow is the parent node of the node corresponding to the node to the right of the arrow.

[0114] Level 1:

[0115] (Root node)

[0116] The mth layer ( ):

[0117] ,

[0118]

[0119] …

[0120] ,

[0121] ,

[0122] nth level:

[0123] ,

[0124] ...

[0126] ,

[0127] .

[0128] To maximize the efficiency of key negotiation, it is necessary to calculate the maximum number of child nodes that each node can have, i.e., the fork factor. In a multi-way tree, nodes at each level can perform calculations simultaneously. The total time spent by each node performing encryption / decryption calculations and transmitting data is approximately... ,in The average time required for a parent node to process information for a single child node. The average concurrency of processing information for a single child node for a parent node; This represents the average processing time of the parent node for the overall information, including the time required to XOR the key obtained from QKD communication with the child node or the received intermediate key to generate a new intermediate key, the time for QKD communication with the parent node, the time required to send the encrypted intermediate key to its parent node, the time required to decrypt the information received from its parent node and calculate the session key, and the time required to process, encrypt, and send this session key to its child nodes. Furthermore, the multi-way tree has a total of... Layer. Therefore, the total time for key negotiation is

[0129] ,,

[0130] In order to calculate Let the minimum value be... ,but

[0131] ,

[0132] This function is a piecewise function, with a fixed... In the case of Maximum (i.e.) When the minimum value of the segment is obtained:

[0133] ,

[0134] Compared to Images such as Figure 4 As shown.

[0135] The piecewise function is relative to The minimum value is found at the leftmost edge of each segment, so we can assume first... Since the integers are consecutive, find the leftmost value; if it is not an integer, round it up. Therefore, let... ,Right now Then the above equation becomes

[0136] ,

[0137] The above formula should When the minimum value is reached

[0138] ,

[0139] To find the value that minimizes time. If we extend the range of the function above from integers to real numbers and make its derivative zero, we can obtain:

[0140] ,

[0141] Right now

[0142] ,

[0143] Solving Then it needs to be rounded down; whether to round up or down depends on which value makes it round. Smaller, then through It is possible to obtain the minimum value of time. .

[0144] Based on the specific principles of this invention, a group key negotiation method based on quantum key distribution and a multi-branch tree structure is suitable for secure and efficient group communication. The method constructs group communication nodes into a multi-branch tree structure, uses QKD technology to establish a secure QKD key between child and parent nodes, generates an intermediate key by XORing the child node keys with the intermediate node, and then encrypts it using quantum key distribution before uploading it to the parent node. Finally, the root node decrypts the key to generate the group key, which is then transmitted layer by layer to all nodes through a secure channel. By optimizing the branching factor of the multi-branch tree, the computational and communication overhead of the central node is significantly reduced, adapting to the needs of groups of different sizes. Furthermore, a branching factor optimization calculation model is proposed to minimize key negotiation time and improve performance. For scenarios of new members joining and old members leaving, key update and synchronization mechanisms are provided to ensure the security and consistency of the group key.

Claims

1. A group key agreement method based on quantum key distribution and a multi-ary tree structure, characterized by, The method comprises the following steps: 1) constructing all the communication nodes in the group into a multi-way tree structure comprising root nodes, intermediate nodes and leaf nodes; 2) assigning a corresponding QKD key to each pair of parent-child nodes in the multi-way tree structure; 3) intermediate key generation and uploading: 31) the intermediate nodes with only leaf nodes as child nodes generate an intermediate key by operation using all the QKD keys between them and their child nodes; 32) the intermediate nodes with only leaf nodes as child nodes encrypt the intermediate key using the QKD key between them and their parent node and upload the encrypted result to their parent node; 33) the intermediate nodes with non-leaf nodes as child nodes decrypt all the intermediate keys received from their child nodes and generate a new intermediate key by operation using all the intermediate keys and the QKD keys corresponding to their child nodes, and then encrypt the new intermediate key using the QKD key between them and the parent node of the previous layer and upload the encrypted result to the parent node, which is repeated until the root node; 4) the root node generates a final group key by decrypting all the received intermediate keys and operating the intermediate keys and the QKD keys between them and the corresponding child nodes; 5) the root node sends the group key layer by layer downwards until all the intermediate nodes and leaf nodes obtain the group key.

2. The group key agreement method based on quantum key distribution and multi-ary tree structure according to claim 1, characterized in that, In step 5), the root node encrypts the operation result of the group key and the QKD key between it and each child node using the QKD key, and sends each encrypted result to the corresponding child node, each child node decrypts the encrypted result using the corresponding QKD key and calculates the group key, and then encrypts the operation result of the group key and the QKD key between it and each child node using the QKD key, and sends each encrypted result to the corresponding child node, and continues to send the group key layer by layer downwards until all the leaf nodes obtain the group key.

3. The group key agreement method based on quantum key distribution and multi-ary tree structure according to claim 1 or 2, characterized in that, The operation is an XOR operation.

4. The group key agreement method based on quantum key distribution and multi-ary tree structure according to claim 3, characterized in that, The method further comprises step 6): New node joining: when a new node joins, the root node exchanges a QKD key with the new node through quantum key distribution, and generates a new group key using the QKD key and the old group key; the root node securely distributes the new group key to the existing nodes and the new node, so that all the nodes update the key synchronously.

5. The group key agreement method based on quantum key distribution and multi-ary tree structure according to claim 3, wherein, The method further comprises step 7): Old node leaving: when an old node leaves, the root node generates a random number and generates a new group key using the random number and the current group key, and distributes the encrypted random number to all the nodes through layer-by-layer transmission, so that the remaining nodes update the group key.

6. The group key agreement method based on quantum key distribution and multi-ary tree structure according to claim 4, wherein, The joining process of the new node comprises: 61) key exchange: the root node exchanges a key with the new node through QKD; 62) generating a new group key: the root node performs an XOR operation on the newly exchanged QKD key and the current group key to generate a new group key; 63) key distribution: the root node broadcasts the new group key encrypted with the current group key to the existing nodes; The root node sends the current group key encrypted with the newly exchanged QKD key to the new node, the new node obtains the current group key by decryption, and calculates and generates a new group key in combination with the newly exchanged QKD key; 64) Group key synchronization: the existing nodes use the old group key to decrypt the received messages, all nodes update to the new group key, and the whole synchronization is completed.

7. The group key agreement method based on quantum key distribution and multi-ary tree structure according to claim 5, wherein, The node leaving process is as follows: 71) Generate random number: the root node generates a random number, and generates a new group key by XORing the random number with the current group key; 72) Random number encryption and distribution: the root node uses the QKD key exchanged with the direct child node to encrypt the XOR result of the random number and the QKD key, and then distributes the encrypted result to each child node; 73) Layer-by-layer transmission: after the child node decrypts and obtains the random number, it calculates a new group key by XORing the random number with the current group key, and then encrypts the XOR result of the random number and the QKD key exchanged with the direct child node, and then transmits the encrypted result downward; 74) Group key update: through layer-by-layer transmission, all nodes receive the encrypted result, complete decryption and calculation of the new group key, and update the group key as a whole.

8. The group key agreement method based on quantum key distribution and multi-ary tree structure according to claim 1, characterized in that, The multi-ary tree construction process in step 1) is as follows: 11) the nodes in the network are denoted as with the root node as ​​ 12) from the nodes other than the communication node as children of , where is the branching factor of the multi-way tree; if there are less than nodes other than , then all the remaining nodes are as children of ; 13) Regarding this For each of the nodes, continue selecting from the remaining nodes. Each node is its child node; If the remaining nodes are insufficient All the remaining nodes are taken as the children of the node. The multi-ary tree is divided into layers.

9. The group key agreement method based on quantum key distribution and multi-ary tree structure according to claim 8, wherein, Bifurcation factor The calculation process is as follows: Solving for the parameters by the following equations : ， Wherein: the average time required to process information for a single child node for a parent node; The average time required to process the information of a single child node for a parent node, including: The time required for XOR operation on the key obtained by QKD communication with the child node or the received intermediate key to generate a new intermediate key; The time for QKD communication with the parent node; The time required for sending the encrypted intermediate key to the parent node; The time for decrypting the information received from the parent node and calculating the group key; The time for encrypting and sending the group key to the child node after processing; The time for encrypting and sending the group key to the child node after processing; average concurrency of processing single child node information for parent nodes; Solve for rounding it, specifically up or down, depends on which value makes smaller; a bifurcation factor is derived The calculation formula is: .

Images