Hyperledger Fabric-based Lightweight Group Management (H-LGM) for IoT Devices

Internet of Things (IoT) is a network that can communicate between devices without human intervention. In this network, IoT devices collect sensor data and provide them for various applications. However, data collected from the device may include sensitive information. If this information is leaked, several serious problems will occur. Therefore, access control is presented to allow only authorized users to access important data. This paper proposes a model for organizing and managing groups with the group key (GK) so that only the authorized users can share data for access control. In particular, rekeying overhead is reduced. Because the IoT devices are resource-constrained, the network lifetime may be reduced as the rekeying overhead increases. There is a problem when group communication between multiple users is not used. If multiple users can easily access all data, the leakage of sensitive information will increase. To solve this problem, only users who need to share data join in a group based on the hyperledger fabric. Our approach groups users with the same GK and protects sensitive data by using secure communication links within the group. In addition, a trusted agent for rekeying sends a new GK to users in the group. Therefore, the security of data is guaranteed, and the network lifetime is extended. We analyze the storage cost, delay, and processing time for rekeying, and we also compare them according to the number of users and the depth of the key tree. The results of the performance analysis show that the proposed hyperledger fabric-based lightweight group management (H-LGM) outperforms the existing method in terms of storage cost, delay, and processing time.

be effectively implemented using MSP 1 , an element of hyperledger fabric [12]. The proposed hyperledger fabricbased lightweight group management (H-LGM) generates a GK that manages the group through an agent previously authenticated by the MSP. Since the agent is certified by the MSP, the reliability of GK is secured and its leakage may be prevented. Whenever each user leaves or joins, the agent rekeying and sends the key to users in the group. Data is then shared between users in the group. As a result, important data may be protected from unauthorized users. Also, in order to extend the lifetime of a network composed of IoT devices, rekeying overhead must be reduced. This is because IoT devices are seriously resource-constrained [13] If the storage cost, delay, and processing time increase for rekeying in this device, the network lifetime may be reduced. The proposed lightweight rekeying reduces the key tree depth of the GK to reduce the update overhead of the GK. As a result, the lifetime of the network composed of the resource-constraint IoT device may be extended.
Under these considerations, we implement H-LGM to protect important data from unauthorized users. In addition, lightweight rekeying was studied to extend the lifetime of the network consisting of resource-constrained IoT devices. Our contributions can be summarized as follows: • We propose a lightweight rekeying to reduce the update overhead of GK and H-LGM to manage access control of important data.
• We use GK to organize and manage groups. Because if users use a secure communication link within a group while authenticating with the same GK between users, access control of important data can be performed.
• We use an agent for lightweight rekeying. Because if the agent re-generates the GK and sends it to all users in the group to reduce the rekeying overhead, storage cost, delay, and processing time can be reduced. Also, in order to secure the reliability of the agent, it is authenticated by the MSP, an element of hyperledger fabric, and registered in a private network.
• In performance evaluation, we demonstrate the effectiveness of H-LGM. Since storage cost, delay, and processing time according to rekeying are reduced compared to the existing method, the lifetime of the network composed of IoT devices may be extended.
The rest of this paper is organized as follows. Section 2 presents the related work. Section 3 introduces the hyperledger fabric-based lightweight group management (H-LGM). Section 4 analyzes various cases of the H-LGM in terms of storage cost, delay, and processing time. Section 1 https://hyperledger-fabric.readthedocs.io/en/release-2.2/msp.html 5 presents the limitations of the study. Finally, Section 6 concludes the paper.

