1. Field of the Invention
The present invention relates generally to group keying systems and more particularly to a group key distribution mechanism.
2. Discussion of the Related Art
Secure group communication is gaining in importance, with both military and commercial applications in need of development. In a secure group communication, a trusted key server communicates with a group of N users over a multicast or broadcast communications channel. The trusted key server also communicates with the group of N users through N respective unicast communications channels that enable communications with individual users.
A unicast communications channel can be embodied in various forms. In one example, the unicast communications channel is implemented online protected by a shared secret. In another example, the unicast communications channel is implemented offline through the physical delivery of a floppy disk. A multicast or broadcast channel can also be embodied in various forms, such as a wireless network, the public Internet, a cable network, a satellite network, a hybrid network, or the like.
In a secure group communication, each of the N users is a member of a group that uses a group key to encode and decode group communications. The group key is known to each user and to the key server.
In the normal course, users will frequently join and leave the group. It is therefore important to ensure that only the set of current users has access to a currently valid and secure group key. Specifically, the current group key should be secure against collaborative attacks from past and future users.
Many conventional algorithms are able to use the broadcast channel to communicate information necessary to evict a user or users from the group or to add a user or users to the group. Some conventional algorithms have been adopted that reduce the bandwidth used on the broadcast channel to perform key operations by using a hierarchy of keys assigned to nodes in a tree. These keys are used to communicate update information in an efficient manner when a new group key is needed due to membership changes.
Higher nodes in the hierarchy are associated with sets of users, and are referred to as interior nodes. Each interior node is associated with a key known to one or more users that descend from that node. For example, the top most key, key A (the group key), is known by users U0-U31 that descend from it, key B is associated with users U0-U15 that descend from it, and key D is associated with users U0-U7 that descend from it.
In hierarchical tree 100, each user U0-U31 knows the keys corresponding to the path from its leaf node up to the root node A on top. For example, user U2 knows its unique key, and also knows its parent node key K, its grandparent node key H, and higher level node keys D, B, and A. Each user therefore knows one key per level of hierarchical tree 100 on the way to the root node A.
In general, tree hierarchies do not have to be symmetric or binary as illustrated in
Additionally, hierarchical trees do not have to have a uniform depth. For example, some users could be at leaf nodes on the sixth level, as in hierarchical tree 100, while other users could be at leaf nodes at the eighth, ninth, or tenth levels at other places in the tree.
If a user is evicted, all of the keys the evicted user knows need to be replaced with new keys. This process ensures that only authorized users have access to the secure group communication. For example, in hierarchical tree 100, user U0 is illustrated as being evicted. Therefore, the circled keys, namely keys A, B, D, H, and J, are compromised and need to be replaced. The reason the key uniquely known to user U0 is not circled is that no other user knows that key. Therefore, key U0 will not be used again. If a new user is later added to the group and assigned to user U0's leaf node, that new user will be assigned a new key uniquely associated with it that cannot be derived from the old user U0's unique key.
Each non-evicted user that knows a key that is compromised through an eviction must learn the value of the replacement key. One conventional method for communicating new values for compromised keys from a key server to a non-evicted user is the logical key hierarchy (LKH) method, described in section 4.2 of Wallner et al., “Multicast Security: a Taxonomy and Some Efficient Constructions,” Sep. 15, 1998, which is hereby incorporated by reference in its entirety. In the LKH method, all compromised keys are generated at the key server, i.e., the key server determines replacement values for them. These values are then communicated in an efficient way to the remaining non-evicted users.
In
As mentioned previously, the circled keys A, B, D, H, and J need to be replaced. In the LKH method, replacement key distribution begins at the bottom of the tree and progresses upward. In this framework, the first key to be replaced is key J. Key J is known to non-evicted user U1, and so its new value should be given to user U1. The key unique to user U1 is regarded as a leaf node key. Therefore, user U1 receives the new key J through a message EU1 that is encrypted with U1's leaf node key.
The next key to be replaced is key H. Users U1-U3 should be given the new value of key H. Here, key K is used to communicate the new value of key H to users U2 and U3, while the new key J is used to communicate the new value of key H to user U1. Specifically, user U1 receives the new value of key H through a message EJ that is encrypted with the new key J, while users U2 and U3 receive the new value of key H through a message EK that is encrypted with key K. Encryption under the new key J prevents evicted users from decrypting message EJ and obtaining the new value of key H.
Users U1-U7 are also given the new value of key D. Users U1-U3 receive the new key D through a message EH that is encrypted with the new key H, while users U4-U7 receive the new key D through a message EI that is encrypted with key I. Next, users U1-U15 receive the new value of key B. Users U1-U7 get key B by decrypting message ED, while users U8-U15 get key B by decrypting message EE. Finally, users U1-U15 get the new group key A by decrypting message EB, while users U16-U31 get the new group key A by decrypting message EC.
As thus described, the LKH method enables secure distribution of new interior node keys upon eviction of one or more users. Two additional key distribution methods have been proposed to reduce the number of encrypted messages that are needed to a tree update after a single user is evicted. These methods are the one-way function chain (OFC) and one-way function tree (OFT) methods. The OFC method is described in section 4.2 of Canetti et al., “Multicast Security: A Taxonomy and Some Efficient Considerations,” Proceedings of IEEE Infocom'99, March 1999, which is hereby incorporated by reference in its entirety. The OFT method is described in McGrew et al., “Key Establishment in Large Dynamic Groups Using One-Way Function Trees,”. May 20, 1998, which is hereby incorporated by reference in its entirety.
In the OFC method, the messages shown with the dotted arrows in
It should be noted that it is possible for multiple users to be evicted from the group simultaneously. This could happen, for example, if multiple users are compromised over a period of time and the key server evicts them all at the end of the period of time (e.g., end of a subscription period). This aggregates the eviction process for reasons of efficiency.
For example, suppose that users U0 and U13 are evicted simultaneously. As can be seen in
In a large tree encompassing thousands or millions of users, many compromised users could accrue during a time interval. When they are simultaneously evicted after the time interval, there may exist a large number of keys that need to be replaced, particularly toward the bottom of the tree. For example, assume a worst case scenario in which every other user (i.e., users U0, U2, U4, U6, . . . ) is evicted. In a symmetric binary tree having 32 leaf nodes) 16 separate encrypted messages would be required to inform the non-evicted users (i.e., users U1, U3, U5, U7, . . . ) of the replacement keys for the first level of interior nodes above the leaf nodes. Additional encrypted messages would also be required to replace the rest of the compromised keys at higher levels of the tree. This communication cost becomes excessive when the tree encompasses millions of users. What is needed therefore is an efficient group key distribution mechanism.
An embodiment of the invention is discussed in detail below. While specific implementations are discussed, it should be understood that this is done for illustration purposes only. A person skilled in the relevant art will recognize that other components and configurations may be used without departing from the spirit and scope of the invention.
The efficiency of group key distribution using hierarchical trees (e.g., a binary tree) can be judged based upon its ability to handle multiple-user evictions. In accordance with the present invention, the impact of multiple-user evictions is reduced through the effective truncation of the hierarchical tree. To illustrate this concept, reference is made first to a portion of hierarchical tree 100 of
In this scenario, the cost of sending encrypted update messages is high. This cost becomes excessive as the number of users increases. Significantly, the bulk of the cost is incurred in updating the interior nodes at the bottom levels of the tree. In accordance with the present invention, the cost of updating interior nodes at the bottom levels of the tree is reduced through the creation of a self-repairing group of users.
The concept of a self-repairing group of users is described with reference to tree portion 320 illustrated in
One of the properties of the self-repairing group is that each of its members can independently update the shared interior node key. Updating of the shared interior node key is not dependent on key distribution messages from the root node that update further node keys descending from the shared interior node key. The elimination of encrypted messages therefore enables the shared interior node key to be generated in a single step.
In the context of
In one embodiment, the updating process is initiated through the transmission of a update request message. This update request message can include the identities of the evicted user(s). Each non-evicted user in the self-repairing group uses this information to recalculate the shared interior node key. A detailed description of an embodiment of a update process is described below in the context of a reusable power set.
In accordance with the present invention, dotted messages EU1, EK, and EI are eliminated because users U0-U7, which form a self-repairing group, can independently update key D. This one-step update process for the entire self-repairing group obviates the need for the sequential determination of node keys at levels between node D and the users U0-U7. Interior node keys such as keys H-M are therefore unnecessary for the incremental distribution of information to determine the shared key D.
As further illustrated in
In general, the formation of self-repairing groups within a hierarchical tree effectively truncates the tree for the purpose of update messages. The common node of a self-repairing group effectively operates as a leaf node. This leaf-type node dictates that update messages need not be produced by the root node to update nodes beyond the leaf-type node. The interior common node of the self-repairing group is therefore converted into a leaf-type node, effectively truncating the tree.
The elimination of the lowest levels of the tree results in a large cost savings in the distribution of key information. As noted, in a worst-case eviction scenario where every other user is evicted, the number of encrypted messages needed to update the nodes at the first level above the user nodes is equivalent to one-half the number of users. This cost alone becomes prohibitive when the number of users becomes large.
For example, consider a balanced binary tree that supports 8192 users. This balanced binary tree would have 4096 interior nodes at the first level above the leaf nodes. In a worst-case eviction scenario, 4096 encrypted messages would be needed to update those 4096 interior nodes.
In the illustrated example of
In the illustrated example of
This same cost would be incurred in the updating of the conventional 32-user tree of
In general, the application of self-repairing groups to hierarchical trees serves to eliminate the large cost of updating the lowest levels of the tree. The number of levels of eliminated updates is dependent on the size of the self-repairing groups that are used. In the above example, 8-user self-repairing groups were used to eliminate two levels of updates. If 16-user self-repairing groups were used, then three levels of updates are eliminated. Implementation considerations relating to the size of the self-repairing groups are discussed in detail below.
It should also be noted that self-repairing groups can be applied to any type of tree. The tree is not required to be binary or balanced. Self-repairing groups generally can be used to represent any group of users that have a shared node. These groups may also exist at varying levels of the tree.
Having described a general framework for tree truncation, an embodiment of a self-repairing group mechanism is now provided. In one embodiment, the self-repairing group is based on a reusable power set (RPS). As detailed below, the RPS enables a self-repairing group to independently update a shared secret (e.g., an encryption key) when one or more users are evicted.
A RPS uses the power set of the set of users in a group as a basis for group key updates. The set of all subsets of a set is referred to as the power set of that set. To illustrate the concept of power sets, consider the case of N=3 in
In one embodiment described below, the power set minus the empty set { } is used, thereby leaving a set of 2N−1 elements. This set is referred to as the modified power set. Each set in the modified power set has a secret (or key) associated with it. In the following description, the secrets unique to the particular sets are referred to as keys. It should be noted, however, that the shared secrets need not be used to enable secure communications between particular subsets of users. The key associated with set {U1} is denoted as key KU
For the case of N=3, therefore, the {U2} element is represented by the binary number (100); the element {U1} is represented by the binary number (010); and the element {U0} is represented by the binary number (001).
For further ease of description, keys are also referred to below using their decimal representation. For example, the key associated with set {U0, U1} can be denoted in binary as K011 or in decimal as K3.
In an embodiment in which the modified power set is used, a group with N members has 2N−1 keys associated with it. For example, in
For example, as can be seen in
As noted, each user knows a subset of the keys used by the group. As illustrated in
When a user is evicted from a group, each key that the user knows can no longer be used for secure communications without creating a risk that the evicted user will gain unauthorized access. The set of keys known by the evicted user is said to be compromised. For example, if user U3 is evicted from the group then all of the keys known to user U3 are compromised, i.e., key numbers 8-15 and 24-31.
When a key is compromised, it should be replaced. One possible method of replacement is for the key server to generate a new, substitute key. The key server then communicates the generated key to all users who need to know it. As noted, this communication comes with significant bandwidth costs for new key distribution.
In accordance with the present invention, compromised keys are updated independently and separately by each entity that needs to know it, i.e., by the key server and by each non-evicted user. Each user that needs to know the compromised key, and only those users, should be able to update the compromised key on its own. Evicted users should not be able to collaboratively determine the updated keys.
Before discussing an embodiment of a process of updating a key, it will prove useful to analyze the implication of an eviction. Consider the example of
It is the eviction of user U3 that has compromised the key K15. The rest of the set that would be left over if user U3 were to be removed would be {U0, U1, U2}.
In one embodiment, each compromised key is updated by the key server and the non-evicted users. A key can be updated by using one or more keys to generate a replacement key. In order to prevent any possible collusion among evicted members to obtain the updated key, at least one of the keys used to generate a replacement key should be an uncompromised key.
A candidate to use as an uncompromised key to generate a replacement for a compromised key would be the key known to every non-evicted user in the set associated with the compromised key. As shown in
A compromised key may be updated using the key known only to all of the non-evicted users in the set associated with the compromised key. An example of this condition was illustrated in
As shown in
Of the remaining keys, keys K2, K8, and K10 aren't updated because they are not known by any non-evicted users. Here, it is useful to observe that if a compromised key is to be generated, i.e., if it corresponds to a set containing only evicted users, then the set of non-evicted users that also know the compromised key is the empty set. There is therefore no key corresponding to the empty set. Accordingly, none of the keys can be used to update the compromised key.
In a similar fashion to the single eviction case, the key used to update a compromised key is the key known only by all of the non-evicted users that also know the compromised key.
The process of updating and generating keys is illustrated in the flowchart of
If, at step 1204, key Ky is determined to exist, then key Kx is updated using Ky at step 1206. If, at step 1204, key Ky is determined not to exist, then a new key Kx is generated by the key server. As noted above, the generation of new keys occurs when the compromised key Kx is known only by the evicted user(s). For example in the double eviction scenario of
After key Kx is either updated or replaced by a newly generated key, the process then proceeds to step 1210 where it is determined whether more compromised keys need to be processed. If more compromised keys need to be processed, then the process loops back to step 1202.
The procedure of
In one embodiment, non-evicted users are sent information about the identities of the users that are evicted. Using this information, each non-evicted user then updates the compromised keys that it knows. The key server also updates all compromised keys. This results in a consistent, uncompromised updated key set.
As noted, in one embodiment, a key used to update a compromised key is the key known only by the non-evicted users that also know the compromised key. In one embodiment, the update of compromised keys is performed through a function with the following three properties: (1) knowledge of the updated key does not give knowledge of the compromised key or the updating key, (2) knowledge of the compromised key does not give knowledge of the updated key, (3) knowledge of the compromised key and the updated key does not give knowledge of the updating key. A function with these properties will deny access to evicted users and control access by valid users. A cryptographic one-way function has these features. In general, a cryptographic one-way function is a function that does not have an easily computable inverse or easily computable collisions (collisions are where two input values give the same output value). For example, if F( ) is a one-way function, we could update compromised key Kx with F(Ky).
The following example illustrates a security breach that would result from using an invertible, rather than a one-way function. Suppose, as in
Another example illustrates a security breach that would result from using F(Ky) to replace Kx. Suppose, as in
Thus, even if a one-way function is used, it will need more than one input to prevent the problem just described. In one embodiment, a one-way function with multiple inputs (e.g., two) is used. Because it is preferred to use key Ky in updating key Kx, one of the two inputs could be Ky. The other input(s) could be used to obtain uniqueness. For example ‘x,’ the numeric value of the set corresponding to the compromised key, could be used. Key Kx could therefore be updated with F(x, Ky), where F( ) again is a one-way function. While the use of ‘x’ would provide uniqueness, the updated keys may be subject to security risks due to the possible non-confidentiality of the value ‘x.’
Thus, in one embodiment, the input to the one-way function is a unique pair of keys (or other data values) that are known only to the non-evicted users that know the compromised key Kx. In this embodiment, the updated value of a compromised key Kx is based on F(Kx, Ky). This ensures that each replacement key will be unique, that only authorized users will know it, and that it will not be useable by a new user to obtain keys not authorized to that user.
As noted above, the function F need not be a one-way function. Any function having the properties of (1) knowledge of F(Kx, Ky) does not give knowledge of Kx or Ky, (2) knowledge of Kx does not give any knowledge of F(Kx, Ky), and (3) knowledge of F(Kx, Ky) and Kx does not give any knowledge of Ky, can be used.
Significantly, no collection of past, present, and future users can collaborate to find any key not known to a member of the collection. The following example shows how, after a sequence of two evictions, the two evicted users cannot collude to obtain any keys. For ease of explanation, the set of keys after the first eviction are denoted K′, and the set of keys after the second eviction are denoted K″. In this example, the group includes four users U0, U1, U2, and U3. User U3 is evicted first, followed by the eviction of user U2. The initial state of the system is illustrated in Table 1.
As illustrated, each user U0, U1, U2, and U3 maintains those keys that are identified by a ‘1’ in that user's respective column. For example, user U3 maintains copies of key numbers 8-15.
The first eviction that occurs is the eviction of user U3. The keys 8-15 belonging to user U3 are marked as compromised in Table 2.
In response to the eviction of user U3, the key server notifies the non-evicted users U0, U1, and U2 that user U3 has been evicted. Then, the key server updates compromised keys 9-15, and generates new key 8.
Upon notification of the eviction of user U3, each non-evicted user also updates the compromised keys that it knows. Specifically, user U2 updates keys 12-15, user U1 updates keys 10, 11, 14, and 15, and user U0 updates keys 9, 11, 13, and 15. Table 3 illustrates the replacement values for each of the compromised keys. The compromised keys are highlighted with an asterisk.
As illustrated, keys 1-7 are not compromised and are therefore left unchanged. Key 8 is compromised and is generated by the key server. Keys 9-15 are compromised and are updated. The new values for the updated keys are based on F(Kx, Ky), where F( ) is a one-way function. As noted above, Kx is the compromised key, while Ky is the key known only to the non-evicted users that also know the compromised key.
At this point, a new user is added to the group by the key server distributing the updated K′ keys to the new user. The old evicted user U3 cannot masquerade as a member of the group because the evicted user U3 has no keys in common with any group member.
Now, suppose that user U2 is evicted. The keys belonging to user U2 are marked as compromised in Table 4.
As shown in Table 4, keys 4-7 and 12-15 are compromised by the eviction of user U2. Table 5 shows the subsequent key update.
In particular, Table 5 shows the value of each key after the second update, made in response to the second eviction, i.e., the eviction of user U2. The asterisk identifies the keys compromised by the second eviction. As illustrated, key 4 is generated while keys 5-7 and 12-15 are updated.
In a similar manner to the first eviction of user U3, compromised keys 5-7 and 12-15 are updated separately by the key server and by each non-evicted user that knows the particular compromised key.
The right hand column in Table 5 shows the value of the updated keys K″ first in terms of the previously updated keys K′ after the first eviction, and then in terms of the original keys. For example, consider the example of key 12, where K″1100=F(K′1100, K′1000). In other words, key 12 (after the second eviction) is based on key 12 after the first eviction as well as key 8 after the first eviction. Similarly, key 12 after the first eviction is based on original key 12 as well as the original key 4 (i.e., K′1100=F(K1100, K0100), see Table 4). Key 8 after the first eviction is the generated key New_Key1 (see Table 4). The value of K″1100 can then be represented in terms of the original keys by substituting in the appropriate values for the K′ keys, yielding K″1100=F(K′1100, K′1000)=F(F(K1100, K0100), New_Key1).
Suppose now, that the evicted users U3 and U2 decide to get together and share all of the keys they know. Despite their collusion, users U3 and U2 cannot infer any currently active key. The following illustration in Table 6 describes, for each currently active key, why that key cannot be derived or inferred by the evicted users, even if they collude.
Table 6 is noteworthy because it illustrates the evolution of the key set over time. After an eviction, the key set remains constant until another eviction occurs. It should be noted that, in one embodiment, the key set is modified periodically to protect against time-consuming attempts to derive the keys.
In another embodiment, artificial evictions are performed just prior to an addition of a user. This artificial eviction prevents the new user from decoding any communications sent during the period from the previous eviction and the current addition. In other words, the artificial eviction ensures that the new user will get a set of keys that are valid only from the time of the user's addition.
As thus described, the RPS group provides a mechanism that enables the key server and the group users to update the keys independently. Encrypted key distribution messages can therefore be eliminated in the portion of the hierarchical tree that the RPS group replaces. As described above, self-repairing groups can be applied to any type of key distribution method (e.g., LKH, OFT, and OFC).
To illustrate the particular application of RPS groups to a hierarchical tree, consider the example hierarchical tree illustrated in
As would be appreciated, even if the evicted user U0 obtained update request message ED, security would not be compromised because the evicted user U0 would not be able to synchronously update new versions of the keys that he possessed. For this reason, in one embodiment, the update request message can be sent in an unencrypted form.
As described above, one of the compromised keys to be updated is the key K11111. Key K11111 is the key that is known by all of the users U0-U7 in the RPS group. As such, in one embodiment, key K11111 can be used as the common leaf-type node key D (see
Upon eviction of user U0, key K11111 is independently updated by both the key server and non-evicted users U0-U7 through the calculation of K′11111=F(K11111, K11110). The updated key K′11111 then represents the new common leaf-type node key D. This new key can then be used to acquire the new keys for interior nodes B and A in accordance with the particular key distribution method (e.g., LKH, OFT, and OFC). As noted above, when a new user is added into the vacant slot formerly occupied by user U0, an additional eviction of user U0 occurs just prior to the addition of the new user. This ensures that the new user does not have access to prior communications that occurred after the first eviction of user U0.
In an alternative embodiment, the RPS group is based on a power set that does not include the element {U0, U1, U2, . . . , UN}. Thus, the power set would have a set of 2N−2 elements. The initial secret (or key) that is shared by the RPS group members is then provided by the key server. When a user is evicted, then the new RPS group key is a blinded key. Specifically, the key known by all of the non-evicted users is blinded using a one-way function.
For example, if user U1 is evicted, then the key known by all of the non-evicted users is the key K11101. This key is then blinded using a one-way function G. The blinded key is then used as the start of the key distribution process in replacing the compromised keys in the interior nodes.
If users U2 and U3 are subsequently evicted, then the key known by all of the non-evicted users is the key K′10011. This key is then blinded using a one-way function to yield G(K′10011)=G(F(K10011, K10001). The new blinded key is then used as the start of the key distribution process in once again replacing the compromised keys in the interior nodes.
As described, the RPS group enables the RPS group members and the key server to determine a new RPS group secret independently. This process obviates the need for key distribution messages that would have been used to update the portion of the hierarchical tree that the RPS group structure replaces. Bandwidth is thereby conserved.
An illustration of the impact of self-repairing groups on key distribution is provided in
While the invention has been described in detail and with reference to specific embodiments thereof, it will be apparent to one skilled in the art that various changes and modifications can be made therein without departing from the spirit and scope thereof. In particular, it should be noted that while the above description was stated in the context of encryption keys, the principles of the present invention can be applied to any application environment that uses shared secrets. Thus, it is intended that the present invention cover the modifications and variations of this invention provided they come within thy scope of the appended claims and their equivalents.
The invention was made with Government support under Contract MDA904-00-C-3236. The Government has certain rights in this invention.
Number | Name | Date | Kind |
---|---|---|---|
5592552 | Fiat | Jan 1997 | A |
5630184 | Roper et al. | May 1997 | A |
5748736 | Mittra | May 1998 | A |
6049878 | Caronni et al. | Apr 2000 | A |
6151395 | Harkins | Nov 2000 | A |
6178244 | Takeda et al. | Jan 2001 | B1 |
6226743 | Naor et al. | May 2001 | B1 |
6240188 | Dondeti et al. | May 2001 | B1 |
6275859 | Wesley et al. | Aug 2001 | B1 |
6295361 | Kadansky et al. | Sep 2001 | B1 |
6330671 | Aziz | Dec 2001 | B1 |
6397329 | Aiello et al. | May 2002 | B1 |
6483921 | Harkins | Nov 2002 | B1 |
6584566 | Hardjono | Jun 2003 | B1 |
6606706 | Li | Aug 2003 | B1 |
6901510 | Srivastava | May 2005 | B1 |
6941457 | Gundavelli et al. | Sep 2005 | B1 |
7043024 | Dinsmore et al. | May 2006 | B1 |
20020147906 | Lotspiech et al. | Oct 2002 | A1 |