A Blockchain-Encryption-Based Approach to Protect Fog Federations from Rogue Nodes
AA Blockchain-Encryption-Based Approach toProtect Fog Federations from Rogue Nodes
Mohammed Alshehri, Brajendra Panda
Department of Computer Science and Computer EngineeringUniversity of Arkansas
Fayetteville, USAmsalsheh,[email protected]
Abstract —People have used cloud computing approach to storetheir data remotely. As auspicious as this approach is, it bringsforth many challenges: from data security to time latency issueswith data computation as well as delivery to end users. Fogcomputing has emerged as an extension for cloud computing tobring data processing and storage close to end-users; however,it minimizes the time latency issue but still suffers from datasecurity challenges. For instance, when a fog node providingservices to end users is compromised, the users’ data security canbe violated. Thus, this paper proposes a secure and fine-graineddata access control scheme by integrating the Ciphertext PolicyAttribute-Based Encryption (CP-ABE) algorithm and blockchainconcept to prevent fog nodes from violating end users’ datasecurity in a situation where a compromised fog node is beingousted. We also classify the fog nodes into fog federations, basedon their attributes such as services and locations, to minimize thetime latency and communication overhead between fog nodesand cloud server. Further, the exploitation and integration ofthe blockchain concept and the CP-ABE algorithm enables fognodes in the same fog federation to perform the authorizationprocess in a distributed manner. In addition, to solve time latencyand communication overhead problems, we equip every fog nodewith an off-chain database to store most frequently accesseddata files for specific time, and with an on-chain access controlpolicies table (On-chain Files Tracking Table) which must beprotected from being tampered by malicious (rogue) fog nodes.Therefore, blockchain plays a vital role here as it is tamper-proofby nature. We demonstrate our scheme’s efficiency and feasibilityby designing algorithms and conducting a security analysis. Theprovided analysis shows that the proposed scheme is efficient andfeasible in ousting malicious (rogue) fog nodes.
Index Terms —Fog Computing, blockchain, , rogue node, fine-grained access control
I. I
NTRODUCTION
Cloud computing is a thriving paradigm due to the enor-mous on-demand services it provides to end users over theinternet. Cloud computing has provided customers with inno-vative features such as availability, scalability, and economythat help to satisfy the substantial demand for storage andcomputation resources [10]. End users outsource their data,to the core network on the cloud, for processing and storage.However, there are many obstacles facing data owners. First,the response time between users and the cloud is high becausethe data is stored in far from the data owners. Second, end-users’ data security and privacy are susceptible to violationbecause of the semi-trusted third party controls the cloud. The research community has studied the issues of data securityand privacy in cloud computing by adopting and applyingadvanced cryptographic techniques. However, it is still de-manding to invent a new technology to resolve the cloudlatency issue [9][16].From here, fog computing was introduced in 2012 [6] toreduce the time latency between the cloud and end users’devices [9][16] and to provide new services and applications toend users. Fog computing paradigm is as small clouds closeto end-user’s devices, which allows customers to utilize thecomputing and storage services at the edge of the network[6]. More specifically, fog computing comprises of multiplefog nodes which provide services to end users [27]. Thefog computing paradigm has supported end devices withdistinguishing features such as mobility, location awareness,and low time latency [23]. Because fog computing is deemedas an extension of the cloud computing paradigm; therefore,it inherits some of the security and privacy obstacles in cloudcomputing[24]. In particular, a fog computing paradigm issusceptible to different threats, such as malicious attacks andtechnical issues. In this context, the end users’ data travelingthrough fog computing nodes to the cloud is vulnerable todifferent violations. Therefore, it is necessary to design ascheme to protect end-users’ data confidentiality, availability,and integrity by ousting the rogue (malicious) fog nodes. Onereason for these vulnerabilities is that end users outsourcesensitive data to the nearby fog node for processing and thento the cloud for further processing and storage. Because thisfog node is seen as a connector between end users and thecloud, it is challenging to protect other fog nodes and thecloud from malicious attacks. End users’ data security wouldbe difficult to defend if the fog node providing services interms of storage and computation is compromised or goesrogue. We have been motivated by those issues to protectcustomers’ private data from being compromised. Also, amethod to secure communication among fog nodes is requiredto exchange encrypted data for reducing the time latency toretrieve it from the far cloud.In general, threats in the context of fog computing takestwo forms. 1) data modification: if an adversary gets hands-onend users’ private data, he/she might violate its confidentialityand integrity. Therefore, introducing a security scheme is a r X i v : . [ c s . CR ] J a n ecessary to prevent data confidentiality and integrity violationamong fog nodes; and between fog nodes and the cloud. 2)unauthorized access: when an adversary compromises a fognode, he/she can get unauthorized access to the end users’private data. Besides, data availability is in danger of maliciousviolation in this way. Therefore, it is essential to introduce asecurity scheme to protect against rogue (malicious) fog nodesand to oust them off the network while maintaining low timelatency feature fog computing provides. Additionally, it is vitalto enabling the fog nodes to carry on a distributed authoriza-tion process and to communicate in a trust-less environment.Attribute-Based Encryption (ABE) is a cryptographic prim-itive that enables one-to-many encryption. It comprises twotypes: ciphertext policy attribute-based encryption (CP-ABE)[3] and key policy attribute-based encryption (KP-ABE) [11].CP-ABE was introduced by Bethencourt at el. [3] which isdeemed as one of the most significant algorithms to providefine-grained data access control.Blockchain has attracted the attention of researchers sinceit was introduced in late 2008 [19]. Blockchain is a shareddistributed ledger, which is secured, immutable, and transpar-ent, that helps in processing and tracking resources withoutdepending on a centralized trusted third party [26]. With thispromising technology, peer-to-peer nodes can communicate,and exchange resources where the decision is carried on ina distributed manner by the majority of the network’s nodesrather than a single centralized trusted third party.This paper proposes a scheme to oust rogue (malicious) fognodes and to minimize the communication overhead betweenthe cloud service provider (CSP) and fog nodes (FNs) byintegrating the CP-ABE algorithm and blockchain technology.Blockchain is adopted as a medium to store on-chain trackingtable to verify the identity of each fog node using the smartcontract before they could access the encrypted data on theCSP. The blockchain immutability feature prevents fog nodesfrom maliciously changing the on-chain tracking table, if sucha change detected, the FN which issues the request is reportedas a rogue fog node.The rest of this paper is organized as: Section (II) presentsthe related work. Section (III) focuses on the motivation ofthis paper. Section (IV) explains the proposed scheme, andthe scheme description is broadly explained in section (V).Finally, the security analysis and the conclusion consecutivelyare in sections (VI) and (VII).II. R ELATED W ORK
The main objectives of this paper are to propose a newscheme to allow fog nodes (FNs) to communicate in trustlessenvironment, to maintain end users’ data security, and toreduce the time latency and communication overhead betweenthe cloud service provider (CSP) and the FNs by adoptingand integrating the CP-ABE and blockchain. Therefore, wesummarize the overview of any related state-of-the-art worksin this section, a brief literature review about access control,rogue fog nodes, and fog nodes communication.
A. Access Control
Sahai et al. [20] proposed an attributes-based encryption(ABE) scheme that uses the identity-based encryption al-gorithm [5]. Its two variants are the key-policy ABE (KP-ABE) and the ciphertext-policy ABE (CP-ABE) [11][3]. ABEencryption and decryption processes are based on users’attributes, so the scheme was first adopted in cloud computingto help data owners overcome obstacles such as data securityand data access control when outsourcing data to the cloud.The concept of access control has been well researched incloud-computing, but more investigations are still needed intofog computing. Recently, the research community has studiedaccess control issues in this area and started to adopt ABE inthe environment with the object of providing fine-grained dataaccess control and guaranteeing data security.ABE has been applied to IoT devices to resolve data accesscontrol issues. Yu et al. [27] presented the fine-grained dataaccess control issues arising in a wireless server network,proposing an FDAC scheme in which each sensor node wasassigned a set of attributes and each user was assigned anaccess structure to specify access rights.Huang et al. [14] proposed a CP-ABE scheme to supportdata security and fine-grained data access control, using fea-tures such as ciphertext updating and computation outsourcingfor fog computing with IoT devices. As Zuo et al. [28] alsofound, their scheme’s main problem is that it was only suit-able with an AND-gate encryption predicate. Xiao et al.[25]proposed a hybrid fine-grained search and access authorizationscheme for fog computing, based on a CP-ABE cryptographicprimitive. Their scheme was hybrid as it supported both indexencryption and data encryption. This too, however, supportedonly AND-gate predicates. Mao et al. [17] proposed theconstruction of a CPA-secure and RCCA-secure scheme; itwas based on an ABE model with the possibility of outsourcedencryption verification. Dsouza et al. [21]proposed a schemeto support secure data sharing and communication in fogcomputing. This scheme is no more than a policy managementframework as it lacks details on building the policy repositoryand users’ identities, as well as on making decisions andprotecting users’ identities and data privacy. Stojmenovic etal. [23]studied authorization and authentication issues amongfog devices and between fog and cloud. They based their studyon the ABE algorithm and argued that end users could stillbe authenticated and authorized to fog devices even in thepresence of a vulnerable connection between the fog and thecloud. Li et al.[15] proposed a model to collect smart devices’attributes as dynamic attributes, incorporating them with theABE algorithm to verify the access authority in real time.Mollah et al.[18] proposed a lightweight cryptographic modelto provide access control and data-sharing; in this model, allsecurity operations are offloaded to nearby fog servers.
B. Rogue Fog Nodes
A rogue fog node is a fog node that pretends to be legitimateand deceiving end devices, other fog nodes, or the cloud intocommunicating with it. Its malicious hidden intent is to violatewners’ data security and privacy. Having compromised a fognode, an attacker can violate the security and privacy of endusers’ data in transit to the cloud through the fog nodes. Theresearch community has not broadly addressed this problem.Stojmenovic et al. [22] proposed a scheme to show thefeasibility of a man-in-the-middle attack in which the gatewayis either being compromised or substituted by a fake. Han et al.[12][12] proposed a measurement-based scheme to help usersavoid connecting to fake access points. Their scheme discoversthe rogue AP by calculating the round-trip time between endusers and the DNS server. Mohammed et al.[2] proposedan encryption-based approach to protect fog computing fromrogue fog nodes based on the CP-ABE algorithm. In thisscheme, fog nodes cannot exchange data unless they fully trusteach other. So, to let the fog nodes to carry on a distributedauthorization process is an outstanding idea.
C. Communication among Fog Nodes
Arwa et al. [1] proposed an attribute-based encryptionscheme to maintain fog communications security. Designedto provide authentic, confidential communications among agroup of fog nodes, it made use of a key-exchange protocolbased on the CP-ABE algorithm. The researchers have notwidely addressed this issue.Recently, researchers have started using blockchain to de-velop secure applications, benefiting customers in variousfields. Christidis et al. [8] summarized the blockchain usecases built into the IoT. They reviewed the integration ofa blockchain smart contract into the IoT. Kamanashis etal.[4] proposed a multi-layered security scheme to create asecure communication platform in smart cities by integratingblockchain with smart devices. Researchers use blockchain asa distributed database to store heterogeneous data related tothe smart city, such as traffic and location. These data need tobe shared among smart cities’ components. The main issuesdealt with by this scheme are scalability and reliability in smartcities. In[13], authors proposed a blockchain-based scheme,consisting of distributed data storage, to enable data sharingin IoT environments. The aim of using blockchain was toenable data access control and data storage. In their scheme,the authors separated data store from data management, thenused blockchain to verify the separation and to decentralizethe access control.The fog computing layer occupies the middle ground be-tween cloud servers and end users’ devices and is, therefore,more susceptible to attack than other layers. Data ownerscan find their data damaged or leaked by a rogue fog node.Since one of the primary fog computing features is to increasenetwork reliability, fog nodes need protection method againstmalicious attacks. Protecting the nodes will defend the dataowners’ security and privacy.
D. Our Contributions
To the best of our knowledge, no previous work has adoptedand integrated the blockchain technology with the CP-ABEalgorithm to form a fog federation (FF) and address the problem of rogue fog nodes in fog computing. Based on [26]and [3], we propose a secure scheme in the context of fogcomputing with the following features: 1) to detect and preventrogue fog nodes from violating end users’ data confidentialityand besides to minimize the communication overhead betweenthe cloud server and the fog nodes. 2) to enable the fog nodesto communicate in a trust-less environment. 3) to enable thefog nodes to perform the authorization process in a distributedmanner. 4) it supports end users’ data availability. However,we focus our work on the communication among fog nodesand between fog nodes and the cloud. We assume that themedium between the end users’ devices and the fog nodes issecured for now. III. M
OTIVATION
Fog computing plays critical roles in providing multiple ser-vices to end users such as music, adults’ entertainment, kids’entertainment, emergency vehicle response, and health datacollection at low latency time [6]. Even the innovative featuresfog computing paradigm provides, it introduces many securityissues. However, customers cannot benefit from those servicesfog computing provides if the fog node, which provides theintended services, is not functioning thoughtfully. Therefore,costumers care about their data security and availability indifferent geographic location. This scheme is motivated bythe idea of protecting customers’ data security from roguefog nodes. For example, in the health care sector, health careprovider outsources patients’ sensitive data to the close FN forprocessing and then for uploading to the cloud for permeantstorage. In the future, suppose the FN responsible for thesedata is compromised, this FN could breach end users’ datato attackers. Moreover, end users would not be able to accesshis/her original data as the FN in charge of providing thisservice is comprised, so users need to be forwarded to anothertrusted fog node for data retrieving from the CSP. This paperfocuses on preventing the security threats that rogue fog nodescause the system to breach end users’ encrypted data andthe time latency to delivering the data from the cloud to thefog node. Moreover, we leverage the blockchain technologyto enable fog nodes to provide authorization in a distributedmanner. So, we argue that this would help in recognizingrogue fog nodes. Specifically, an adversary can either takeover the fog node or intercept data flown from the fog nodesto the cloud and vice versa. Based on the literature review,no previous scheme has addressed the issue of protecting thefog nodes from rogue nodes by combining a cryptographicprimitives, such as CP-ABE, with blockchain. Hence, there isa need for an efficient and secure scheme that considers thesesecurity challenges and time latency.IV. P
ROPOSED S CHEME
As Fig. 1 illustrates, our model comprises of the followingentities: a cloud service provider (CSP), fog nodes (FNs),and a Cryptographic Materials Issuer(CMI). Fog nodes (FNs)with same attributes form a fog federation (FF) which isconsidered as a private blockchain. FNs in the FF function ig. 1. The system model. as miners to validate the requests generated by FN in sameFF. Through this paper, we use fog federation and privateblockchain interchangeably.Data delivery from cloud storage to end users’ devices ishindered by time latency and communication overhead. Fogcomputing has emerged to address these issues. However, FNsare exposed to malicious attacks; consequently, the end users’data security may be violated. To maintain confidentiality,integrity and availability for end users’ data travelling throughFNs to the CSP, we exploit and integrate blockchain with theCP-ABE algorithm, an advanced cryptographic primitive thatenforces fine-grained data access control to secure communi-cation between FNs and the CSP. Using blockchain, FNs canperform the authorization process in a distributed manner.To solve the problem of high time latency and communi-cation overhead, we equip every FN with an access controlpolicies table (on-chain files tracking table),as shown in Table-IV, which must be protected from tampering conducted bymalicious (rogue) FNs. Blockchain plays a vital role here, as itis tamper-proof by nature. This scheme equips each FN with aset of attributes, namely location and services. Each FN in thesame FF maintains an on-chain files tracking table to providefine-grained access control by using a smart contract. Thisallows other FNs in the same FF to access the encrypted dataon the CSP when their attributes satisfy the stored predicates inthe on-chain files’ tracking table. When a FN sends a requestto other FNs in the same FF to access a certain file, theycheck whether any FN in the FF has the required file storedin its off-chain database (DB). If so, they refer the requestorto get the file from the FN currently in possession of thefile instead of sending the request to the CSP. This featureis a benefit of our scheme, as it minimizes the time latencyand communication overhead between the CSP and the FF.In addition, the CSP maintains a verification list (VL) of FFs along with their Fog Federation Public Key ( F F P K ) and FogFederarion Attributes (FF att ), as shown in Table-I.This tableallows the CSP to verify the received request from FNs. Italso stores each encrypted file (EF) along with a verificationfile (VF), as shown in Table-II. The CSP uses this table tomatch each EF to the corresponding VF in order to verify therequests arriving from the FNs.In fog computing, FNs collect data from end devices. Theyprocess those data and upload the results to the cloud forfurther processing and storage. We equip every FN with twodatabases (DBs), an off-chain and an on-chain DB. The off-chain DB stores the encrypted data most frequently accessedby end users, which reduces time latency when retrieving theencrypted data from the CSP. FN can retrieve data encryptedby FNs in the same FF. This feature helps maintainingdata availability when ousting an FN from the FF near endusers’ devices. The on-chain database is considered as digitalledger and stored on the blockchain. It stores an on-chain filetracking table as shown in Table-IV to verify FF’s membersidentifications. To protect cryptographic shares from breachingby malicious FN, it is stored off-chain by every FN, Table-III.For the sake of clarity, we will consider the following example:Suppose FN encrypts file F using a random secret key( SK ). Then it generates a V F . Consequently, it uploads theEF into the CSP along with the VF and generates a new rowin the on-chain file tracking table.FN divides the SK and the V F into n shares where n isthe number of FNs in a given FF (private blockchain). It sends[ SK share , VF share , EF ID ] to each FN in the FF to be storedas off-chain cryptographic shares, Table-III. All FNs in thesame FF maintain an on-chain file tracking table, as shownin Table-IV. This table is used to verify the data requestor(FN ID ) by verifying the FN sign − att . This table is protectedfrom being tampered by malicious FNs through the nature ofblockchain services. Suppose FN in the FF seeks to retrievean EF from the CSP. There are three scenarios, which are asfollows.In the first scenario, FN needs to retrieve EF from the TABLE IV
ERIFICATION L IST FF ID FFPK FF att FF Rtufn@10 (Health OR Education) and Atlanta... ... ...FF n TABLE IIE
NCRYPTED F ILES AND V ERIFICATION F ILES EF ID VF ID F VF ... ...F n VF n SP, and no FN has the file in its off-chain DB. FN(requestor)needs to send a request through the FF (private blockchain).Then, the FNs in the same FF would verify the requestor’sattributes signature. If it is verified by the majority of theFNs in the FF, they would share the [ SK share , VF share ,EF ID ] they have related with the EF with the requestor.When the requestor collects at least 51% of the VF’s shares,it sends a request to retrieve the EF from the CSP as[VF shares , EF ,signed (FN att )]. Accordingly, the CSP verifiesthe VF shares ; if they match the VF attached with the EF , itsends the file to the FN to decrypt. For more details, read thescheme’s description.In the second scenario, FN needs to retrieve EF from theCSP, and FN has the file in its off-chain DB. It sends a requestthrough the private blockchain with the [EF , signed (FN att )].Accordingly, FNs verify the FN ’s identity by verifying itssigned attributes using F F P K . If verified, they check whichof the off-chain DBs has the file and then send the FNs ID thathave the EF to the requestor. In this case, the file requestor,FN , does not have to contact the far CSP to retrieve the file. Itcould contact FN to get EF . This feature gives our schemea credit in minimizing the time latency and communicationoverhead between the CSP and the FFs. This is possible withthe fog federation idea. For more details, read the scheme’sdescription.In the third scenario, if FN (the requestor) is not verified,FNs in the FF will report the FN as a rogue FN and deleteit from the on-chain tracking table. It then cannot access anyencrypted data.An FN leaves the system for whatsoever reason, or it couldgo rogue after being compromised by a malicious attack.To ensure users’ data security, namely data confidentiality,and availability, there has been a demand to take precautionsagainst rogue FNs. Our scheme efficiently acts as a protectionlayer against rogue FNs to prevent them from accessing theencrypted data stored on the CSP.All FNs in one FF maintain the same on-chain file trackingtable. Malicious modification of the table by a malicious FNwould be detected, as any update must be verified by themajority of the FNs, which is why we utilize the blockchainas FFs. If an FN issues an update and it is not passed by mostof the FNs, the issuer would be considered as a rogue FN andthen excluded from the FF. When a rogue FN is detected in theFF, it is reported to the CSP. Then, the CSP will not respond toany requests from this FN. Accordingly, this feature enhancesthe scheme’s ability to protect against rogue FNs. TABLE IIIC
RYPTOGRAPHIC S HARES EF ID VF share SK share EF MNGONMDF SK ... ... ...EF n MNGONMDF SK n TABLE IVO N -C HAIN T RACKING T ABLE FN ID EF ID FN sign − att attributes set off-chain DB FN EF fNJk3u@ Movies and CL EF FN EF KLJk3J@ Edu and AT 0... ... ... ... ...FN n EF @3EFJJL@ Health and AR 0 Algorithm 1
Setup( λ ) Choose bilinear cyclic group G of prime order p withgenerator g ; Randomly generates exponents α, β ∈ G ∗ p ; Random Oracle H : U SAT → { } ∗ // to map each attin USAT into random element ∈ G ; compute SM K and
SP K as: SM K = { β, g α } SP K = { G , g , g β , e ( g , g ) α } ; The
SP K is public to all FNs, but
SM K is private forCMI V. S
CHEME D ESCRIPTION
In this section, we present the description of our schemebased on the integration of the CP-ABE algorithm andblockchain. We exploit the access tree model presented in[3] as an access structure A, as shown in Fig-2. To satisfythe access tree conditions, we follow the same methods in[3][5]. For more information about the access tree model, readthrough [3][5]. Next we provide algorithms needed for ourmodel.Algorithm 1, which is based on [3], is executed by CMI.It receives a security parameter as an input, then it outputs asystem master key (
SM K ) and a system public key (
SP K ).It builds a universal set of attributes (USAT), which FF clas-sification is based on in our scheme; USAT = FN’s location,FN’s services.Algorithm-2 is executed by an FN that intends to join thesystem to provide a service for end users. It contacts the CMI,then the CMI checks the FFL. Then, it assigns the FN to thecorresponding FF if its attributes are verified. If the FN isverified but no FF att matches its attributes, the CMI creates a
Fig. 2. Example of an access structure. lgorithm 2
Join (FN att ) New FN contacts CMI to join the system CMI verifies the FN (requestor) if not verified then Declined else Check the FFL if FF att == new-FN att then Assign new-FN att to the corresponding FF ID end if Assign new FN ID as: FF ID .FN ID Send new FN ID to all FN in the same FF end if for every FN ∈ FF do share on-chain ledgers (on-chain tracking table) withthe new FN end for if New FN receives at most 49% of un-identical on-chainidentical ledgers then report a problem to CMI else
Return (on-chain ledgers are authenticated) end ifAlgorithm 3
Generating
F N SK ( SP K, SM K, S, F N ID ) CMI gets request from new FN to join the system Choose bilinear cyclic group G of prime order p withgenerator g ; Randomly generates exponents α , β ∈ G ∗ p ; Random Oracle H : U SAT → { } ∗ // to map each attin USAT into random element ∈ G ; compute F F P K and
F F M K as: F F P K = { β , g α } F F M K = { G , g , g β , e ( g , g ) α } generate random r ∈ Z ∗ p for every att i ∈ S do generate random r i ∈ Z ∗ P end for for each new FN i ∈ F F do compute F N SK send
F N SK to FN i end for new FF and adds the new FN to it. If the FN is not verified, theconnection will be refused. However, as each FF is considereda private blockchain, the FNs already part of the FF have toshare their on-chain ledger with the new FN. If the new FNreceives 51% of identical ledgers, it saves them in the on-chainDB. Otherwise, it reports an issue to the CMI. The details ofhow to verify and authenticate the FN’s attributes are out ofour scope for now.Algorithm 3 is executed by the CMI. It generates a FogFederation Public Key ( F F P K ) and a Fog Federation MasterKey (
F F M K ). The
F F P K is public to all FNs in the FF,whereas the
F F M K is private to the CMI. It also generates
Algorithm 4
Data Encryption ( M , T, SP K , F F P K ) SK = gen.DEC-Key verification-file = generate.VF VF share = VF/n // n is the number of FNs in FF divide SK key to shares as: SK/n Encrypted-File (EF) = Encrypt (M, SK) //M is the messageto encrypt A is set of atts represented by monotone access structuretree T for each node x in T do set a polynomial if node x is root node in T then set q (0) R = s // s is random value ∈ Z ∗ P else q (0) x = q parent ( x ) ( index ( x )) then choose d x = k x - 1 as polynomial degree tointerpolate with q x end if end for for each y ∈ Y do //Y is the set of leaf nodes in T C y = g q y (0) C (cid:48) y = H ( att ( y )) q y (0) end for Compute: C = g βs for each SK i ∈ SK do Compute C ver i = SK i .e ( g, g ) αs end for Upload [EF, EF ID , VF, FN att s ig ] to CSP for each FN ∈ FF do send [EF ID , VF i , C ver i ] end for a distinct Fog Node Secret Key ( F N SK ) for each FN in theFF. Then, the CMI securely shares the
F F P K and
F N SK with the new FN.Algorithm 4 is executed by authorized FNs in a given FF.The FN intending to encrypt a file generates a secret key (SK)and uses it to encrypt the file. It also generates a verificationfile (
V F ) which is used for further requestors verification bythe CSP. Then, it divides the SK and the VF into n shares as Algorithm 5 on-chain tracking table smart contract sig = sign(FN att , F N SK ) // for future authentication propagate the transaction through FF [EF ID , Current-Hash, Prev.Hash, Timestamp, FN att − sig ] if transaction is verified and FN att.sig.verify is true then File owner (FN) generates a new row in on-chain filetracking table as:[FN ID , EF ID , attributes-set, off-chainDB] FNs ∈ FF update the on-chain tracking table else decline and Report FN as rogue FN to all FNs in FFby its ID end iflgorithm 6 File Retrieving Smart Contract Part 1:
FN (requestor) ID verification FN send a request through FF as [FN ID , EF ID ,FN att − sig ] for every FN i ∈ FF do if FN att − sig == true then send [ SK share , VF share , EF ID ] else decline end if end for if FN (requestor) recieves 51% of (SK,VF) shares then send (SK,VF) shares to CSP end if
Part 2:
CSP checks the VF shares if VF shares match at least 51% of VF then send EF to the FN (requestor) else decline the request and report FN to CMI as rogue node end if n is the number of FNs in the FF. After that, it encrypts the SK i,shares using the CP-ABE algorithm to enable every FNin the same FF to decrypt the encrypted SK . Finally, the dataowner (FN) uploads the EF along with the VF to the CSP. Weassume that the number of FNs in an FF is fixed for now.Algorithm 5 is an on-chain smart contract which is triggeredamong authorized FNs in the FF. The basic function of thissmart contract is to keep tracking which FNs have which filesin the off-chain DB. This means less time latency to retrieveEFs from the CSP and less communication overhead betweenthe CSP and the FFs. No FN can retrieve the EF or performany operation unless it is authorized by the majority of theFNs in the FF. This is attributed to the blockchain tamper-proof feature. When a FN submits a rquest to retrieve anEF from the cloud it has to sign its attributes using its own F N SK , then the others FF’s members will authenticate itby checking its signature using the
F F P K . This feature isa credit to our scheme, as it prevents FNs in the FF fromfalsifying information about files’ tracking table or accessingthe EF in the CSP.Algorithm 6 is a smart contract which two parts. First partis executed between the FN that intends to retrieve an EFfrom the CSP and FF’s members. Second part is between theFN (requestor) and the CSP. FN first propagates a request toretrieve an EF from the CSP through the private blockchain.All FNs in the FF verify the requestor attributes by verifyingthe requestor attribute signature. When majority FNs verify therequestor (see algorithm 7), they send [ SK share , V F share ]tothe EF requestor. When the EF’s requestor (FN) receives 51%of the shares, it send [ SK share , VF share , EF ID ] to the CSP.The CSP checks the shares against the pre-stored VF. If theshares match at least 51% of the VF, the CSP sends the EFto the FN. If the shares do not match the VF, the CSP willreport the requestor as a rogue FN to the CMI. This feature Algorithm 7
Consensus approach assume 3f + 1 of FNs in FF // f is max number of FNswhich may fail if
2f +1 of FNs confirm the transaction then FNs come to consensus else discard the transaction end if strengthens our scheme in ousting rogue FNs to protect endusers’ data confidentiality, availability and to authenticate theFF’s members identity.Algorithm 7 is based on Practical Byzantine fault toleranceapproach (PBFT) [7]. We assume that the FF has 3f + 1 ofFNs, where f is the maximum number of FNs that could fail.To confirm a specific transaction in our scheme, at least 2f +1 of FNs must agree on it. In this method, the authorized FNsin the FF come to a consensus state.VI. S ECURITY A NALYSIS
A. Confidentiality
The EFs in the CSP is protected against rogue FNs. Toretrieve an EF, the FN must sign its attributes using its
F N SK , then send it with the request as a transaction throughthe private blockchain. The EF’s requestor must accumulateat least 51% of [ SK shares , VF shares ] to be able to retrievethe EF from the CSP. This will not happen unless the EF’s re-questor passed the authorization process (algorithm 6) throughthe private blockchain. If the EF’s requestor is not authorizedby the majority of FF’s members, it is reported as a rogue FNand consequently cannot access the EFs in the CSP or in anoff-chain DB of other FNs. This feature makes our schemeefficient in protecting end users’ data confidentiality. B. Availability
The proposed scheme guarantees the data availability: eventhe FN providing services to end-users is down. The idea of theFF enables data owner to retrieve their encrypted data throughany FN ∈ same FF. The most frequently accessed EFs arestored in the off-chain DB of the FN that recently accessed it.This means the end users’ data would be available near themfor a period of time. The off-chain DB is flushed regularly asprecaution against malicious FN. C. Ousting Rogue FN
This scheme aims to oust rogue FNs from the system to keepend users’ data secured from being breached or compromised.This feature is obvious through algorithms (5,6). In particular,if the FN (requestor) does not sign its attributes with thecorrect
F N SK , FN authorization process will be denied bythe private blockchain. Therefore, it would be ousted andprotected from accessing the EFs in the CSP and in an off-chain DB of other FNs in same FF.II. C
ONCLUSION
If the FNs providing services to end users are malfunc-tioning, end-users’ data security can be violated. Also, it ispossible that the FNs to go rogue which maliciously wouldviolate end-users’ data security. Besides, the time latencyand communication overhead between the CSP and FNs arehigh when every time FN retrieves encrypted data from theCSP for processing. This paper proposed a novel schemeto protect end-users’ data security from being breached byrogue FNs and to reduce the time latency and communicationoverhead between the FNs and the CSP. It also enables FNsto communicate in a trust-less environment, and to performauthorization processes in distributed manner to detect therogue fog node. The proposed scheme exploited and inte-grated the CP-ABE algorithm and the blockchain concept. Weclassified the FNs into FFs (private blockchain) according totheir attributes and equipped each FN with on-chain and off-chain databases. The data requestor (FN) must sing its attributeusing its own
F N SK before propagating a request through theprivate blockchain to access EF stored in the CSP. In case therequestor FN att − sig is not verified by the majority of the FNs ∈ FF, the FN would be reported as a rogue FN. We provideda security analysis to show the proposed scheme is securedagainst rogue FNs and is efficient in reducing time latencyand communication overhead between the CSP and the FNs.Our future work will conduct a simulation stage to test ourscheme performance. R
EFERENCES[1] Arwa Alrawais, Abdulrahman Alhothaily, Chunqiang Hu, XiaoshuangXing, and Xiuzhen Cheng. An attribute-based encryption scheme tosecure fog communications.
IEEE access , 5:9131–9138, 2017.[2] Mohammed Alshehri and Brajendra Panda. An encryption-based ap-proach to protect fog federations from rogue nodes. In
InternationalConference on Security, Privacy and Anonymity in Computation, Com-munication and Storage , pages 225–243. Springer, 2019.[3] John Bethencourt, Amit Sahai, and Brent Waters. Ciphertext-policyattribute-based encryption. In , pages 321–334. IEEE, 2007.[4] Kamanashis Biswas and Vallipuram Muthukkumarasamy. Securingsmart cities using blockchain technology. In ,pages 1392–1393. IEEE, 2016.[5] Dan Boneh and Matt Franklin. Identity-based encryption from the weilpairing. In
Annual international cryptology conference , pages 213–229.Springer, 2001.[6] Flavio Bonomi, Rodolfo Milito, Jiang Zhu, and Sateesh Addepalli. Fogcomputing and its role in the internet of things. In
Proceedings of thefirst edition of the MCC workshop on Mobile cloud computing , pages13–16. ACM, 2012.[7] Miguel Castro and Barbara Liskov. Practical byzantine fault toleranceand proactive recovery.
ACM Transactions on Computer Systems(TOCS) , 20(4):398–461, 2002.[8] Konstantinos Christidis and Michael Devetsikiotis. Blockchains andsmart contracts for the internet of things.
Ieee Access , 4:2292–2303,2016.[9] Ruilong Deng, Rongxing Lu, Chengzhe Lai, and Tom H Luan. Towardspower consumption-delay tradeoff by workload allocation in cloud-fogcomputing. In , pages 3909–3914. IEEE, 2015. [10] Armando Fox, Rean Griffith, Anthony Joseph, Randy Katz, AndrewKonwinski, Gunho Lee, David Patterson, Ariel Rabkin, and Ion Stoica.Above the clouds: A berkeley view of cloud computing.
Dept. ElectricalEng. and Comput. Sciences, University of California, Berkeley, Rep.UCB/EECS , 28(13):2009, 2009.[11] Vipul Goyal, Omkant Pandey, Amit Sahai, and Brent Waters. Attribute-based encryption for fine-grained access control of encrypted data. In
Proceedings of the 13th ACM conference on Computer and communi-cations security , pages 89–98. Acm, 2006.[12] Hao Han, Bo Sheng, Chiu Chiang Tan, Qun Li, and Sanglu Lu. Ameasurement based rogue ap detection scheme. In
IEEE INFOCOM2009 , pages 1593–1601. IEEE, 2009.[13] S. H. Hashemi, F. Faghri, P. Rausch, and R. H. Campbell. World ofempowered iot users. In , pages 13–24,April 2016.[14] Qinlong Huang, Yixian Yang, and Licheng Wang. Secure data accesscontrol with ciphertext update and computation outsourcing in fogcomputing for internet of things.
IEEE Access , 5:12941–12950, 2017.[15] Fei Li, Yogachandran Rahulamathavan, Mauro Conti, and MuttukrishnanRajarajan. Robust access control framework for mobile cloud computingnetwork.
Computer Communications , 68:61–72, 2015.[16] Jianhua Li, Jiong Jin, Dong Yuan, Marimuthu Palaniswami, and KlausMoessner. Ehopes: Data-centered fog platform for smart living. In , pages 308–313. IEEE, 2015.[17] X. Mao, J. Lai, Q. Mei, K. Chen, and J. Weng. Generic and efficientconstructions of attribute-based encryption with verifiable outsourceddecryption.
IEEE Transactions on Dependable and Secure Computing ,13(5):533–546, Sep. 2016.[18] Muhammad Baqer Mollah, Md Abul Kalam Azad, and AthanasiosVasilakos. Secure data sharing and searching at the edge of cloud-assisted internet of things.
IEEE Cloud Computing , 4(1):34–42, 2017.[19] Satoshi Nakamoto et al. Bitcoin: A peer-to-peer electronic cash system.2008.[20] Amit Sahai and Brent Waters. Fuzzy identity-based encryption. In
Annual International Conference on the Theory and Applications ofCryptographic Techniques , pages 457–473. Springer, 2005.[21] Stavros Salonikias, Ioannis Mavridis, and Dimitris Gritzalis. Accesscontrol issues in utilizing fog computing for transport infrastructure.In
International Conference on Critical Information InfrastructuresSecurity , pages 15–26. Springer, 2015.[22] Ivan Stojmenovic and Sheng Wen. The fog computing paradigm:Scenarios and security issues. In , pages 1–8. IEEE, 2014.[23] Ivan Stojmenovic, Sheng Wen, Xinyi Huang, and Hao Luan. Anoverview of fog computing and its security issues.
Concurrency andComputation: Practice and Experience , 28(10):2991–3005, 2016.[24] Hassan Takabi, James BD Joshi, and Gail-Joon Ahn. Security andprivacy challenges in cloud computing environments.
IEEE Security& Privacy , 8(6):24–31, 2010.[25] Min Xiao, Jing Zhou, Xuejiao Liu, and Mingda Jiang. A hybrid schemefor fine-grained search and access authorization in fog computingenvironment.
Sensors , 17(6):1423, 2017.[26] Xiwei Xu, Ingo Weber, Mark Staples, Liming Zhu, Jan Bosch, Len Bass,Cesare Pautasso, and Paul Rimba. A taxonomy of blockchain-basedsystems for architecture design. In , pages 243–252. IEEE, 2017.[27] Shanhe Yi, Cheng Li, and Qun Li. A survey of fog computing: concepts,applications and issues. In
Proceedings of the 2015 workshop on mobilebig data , pages 37–42. ACM, 2015.[28] Cong Zuo, Jun Shao, Guiyi Wei, Mande Xie, and Min Ji. Cca-secureabe with outsourced decryption for fog computing.