II. RELATED WORK
Recently, Internet of Things (IoT) devices have been used in various areas [14]. Since IoT devices in diverse fields may communicate with each other, important data may be leaked to any user. Therefore, it is necessary to protect important data by forming a group between IoT devices. Under these considerations, several studies have been conducted to enhance data security. In [15], the author proposed a blockchain-based authentication and dynamic group key agreement protocol to improve some shortcomings in the existing group key agreement protocol. Authentication of each member can be performed by authenticating the left neighboring member. The literature [16] considers group sensor communication protocols to address various vulnerabilities in wireless network communication. This protocol performs basic arithmetic and logical operations for sensor node authentication and data transmission. In [17], group key management (GKM) for the management of multiple devices was studied. The proposed GROUPIT is a two-tier GKM architecture. In GROUPIT, each device is included in a predetermined group, and key management is performed within or between each group. [18] studies group key management (GKM) protocols for dynamic IoT environments. In this protocol, device groups can join or leave the network, also user groups may be created and dismantled. In [19], the author proposed master-key-encryption-based multiple group key management (MKE-MGKM) for multiple multicast groups. MKE-MGKM uses a master key and multiple slave keys. As shown in Fig. 1, key trees can be used to manage groups. In this logical key hierarchy (LKH) 2 , the user owns a key on the path from leaf node to root node when in a group [20], and if a new user joins the group or an existing user leaves, all keys on the path are updated [21]. In addition, all users in the group share the group key [22]. There are also one-way function tree (OFT) and LKH++, which manage groups through the key tree. In the OFT, each node v has a node secret x v and a node key k v . If the key tree changes, the node secret x v = f(x l ) ⊕f (x r ) and node key k v = f(x v ) from node v to root node are updated. The node secret of the updated root node is used as the group key. where l and r are left and right children of node v. F is one-way functions and ⊕ is bitwise exclusive-or [23]. In addition, in LKH++, the user has a key from leaf node to root node. If a member of the group changes, the key in the path to the root node is updated. The group is managed with the key of this root node [24], [25] Since IoT devices are resource-constrained, it is necessary to reduce storage cost, delay, and processing time according to rekeying. Therefore, this paper proposes hyperledger fabric-based lightweight group management (H-LGM). The key tree of the logical key hierarchy scheme [20].

III. PROPOSE METHOD A. SYSTEM MODEL
In this paper, we assume that, as shown in Fig issues the certificate to the MSP and the agent. Also, the (TLS) CA issues a certificate to the MSP and the agent to establish a communication link between the MSP and the agent. Finally, the MSP verifies the certificate owned by the agent, and each user in the group has a shared key expressed by P K i , ∀ i ∈ {0, 1, 2, . . . , K} Each user sends a PK to the agent when requesting to join the group. This PK is used when the agent is rekeying; therefore, multiple groups can be created and operated simultaneously. Agents in each group manage the group after completing registration and verification as described above. MSP records verified agnet in block via orderer. By confirming the records periodically, the status of the agent is monitored. In addition, the agent for each group is periodically changed. This is to stably manage the rekeying of each group 3 .
As shown in Fig. 3, the agent authenticated by the MSP manages the group. GK is generated to manage the group 3 https://en.wikipedia.org/wiki/Single_point_of_failure#cite_note-1 and then sent to all users in the group. All users with GK communicate with each other using a secure group channel. A reliable agent should be selected because the agent performs an important role in managing the group. Therefore, as shown in Fig. 4, the selected agent is verified by the fabric-CA intermediate server and MSP. In order to issue a certificate for the MSP, the MSP generates a shared key. Next, a certification request for MSP is generated, including information on organizations, organizational units, cities and regions, states, provinces, and countries within the MSP. After the created shared key and authentication request are sent to the CA, the CA issues the certificate and sends it to the MSP. This procedure is implemented in the same way for issuing certificates for other nodes. MSP and orderer already receive a certificate from fabric-CA intermediate server and are mutually authenticated. The agent requests a certificate from the fabric-CA intermediate server that can prove itself. VOLUME 4, 2016 After verifying the agent, the fabric-CA intermediate server generates a certificate for the agent and sends it to the agent. The agent then requests registration from the MSP. The MSP requests a certificate from the agent, which receives the request and sends the certificate issued by the fabric-CA intermediate server to the MSP. Upon receipt of the certificate, the MSP confirms the previous registration and integrity of the certificate. If there is no problem with the registration of the certificate, MSP requests the certificate from the fabric-CA intermediate server that issued the certificate to the agent. The fabric-CA intermediate server sends the certificate requested by the MSP, and the MSP confirms the previous registration and integrity of the certificate as before. The MSP then confirms the verification of the agent through the received certificate and notifies the orderer of the result. Registered and validated agent manages the group. The MSP records the agent in the block through the orderer. The following procedure is required for the user to receive the GK from the agent. The user sends a message to the agent that includes random numbers, session ID, and cipher suite information generated by the user. Upon receiving it, the agent transmits the random numbers and session ID information generated by the agent to the user. The agent then sends information to the user for the exchange of his certificate and key, and the agent requests certificate of the user. The user sends information to the agent for the exchange of certificate and key, and sends information about the verified certificate to the agent. The user and agent update the existing information by exchanging updated parameters in a series of processes, so that communication between the user and the agent becomes reliable. 4

