Partition Protocol. We assume that a network failure causes a partition of the n-member group. From the viewpoint of each remaining member, this event appears as a simulta- neous leaving of multiple members. The Partition protocol is involves multiple rounds; it runs until all members compute the new group key. In the first round, each remaining member updates its tree by deleting all partitioned members as well as their respective parent nodes and “compacting” the tree. The procedure is summarized in Table 4.
Partition Protocol. Assume that a network fault causes a partition of the -member group. From the viewpoint of each remaining member, this event appears as a concurrent leave of multiple members. The partition protocol is involves multiple rounds; it runs until all members compute the new group key. In the first round, each remaining member updates its tree by deleting all partitioned members as well as their respective parent nodes and “compacting” the tree. The procedure is as follows: All leaving nodes are sorted by depth order. Starting at the deepest level, each pair of leaving siblings is collapsed into its parent which is then marked as leaving. This node is re-inserted into the leaving nodes list. The above is repeated until all leaving nodes are processed, i.e., there are no more leaving nodes that can be collapsed. The resulting tree has a number of leaving (leaf) nodes but every such node has a remaining sibling node. Now, for each leaving node we identify a sponsor using the same criteria as described in Section 5.3. Each sponsor now computes keys and bkeys on the key-path as far up the tree as possible. Then, each sponsor broadcasts the set of new bkeys. Upon receiving a broadcast, each member checks whether the message contains new bkeys. This procedure iterates until all members obtain the group key. (Recall that a member can compute the group key if it has all the bkeys on its co-path.) 5 Hereafter, we count number of mudular exponentiations that need to be computed in serial.
Partition Protocol. To provide key independence, one of the remaining members needs to change its key share. For this reason, in the first round of the partition protocol, we require the shallowest rightmost sponsor to generate a new key share. Figure 7 shows an example where all remaining members delete all nodes of leaving members and compute keys and bkeys in the first round. In the figure on the right, any of or ( or ) cannot compute the new group key, since they lack the bkey ( ), respectively. However, broadcasts in the first round, and can thus compute the group key. Finally, every member knows all bkeys and can compute the group key. As discussed above, before computing , changes its share . <0,0> <0,0> <1,0> <1,1> <1,0> <1,1> <2,0> <2,1> M3 <2,2> <2,3> M4 <2,0> <2,1> <2,2> <2,3> M2 M3 M5 M6 Sponsor Sponsor <3,6> <3,7> <3,6> <3,7> M1 M2 M5 M6 Sponsor Sponsor
Partition Protocol. Step 1 : Every member – update key tree by removing all the leaving member node, – remove their relevant parent node, if this node have only one member node, – remove all keys and bkeys from the leaf node related to the sponsor to the root node. Each sponsor Mst – if Mst is the shallowest rightmost sponsor, generate new share, – compute all [key, bkey] pairs on the key-path until it can proceed, – broadcast updated tree T^st including only bkeys. T (BK ) Mst −−−−−−−−−−−−−→ C − X ^ s t s ∗ t
Partition Protocol. After M3, M2 computes keys and blinded keys in G1 and G2, respectively 93 CHAPTER 1 INTRODUCTION
Partition Protocol. Assume that it has a group of n members and k of them leave the group. In the first round, every remaining member updates its tree by deleting all partitioned members as well as their respective parent nodes. In other words, if all leaf nodes of a subtree leave the group, the root node of this subtree is marked as leaving (namely the whole subtree is marked as leaving) and its leaf nodes are removed from the leaving nodes list. For each leaving node it identifies a sponsor using the same criteria as described in Section 2.3.4.2. The process of partition protocol is illustrated as follows:
Partition Protocol. The partition protocol is similar to the leave protocol. The only difference is the choice of the sponsor. They usually choose the surviving leaf node directly below the lowest-numbered leaving member. If no such leaf node exists, in other words, if M1 leaves the group, they choose the lowest-numbered surviving leaf node as sponsor. An example is given in Figure 2.14. Suppose there are a group of n members when p of them leave the group. The process is illustrated as follows:
Partition Protocol. The partition operation occur many reasons that explained in section 3.3 (1). When multiple members p need to leave the group, the director is the node above the undermost removing nodes in existing key tree. Otherwise, if the leaving node is child of root and the undermost removing nodes does not exist, the director is leaf node below the undermost the removing nodes. Because director only calculates the new blinded key of intermediate nodes above director up to the root node, other intermediate nodes are not necessary to update blinded keys. It means that amount of new blinded keys calculation is least. Moreover, the director computes the new blinded keys of leaf nodes below and above the director in the same manner as leave protocol. There are three examples in partition protocol. First, the partition protocol actually presents a concurrent multiple members, p, leaving from group. As for the leave protocol, after the director deletes all leaving members from key tree, it selects new session random key, computes keys and blinded keys going up to the root, and broadcasts the key tree with blinded keys to reminder members. Finally, each member computes the new group key. Second, the group needs to split into sub-group. β[0,0] = β1β3β4β5β6 [1,0] BK[1,0] = K[1,0] β[0,0] K-1 K[1,0] = s∗K[2,0] β[1,0] K-1 s-1* [0,0] β[1,0] = β1β3β4β5 [2,0] 5 [1,1] M6 BK = K β K-1 BK[1,1] = s β[0,0] s-1 K = K [2,0] [1,0] s β [2,0] s-1 K-1 6 6 K[1,1] = s6 [3,0] 4 [2,0] 4 [3,0] β[2,0] = β1β3β4 director [2,1] M5 -1 BK[2,1] = s∗β[1,0] s-1∗ BK[3,0] = K[3,0] β[2,0] K[3,0] 5 5 K[2,1] = s∗ K = s∗s β s-1s-1* 5 1 3 [3,0] 3 1 β[3,0] = β1β3 [3,0] [3,1] M4 BK[4,1] = s β[2,0] s-1 K[4,1] = s4 M1 [4,0] [4,1] M3 BK[4,0] = s∗β[3,0] s-1* BK = s β K[4,0] = s∗ [4,1] 3 K[4,1] = s3 [3,0] 3
Partition Protocol. This operation is similar as the TBG protocol. The partition operation can occur when a network faults. The partition protocol actually presents a concurrent multiple members leaving from group. When multiple members p need to leave the group, the director is node above the undermost removing nodes in existing key tree. Otherwise, if the leaving node is child of root and the undermost removing nodes does not exist, the director is leaf node below the undermost the removing node. The same as the leave protocol, after the director deletes all leaving members from key tree, it selects new session random key, computes keys and blinded keys going up to the root and unicasts the key tree with authenticated
Partition Protocol. To provide key independence, one of the remaining members needs to change its key share. For this reason, in the first round of the partition protocol, we require the shallowest rightmost sponsor to generate a new key share. This protocol takes multiple rounds to complete. We analyze the number of rounds after p members are partitioned from a group of n members. In the first round, each remaining member updates its tree by deleting all partitioned members as well as their respective parent nodes. Now, each key tree has at most p paths with empty bkeys. The expected number of paths with empty keys is p/2. Filling up these bkeys requires at most min(log2 p, h) rounds, since 1) every sponsor in each subsequent rounds computes bkeys as far up the tree as possible, and 2) the number of rounds never exceeds the tree height. Figure 7 shows an example where all remaining members delete all nodes of leaving members and compute keys and bkeys in the first round. In the figure on the right, any of M2 or M3 (M5 or M6) cannot compute the new group key, since they lack the bkey BK(1,1⟩ (BK(1,0⟩), respectively. However, M3 broadcasts BK(1,0⟩ in the first round, and M6 can thus compute the group key. Finally, every member knows all bkeys and can compute the group key. As discussed above, before computing K(1,1⟩, M6 changes its share K(2,3⟩. <0,0> <0,0> <1,0> <1,1> <1,0> <1,1> <2,0> <2,1> M3 <2,2> <2,3> M4 <2,0> <2,1> <2,2> <2,3> M2 M3 M5 M6 Sponsor Sponsor <3,6> <3,7> <3,6> <3,7> M1 M2 M5 M6 Sponsor Sponsor