B. GROUP MANAGEMENT
In this section, we introduce the proposed hyperledger fabricbased lightweight group management (H-LGM). When a user leaves or joins a group through H-LGM, a procedure in which GK is re-generated and the group is re-established is described.

1) USER LEVAE
As shown in Fig. 5, U 5 leaves the existing group. First, U 5 sends P K 5 to the agent and requests to leave the group. The agent confirms the request from U 5 , discards the P K 5 of U 5 , and then informs U 5 of the result. Next, GK is re-generated with the P K 0∼4 of U 0∼4 in the existing group and the new random string. GK is transmitted to U i , ∀ i ∈ {0, 1, 2, 3, 4}in the group. Except for U 5 which left the group, the agent re-generate GK with the P K 0∼4 of U 0∼4 and the new random string. It is expressed as follows.
The random string is 15 random numbers. It is randomly selected between English alphabets and numbers from 0 to 9. There are 62 in total and are listed in order. The random string is generated as follows. First, the randomly selected number between 0 and 1 is multiplied by 62. Then the characters in the order corresponding to the resulting value are selected, which is repeated 15 times. Since the rekeying includes a random string, it is possible to reduce the possibility that the leaked or lost GK and the re-generated GK are the same. Here, SHA-256 represents a hash function, as shown in Fig.  6, a new GK is obtained by the input values P K 0∼4 and a random string.

2) USER JOIN
As shown in Fig. 7, U 5 joins the existing group. First, U 5 sends the P K 5 to the agent and then requests a group join. The agent confirms the request from U 5 and requests P K 5 from U 5 . U 5 sends the P K 5 to the agent and waits. The agent re-generates GK with P K 0∼4 of U 0∼4 and P K 5 of U 5 in the existing group and a new random string. Then, the GK is provided to the U i , ∀ i ∈ {0, 1, 2, 3, 4, 5} in group.
The agent re-generate the GK with the P K 5 of the new U 5 , the P K 0∼4 of the existing U 0∼4 , and the new random string, and it is expressed as follows. GK = SHA − 256(P K 0 + P K 1 + P K 2 + P K 3 ) (2) As shown in Fig. 8, a new GK is obtained by inputting P K 0∼5 and random string.

IV. PERFORMANCE EVALUATION
In this section, we show the results of analyzing the proposed hyperledger fabric-based lightweight group management (H-LGM). The environment in which H-LGM is implemented is listed in Table 1. The value used in the experiment is the same as TABLE 2, and each value is actually measured in the implemented environment. The results are calculated using generalization equations from TABLEs 3 to 6, and the mean values of 50 times are shown as graphs. The generalized equation uses h ≈ log d (n) of LKH [26].
Where, u is the number of all users in the group, and d represents the depth of the key tree for rekeying, and k l is the  size of a key for rekeying, and t r is the time to make random strings. Also, t e is a time for generating GK by PKs of all users in the group and random string, t x is the time for XOR operation. t d is the time for decryption, t b represents the time at which all users in the group receive GK. From TABLE 3 to TABLE 6, the client represents the user. The server for H-LGM is an agent, and the server for LKH is a key distribution center (KDC). Also, the server for OFT is a manager, and the server for LKH++ is a center. When a user leaves or joins a group, the storage cost of the client and the server by the model are calculated by using the generalized equation, as shown in TABLE 3 and 4. First, when a user leaves or joins a group, in H-LGM, the client stores GK and PK, and the server stores only GK. Next, when one user leaves or joins a group, in LKH, the client stores d KEK and one GK. However, the storage cost according to the leave and join of the server is different. During leave, 2(d-1) KEKs and one GK are stored, and during a join, 2d-1 KEKs and one GK are stored. In OFT, if a user leaves or joins a group, the client stores unblended key and blind node secrets of d+1 and unblended key and blind node secrets of 2d+1 along the path to root, respectively. The server stores 2d-1 VOLUME 4, 2016 and 2d+1 respectively. In LKH++, if a user leaves or joins a group, the client stores key, private key, and random number of d+2 along the path to the root. The server stores d+1.   H-LGM reduces storage than the existing method. This is because, when rekeying, each user only has an individual PK and a new GK, and an agent only has a re-generated GK. Since the storage stored by each user and agent is reduced compared to the existing method, the network lifetime consisting of resource-constraint IoT devices can be extended. When a user leaves or joins a group, the delay of the client for each model is calculated by a generalized equation, as shown in       leaves or joins, d+1 encryption, one decryption, and d xor operations are performed. Fig. 11 is the result of comparing the processing time of the server. (A) and (b) show the results of the overhead of the server for each rekeying according to depth when a user leaves and joins a group. H-LGM reduces the processing time compared to existing method. This is because the depth of the key tree and the update overhead of GK were reduced. As a result, the processing time for agents is reduced compared to the existing method, so lightweight group management can be implemented.

V. LIMITATIONS OF THE STUDY
Our research has several limitations. First, it is necessary to apply hyperledger fabric-based lightweight group management (H-LGM) to IoT devices and prove its effectiveness. This is because the IoT is a promising technology that can change the everyday life of people [27]. However, IoT devices are resource-constrained [28], in order to extend the network lifetime, resource consumption of the device must be reduced. Therefore, it contributes to the implementation of various applications by proving that the resource constraint of the IoT device is improved through the proposed H-LGM. To this end, H-LGM is implemented in IoT development kits and resource consumption is evaluated. Next, it is necessary to consider the possibility that the same GK will be generated again. To create a new GK, H-LGM generates GK using random string and each PK. Since random strings can generate 62 15 random numbers, it is difficult to re-generate the same GK. However, since GK performs a role in protecting important data, it is very important to manage GK. Therefore, the system stability is improved by further reducing the possibility of generating the same GK. To this end, an algorithm that generates more than 62 15 random numbers is developed and performance is evaluated.

VI. CONCLUSION
In this paper, we knew the problem of increasing the storage cost, delay, and processing time for the existing method that manages groups using GK. This problem is because as the number of users increases, the depth of the key tree is increased, and the rekeying overhead is increased. Therefore, we studied hyperledger fabric-based lightweight group management (H-LGM). H-LGM reduces the depth of the key tree and the rekeying overhead. In addition, it secures the reliability of the new GK. Organizing a group using H- LGM can protect important data from external users. As the number of users in existing method increases, the storage cost, delay, and processing time increase, so the network lifetime composed of IoT devices may be reduced. This is because IoT devices are resource-constrained. According to the number of users and the depth of the key tree, the storage cost, delay, and processing time of the proposed H-LGM are analyzed. Storage decreased because the key size of the user and agent was reduced for each rekeying. Also, delay and processing time was reduced because the rekeying overhead was reduced. Therefore, even if the number of users increases, hyperledger fabric-based lightweight group management (H-LGM) reduces storage cost, delay, and processing time, so it can be applied to resource-constraint IoT devices to ensure security of important data.