Mn3422372248

B. Shanmukhi, D. Satyanarayana / International Journal of Engineering Research and
Applications (IJERA) ISSN: 2248-9622 www.ijera.com
Vol. 3, Issue 4, Jul-Aug 2013, pp.2237-2248
2237 | P a g e
Framework for Multi-Cloud Using Integrity Verification Using
CPDP Scheme
B. Shanmukhi*, D. Satyanarayana**
*[II-M. Tech] - CSE, Dr. KVSRIT Kurnool.
**Asst. Prof in CSE Dept, Dr. KVSRCEW Kurnool.
ABSTRACT
Provable data possession (PDP) is a
technique for ensuring the integrity of data in
storage outsourcing. In this paper, we address the
construction of an efficient PDP scheme for
distributed cloud storage to support the scalability
of service and data migration, in which we
consider the existence of multiple cloud service
providers to cooperatively store and maintain the
clients’ data. We present a cooperative PDP
(CPDP) scheme based on homomorphic verifiable
response and hash index hierarchy. We prove the
security of our scheme based on multi-prover
zero-knowledge proof system, which can satisfy
completeness, knowledge soundness, and zero-
knowledge properties. In addition, we articulate
performance optimization mechanisms for our
scheme, and in particular present an efficient
method for selecting optimal parameter values to
minimize the computation costs of clients and
storage service providers. Our experiments show
that our solution introduces lower computation
and communication overheads in comparison with
non-cooperative approaches.
Index Terms—Storage Security, Provable Data
Possession, Interactive Protocol, Zero-knowledge,
Multiple Cloud, Cooperative
I. INTRODUCTION
In recent years, cloud storage service has
become a faster profit growth point by providing a
comparably low-cost, scalable, position-independent
platform for clients’ data. Since cloud computing
environment is constructed based on open
architectures and interfaces, it has the capability to
incorporate multiple internal and/or external cloud
services together to provide high interoperability. We
call such a distributed cloud environment as a multi-
Cloud (or hybrid cloud). Often, by using virtual
infrastructure management (VIM), a multi-cloud
allows clients to easily access his/her resources
remotely through interfaces such as Web services
provided by Amazon EC2. There exist various tools
and technologies for multi-cloud, such as Platform
VM Orchestrator, VMware vSphere, and Ovirt.
These tools help cloud providers construct a
distributed cloud storage platform (DCSP) for
managing clients’ data. However, if such an
important platform is vulnerable to security attacks, it
would bring irretrievable losses to the clients. For
example, the confidential data in an enterprise may
be illegally accessed through a remote interface
provided by a multi-cloud, or relevant data and
archives may be lost or tampered with when they are
stored into an uncertain storage pool outside the
enterprise. Therefore, it is indispensable for cloud
service providers (CSPs) to provide security
techniques for managing their storage services.
Provable data possession (PDP) (or proofs
of retrievability (POR)) is such a probabilistic proof
technique for a storage provider to prove the integrity
and ownership of clients’ data without downloading
data. The proof-checking without downloading
makes it especially important for large-size files and
folders (typically including many clients’ files) to
check whether these data have been tampered with or
deleted without downloading the latest version of
data. Thus, it is able to replace traditional hash and
signature functions in storage outsourcing. Various
PDP schemes have been recently proposed, such as
Scalable PDP [4] and Dynamic PDP. However, these
schemes mainly focus on PDP issues at untrusted
servers in a single cloud storage provider and are not
suitable for a multi-cloud environment (see the
comparison of POR/PDP schemes in Table 1).
Motivation: To provide a low-cost, scalable,
location independent platform for managing clients’
data, current cloud storage systems adopt several new
distributed file systems, for example, Apache Hadoop
Distribution File System (HDFS), Google File
System (GFS), Amazon S3 File System, CloudStore
etc. These file systems share some similar features: a
single metadata server provides centralized
management by a global namespace; files are split
into blocks or chunks and stored on block servers;
and the systems are comprised of interconnected
clusters of block servers. Those features enable cloud
service providers to store and process large amounts
of data. However, it is crucial to offer an efficient
verification on the integrity and availability of stored
data for detecting faults and automatic recovery.
Moreover, this verification is necessary to provide
reliability by automatically maintaining multiple
copies of data and automatically redeploying
processing logic in the event of failures.
Even though existing PDP schemes have
addressed various security properties, such as public
verifiability, dynamics, scalability, and privacy
preservation, we still need a careful consideration of

2238 | P a g e
some potential attacks, including two major
categories: Data Leakage Attack by which an
adversary can easily obtain the stored data through
verification process after running or wiretapping
sufficient verification communications (see Attacks 1
and 3 in Appendix A), and Tag Forgery Attack by
which a dishonest CSP can deceive the clients (see
Attacks 2 and 4 in Appendix A). These two attacks
may cause potential risks for privacy leakage and
ownership cheating. Also, these attacks can more
easily compromise the security of a distributed cloud
system than that of a single cloud system.
Although various security models have been
proposed for existing PDP schemes, these models
still cannot cover all security requirements, especially
for provable secure privacy preservation and
ownership authentication. To establish a highly
effective security model, it is necessary to analyze the
PDP scheme within the framework of zero-
knowledge proof system (ZKPS) due to the reason
that PDP system is essentially an interactive proof
system (IPS), which has been well studied in the
cryptography community. In summary, a verification
scheme for data integrity in distributed storage
environments should have the following features:
 Usability aspect: A client should utilize the
integrity check in the way of collaboration services.
The scheme should conceal the details of the storage
to reduce the burden on clients;
 Security aspect: The scheme should provide
adequate security features to resist some existing
attacks, such as data leakage attack and tag forgery
attack;
 Performance aspect: The scheme should
have the lower communication and computation
overheads than non-cooperative solution.
 Related Works: To check the availability
and integrity of outsourced data in cloud storages,
researchers have proposed two basic approaches
called Provable Data Possession (PDP) and Proofs of
Retrievability (POR). Ateniese et al. first proposed
the PDP model for ensuring possession of files on
untrusted storages and provided an RSA-based
scheme for a static case that achieves the (1)
communication cost. They also proposed a publicly
verifiable version, which allows anyone, not just the
owner, to challenge the server for data possession.
This property greatly extended application areas of
PDP protocol due to the separation of data owners
and the users. Moreover, they do not fit for multi-
cloud storage due to the loss of homomorphism
property in the verification process.
Table 1: Comparison of POR/PDP schemes for a file consisting of blocks.
is the number of sectors in each block, is the
number of CSPs in a multi-cloud, is the number of
sampling blocks, and are the probability of
block corruption in a cloud server and -th cloud
server in a multi-cloud = { }, respective, ♯
denotes the verification process in a trivial approach,
and , , denotes Merkle Hash tree,
homomorphic tags, and homomorphic responses,
respectively.
In order to support dynamic data operations,
Ateniese et al. developed a dynamic PDP solution
called Scalable PDP. They proposed a lightweight
PDP scheme based on cryptographic hash function
and symmetric key encryption, but the servers can
deceive the owners by using previous metadata or
responses due to the lack of randomness in the
challenges. The numbers of updates and challenges
are limited and fixed in advance and users cannot
perform block insertions anywhere. Based on this
work, Erway et al. introduced two Dynamic PDP
schemes with a hash function tree to realize (log )
communication and computational costs for a -
block file. The basic scheme, called DPDP-I, retains
the drawback of Scalable PDP, and in the ‘blockless’
scheme, called DPDPII, the data blocks {
} ∈[1, ] can be leaked by the response of a challenge,
= Σ =1 , where is a random challenge
value. Furthermore, these schemes are also not
effective for a multi-cloud environment because the
verification path of the challenge block cannot be
stored completely in a cloud.
Juels and Kaliski [3] presented a POR
scheme, which relies largely on preprocessing steps
that the client conducts before sending a file to a
CSP. Unfortunately, these operations prevent any
efficient extension for updating data. Shacham and
Waters proposed an improved version of this protocol
called Compact POR, which uses homomorphic
property to aggregate a proof into (1) authenticator
value and ( ) computation cost for challenge
blocks, but their solution is also static and could not
prevent the leakage of data blocks in the verification
process. Wang et al. presented a dynamic scheme

2239 | P a g e
with (log ) cost by integrating the Compact POR
scheme and Merkle Hash Tree (MHT) into the
DPDP. Furthermore, several POR schemes and
models have been recently proposed including [9],
[10]. In [9] Bowers et al. introduced a distributed
cryptographic system that allows a set of servers to
solve the PDP problem.
This system is based on an integrity-
protected error correcting code (IP-ECC), which
improves the security and efficiency of existing tools,
like POR. However, a file must be transformed into
distinct segments with the same length, which are
distributed across servers. Hence, this system is
more suitable for RAID rather than cloud storage.
Our Contributions: In this paper, we address the
problem of provable data possession in distributed
cloud environments from the following aspects: high
security, transparent verification, and high
performance. To achieve these goals, we first
propose a verification framework for multi-cloud
storage along with two fundamental techniques: hash
index hierarchy (HIH) and homomorphic verifiable
response (HVR).
We then demonstrate that the possibility of
constructing a cooperative PDP (CPDP) scheme
without compromising data privacy based on modern
cryptographic techniques, such as interactive proof
system (IPS). We further introduce an effective
construction of CPDP scheme using above-
mentioned structure. Moreover, we give a security
analysis of our CPDP scheme from the IPS model.
We prove that this construction is a multi-prover
zero-knowledge proof system (MP-ZKPS), which has
completeness, knowledge soundness, and zero-
knowledge properties. These properties ensure that
CPDP scheme can implement the security against
data leakage attack and tag forgery attack. To
improve the system performance with respect to our
scheme, we analyze the performance of probabilistic
queries for detecting abnormal situations. This
probabilistic method also has an inherent benefit in
reducing computation and communication overheads.
Then, we present an efficient method for the selection
of optimal parameter values to minimize the
computation overheads of CSPs and the clients’
operations. In addition, we analyze that our scheme is
suitable for existing distributed cloud storage
systems. Finally, our experiments show that our
solution introduces very limited computation and
communication overheads.
Organization: The rest of this paper is organized as
follows. In Section 2, we describe a formal definition
of CPDP and the underlying techniques, which are
utilized in the construction of our scheme. We
introduce the details of cooperative PDP scheme for
multicloud storage in Section 3. We describe the
security and performance evaluation of our scheme in
Section 4 and 5, respectively. We discuss the related
work in Section and Section 6 concludes this paper.
II. STRUCTURE AND TECHNIQUES
In this section, we present our verification
framework for multi-cloud storage and a formal
definition of CPDP. We introduce two fundamental
techniques for constructing our CPDP scheme: hash
index hierarchy (HIH) on which the responses of the
clients’ challenges computed from multiple CSPs can
be combined into a single response as the final result;
and homomorphic verifiable response (HVR) which
supports distributed cloud storage in a multi-cloud
storage and implements an efficient construction of
collision-resistant hash function, which can be
viewed as a random oracle model in the verification
protocol.
2.1 Verification Framework for Multi-Cloud
Although existing PDP schemes offer a
publicly accessible remote interface for checking and
managing the tremendous amount of data, the
majority of existing PDP schemes is incapable to
satisfy the inherent requirements from multiple
clouds in terms of communication and computation
costs. To address this problem, we consider a multi-
cloud storage service as illustrated in Figure 1. In this
architecture, a data storage service involves three
different entities: Clients who have a large amount of
data to be stored in multiple clouds and have the
permissions to access and manipulate stored data;
Cloud Service Providers (CSPs) who work together
to provide data storage services and have enough
storages and computation resources; and Trusted
Third Party (TTP) who is trusted to store verification
parameters and offer public query services for these
parameters.
In this architecture, we consider the
existence of multiple CSPs to cooperatively store and
maintain the clients’ data. Moreover, a cooperative
PDP is used to verify the integrity and availability of
their stored data in all CSPs. The verification
procedure is described as follows: Firstly, a client
(data owner) uses the secret key to pre-process a file
which consists of a collection of blocks, generates a
set of public verification information that is stored in
TTP, transmits the file and some verification tags to
CSPs, and may delete its local copy;
Fig 1: Verification architecture for data
integrity

2240 | P a g e
Then, by using a verification protocol, the
clients can issue a challenge for one CSP to check the
integrity and availability of outsourced data with
respect to public information stored in TTP.
We neither assume that CSP is trust to
guarantee the security of the stored data, nor assume
that data owner has the ability to collect the evidence
of the CSP’s fault after errors have been found. To
achieve this goal, a TTP server is constructed as a
core trust base on the cloud for the sake of security.
We assume the TTP is reliable and independent
through the following functions: to setup and
maintain the CPDP cryptosystem; to generate and
store data owner’s public key; and to store the public
parameters used to execute the verification protocol
in the CPDP scheme. Note that the TTP is not
directly involved in the CPDP scheme in order to
reduce the complexity of cryptosystem.
2.2 Definition of Cooperative PDP
In order to prove the integrity of data stored
in a multi-cloud environment, we define a framework
for CPDP based on interactive proof system (IPS)
and multi-prover zero-knowledge proof system
(MPZKPS), as follows:
Definition 1 (Cooperative-PDP): A cooperative
provable data possession = ( , ,
) is a collection of two algorithms ( ,
) and an interactive proof system , as
follows: (1 ): takes a security parameter as input,
and returns a secret key or a public-secret key
pair( , );
( , , ): takes as inputs a secret key , a
file , and a set of cloud storage providers ={ },
and returns the triples ( , , ), where is the secret
in tags, = ( ,ℋ) is a set of verification parameters
and an index hierarchy ℋ for , ={ ( )} ∈
denotes a set of all tags, ( ) is the tag of the fraction
( ) of in ;
( , ): is a protocol of proof of data possession
between CSPs ( = { }) and a verifier (V), that is,
Where each takes as input a file ( ) and a set of
tags ( ), and a public key and a set of public
parameters are the common input between and .
At the end of the protocol run, returns a bit {0∣1}
denoting false and true. Where, Σ ∈ denotes
cooperative computing in ∈ . A trivial way to
realize the CPDP is to check the data stored in each
cloud one by one, i.e.,
Where ⋀ denotes the logical AND operations among
the boolean outputs of all protocols ⟨ , ⟩ for all
∈ . However, it would cause significant
communication and computation overheads for the
verifier, as well as a loss of location-transparent.
Such a primitive approach obviously diminishes the
advantages of cloud storage: scaling arbitrarily up
and down on demand. To solve this problem, we
extend above definition by adding an organizer ( ),
which is one of CSPs that directly contacts with the
verifier, as follows:
Where the action of organizer is to initiate and
organize the verification process. This definition is
consistent with aforementioned architecture, e.g., a
client (or an authorized application) is considered as
, the CSPs are as = { }∈[1, ], and the Zoho
cloud is as the organizer in Figure 1. Often, the
organizer is an independent server or a certain CSP in
. The advantage of this new multi-prover proof
system is that it does not make any difference for the
clients between multi-prover verification process and
single-prover verification process in the way of
collaboration. Also, this kind of transparent
verification is able to conceal the details of data
storage to reduce the burden on clients. For the sake
of clarity, we list some used signals in Table 2.
Table 2: The signal and its explanation
Sig. Repression
the number of blocks in a file;
the number of sectors in each block;
the number of index coefficient pairs in a
query;
the number of clouds to store a file;
the file with × sectors, i.e., =
{ , } ∈[1, ] ∈[1, ] ;
the set of tags, i.e., = { } ∈[1, ];
the set of index-coefficient pairs, i.e., = {( ,
)};
The response for the challenge .
2.3 Hash Index Hierarchy for CPDP
To support distributed cloud storage, we
illustrate a representative architecture used in our
cooperative PDP scheme as shown in Figure 2. Our
architecture has a hierarchy structure which
resembles a natural representation of file storage.
This hierarchical structure ℋ consists of three layers
to represent relationships among all blocks for stored
resources. They are described as follows:
1) Express Layer: offers an abstract representation
of the stored resources;
2) Service Layer: offers and manages cloud
storage services; and

2241 | P a g e
3) Storage Layer: realizes data storage on many
physical devices.
We make use of this simple hierarchy to
organize data blocks from multiple CSP services into
a large size file by shading their differences among
these cloud storage systems. For example, in Figure 2
the resources in Express Layer are split and stored
into three CSP’s that are indicated by different colors,
in Service Layer. In turn, each CSP fragments and
stores the assigned data into the storage servers in
Storage Layer. We also make use of colors to
distinguish different CSPs. Moreover, we follow the
logical order of the data blocks to organize the
Storage Layer. This architecture also provides special
functions for data storage and management, e.g.,
there may exist overlaps among data blocks (as
shown in dashed boxes) and discontinuous blocks but
these functions may increase the complexity of
storage management.
In storage layer, we define a common
fragment structure that provides probabilistic
verification of data integrity for outsourced storage.
The fragment structure is a data structure that
maintains a set of block-tag pairs, allowing searches,
checks and updates in (1) time. An instance of this
structure is shown in storage layer of Figure 2: an
outsourced file is split into blocks { 1,2, ⋅ ⋅ ⋅
, }, and each block is split into sectors
{ ,1, ,2, ⋅ ⋅ ⋅ , , }. The fragment structure
consists of block-tag pair ( , ), where is a
signature tag of block generated by a set of secrets
= ( 1, 2, ⋅ ⋅ ⋅ , ).
In order to check the data integrity, the
fragment structure implements probabilistic
verification as follows:
Fig 2. Index-hash hierarchy of CPDP model.
given a random chosen challenge (or query) = {( ,
)} ∈ , where is a subset of the block indices and
is a random coefficient. There exists an efficient
algorithm to produce a constant-size response ( 1,
2, ⋅ ⋅ ⋅ , , ′), where comes from all { , ,
} ∈ and ′ is from all { , } ∈ .
Given a collision-resistant hash function (⋅),
we make use of this architecture to construct a Hash
Index Hierarchy ℋ (viewed as a random oracle),
which is used to replace the common hash function in
prior PDP schemes, as follows:
1) Express layer: given random { } =1 and the
file name , sets (1) = Σ =1 ( ) and makes it
public for verification but makes { } =1 secret;
2) Service layer: given the (1) and the cloud name
, sets (2) = (1) ( );
3) Storage layer: given the (2)
, a block number , and
its index record = “ ∣∣ ∣∣ ”, sets (3)
, = (2)
( ), where is the sequence number of a block,
is the updated version number, and is a random
integer to avoid collision. As a virtualization
approach, we introduce a simple index-hash table =
{ } to record the changes of file blocks as well as to
generate the hash value of each block in the
verification process. The structure of is similar to
the structure of file block allocation table in file
systems. The index-hash table consists of serial
number, block number, version number, random
integer, and so on. Different from the common index
table, we assure that all records in our index table
differ from one another to prevent forgery of data
blocks and tags. By using this structure, especially
the index records { }, our CPDP scheme can also
support dynamic data operations. The proposed
structure can be readily incorporated into MAC-
based, ECC or RSA schemes. These schemes, built
from collision-resistance signatures (see Section 3.1)
and the random oracle model, have the shortest query
and response with public verifiability. They share
several common characters for the implementation of
the CPDP framework in the multiple clouds:
1) a file is split into × sectors and each block (
sectors) corresponds to a tag, so that the storage of
signature tags can be reduced by the increase of ;
2) a verifier can verify the integrity of file in random
sampling approach, which is of utmost importance
for large files; 3) these schemes rely on
homomorphic properties to aggregate data and tags
into a constant size response, which minimizes the
overhead of network communication; and 4) the
hierarchy structure provides a virtualization approach
to conceal the storage details of multiple CSPs.
2.4 Homomorphic Verifiable Response for CPDP
A homomorphism is a map: ℙ → ℚ between
two groups such that ( 1 ⊕ 2) = ( 1) ⊗ ( 2) for
all 1, 2 ∈ ℙ, where ⊕ denotes the operation in ℙ
and ⊗ denotes the operation in ℚ. This notation has
been used to define Homomorphic Verifiable Tags
(HVTs) in [2]: Given two values and for two
messages and anyone can combine them into a
value ′ corresponding to the sum of the messages

2242 | P a g e
+ . When provable data possession is considered
as a challenge-response protocol, we extend this
notation to the concept of Homomorphic Verifiable
Responses (HVR), which is used to integrate multiple
responses from the different CSPs in CPDP scheme
as follows:
Definition 2 (Homomorphic Verifiable Response): A
response is called homomorphic verifiable response
in a PDP protocol, if given two responses and
for two challenges and from two CSPs, there
exists an efficient algorithm to combine them into a
response corresponding to the sum of the
challenges ∪ . Homomorphic verifiable response
is the key technique of CPDP because it not only
reduces the communication bandwidth, but also
conceals the location of outsourced data in the
distributed cloud storage environment.
III. COOPERATIVE PDP SCHEME
In this section, we propose a CPDP scheme
for multicloud system based on the above-mentioned
structure and techniques. This scheme is constructed
on collision-resistant hash, bilinear map group,
aggregation algorithm, and homomorphic responses.
3.1 Notations and Preliminaries
Let ℍ = { } be a family of hash functions:
{0, 1} → {0, 1}∗ index by ∈ . We say that
algorithm has advantage in breaking collision
resistance of ℍ if Pr[ ( ) = ( 0, 1) : 0 ≠
1, ( 0) = ( 1)] ≥ , where the probability is
over the random choices of ∈ and the random
bits of . So that, we have the following definition.
Definition 3 (Collision-Resistant Hash): A hash
family ℍ is ( , )-collision-resistant if no -time
adversary has advantage at least in breaking
collision resistance of ℍ. We set up our system using
bilinear pairings proposed by Boneh and Franklin
[14]. Let and be two multiplicative groups
using elliptic curve conventions with a large prime
order . The function is a computable bilinear map
: × → with the following properties: for any
, ∈ and all , ∈ ℤ , we have 1) Bilinearity:
([ ] , [ ] ) = ( , ) ; 2) Non-degeneracy:
( , ) ∕= 1 unless or = 1; and 3) Computability:
( ,) is efficiently computable.
Definition 4 (Bilinear Map Group System): A bilinear
map group system is a tuple = ⟨ ,, , ⟩ composed
of the objects as described above.
3.2 Our CPDP Scheme
In our scheme (see Fig 3), the manager first
runs algorithm to obtain the public/private
key pairs for CSPs and users. Then, the clients
generate the tags of outsourced data by using
. Anytime, the protocol is performed
by a 5-move interactive proof protocol between a
verifier and more than one CSP, in which CSPs need
not to interact with each other during the verification
process, but an organizer is used to organize and
manage all CSPs.
This protocol can be described as follows: 1)
the organizer initiates the protocol and sends a
commitment to the verifier; 2) the verifier returns a
challenge set of random index-coefficient pairs to
the organizer; 3) the organizer relays them into each
in according to the exact position of each data
block; 4) each returns its response of challenge to
the organizer; and 5) the organizer synthesizes a final
response from received responses and sends it to the
verifier.
The above process would guarantee that the
verifier accesses files without knowing on which
CSPs or in what geographical locations their files
reside. In contrast to a single CSP environment, our
scheme differs from the common PDP scheme in two
aspects:
1) Tag aggregation algorithm: In stage of
commitment, the organizer generates a random ∈
ℤ and returns its commitment `1 to the verifier.
This assures that the verifier and CSPs do not obtain
the value of . Therefore, our approach guarantees
only the organizer can compute the final ′ by using
and ’ received from CSPs.
After ′ is computed, we need to transfer it to the
organizer in stage of “Response1”. In order to ensure
the security of transmission of data tags, our scheme
employs a new method, similar to the El Gamal
encryption, to encrypt the combination of tags
( , )∈ , that is, for = ∈ℤ and
=( , = )∈ 2, the cipher of message is
=( 1= , 2 = ⋅ ) and its decryption is performed
by = 2⋅ −
1 . Thus, we hold the equation
2) Homomorphic responses: Because of the
homomorphic property, the responses computed from
CSPs in a multi-cloud can be combined into a single
final response as follows: given a set of = ( ,
′ , , ) received from , let = Σ ∈ ,, the
organizer can compute
The commitment of is also computed by

2243 | P a g e
It is obvious that the final response received by the
verifier’s from multiple CSPs is same as that in one
simple CSP. This means that our CPDP scheme is
able to provide a transparent verification for the
verifiers. Two response algorithms, Response1 and
Response2, comprise an HVR: Given two responses
and for two challenges and from two
CSPs, i.e., = 1( ,{ } ∈ ,{ } ∈ ),
there exists an efficient algorithm to combine them
into a final response corresponding to the sum of
the challenges
∪ , that is,
= 1( ∪ ,{ } ∈ ∪ ,{ } ∈ ∪ )
= 2( , ).
For multiple CSPs, the above equation can be
extended to = 2 ({ }∈ ). More
importantly, the HVR is a pair of values = ( , , ),
which has a constant-size even for different
challenges.
IV. SECURITY ANALYSIS
We give a brief security analysis of our
CPDP construction. This construction is directly
derived from multi-prover zero-knowledge proof
system (MPZKPS), which satisfies following
properties for a given assertion, :
1) Completeness: whenever ∈ , there exists a
strategy for the provers that convinces the
verifier that this is the case;
2) Soundness: whenever ∕∈ , whatever strategy
the provers employ, they will not convince the
verifier that ∈ ;
3) Zero-knowledge: no cheating verifier can learn
anything other than the veracity of the statement.
According to existing IPS research, these
properties can protect our construction from various
attacks, such as data leakage attack (privacy leakage),
tag forgery attack (ownership cheating), etc. In
details, the security of our scheme can be analyzed as
follows:
4.1 Collision resistant for index-hash hierarchy
In our CPDP scheme, the collision resistant
of index hash hierarchy is the basis and prerequisite
for the security of whole scheme, which is described
as being secure in the random oracle model.
Although the hash function is collision resistant, a
successful hash collision can still be used to produce
a forged tag when the same hash value is reused
multiple times, e.g., a legitimate client modifies the
data or repeats to insert and delete data blocks of
outsourced data. To avoid the hash collision, the hash
value (3) , , which is used to generate the tag in
CPDP scheme, is computed from the set of values
{ }, , , { }. As long as there exists one bit
difference in these data, we can avoid the hash
collision. As a consequence, we have the following
theorem (see Appendix B):
Theorem 1 (Collision Resistant): The index-
hash hierarchy in CPDP scheme is collision resistant,
even if the client generates √2 ⋅ln1/(1− ) files with
the same file name and cloud name, and the client
repeats √2 +1⋅ln1/1− times to modify, insert and
delete data blocks, where the collision probability is
at least , ∈ ℤ , and ∣ ∣ = for ∈ .
4.2 Completeness property of verification
In our scheme, the completeness property
implies public verifiability property, which allows
anyone, not just the client (data owner), to challenge
the cloud server for data integrity and data
ownership without the need for any secret
information. First, for every available data-tag pair
( , ) ∈ ( , ) and a random challenge = ( ,
) ∈ , the verification protocol should be completed
with success probability according to the Equation
(3), that is,
In this process, anyone can obtain the owner’s public
key = ( , ℎ,1 = ℎ , 2 = ℎ ) and the
corresponding file parameter = ( , (1), ) from
TTP to execute the verification protocol, hence this is
a public verifiable protocol. Moreover, for different
owners, the secrets and hidden in their public key
are also different, determining that a success
verification can only be implemented by the real
owner’s public key. In addition, the parameter is
used to store the file-related information, so an owner
can employ a unique public key to deal with a large
number of outsourced files.
4.3 Zero-knowledge property of verification
The CPDP construction is in essence a
Multi-Prover Zero-knowledge Proof (MP-ZKP)
system, which can be considered as an extension of
the notion of
an interactive proof system (IPS). Roughly speaking,
in the scenario of MP-ZKP, a polynomial-time
bounded verifier interacts with several provers whose
computational powers are unlimited. According to a
Simulator model, in which every cheating verifier has
a simulator that can produce a transcript that “looks
like” an interaction between a honest prover and a

2244 | P a g e
cheating verifier, we can prove our CPDP
construction has Zero-knowledge property (see
Appendix C):
Theorem 2 (Zero-Knowledge Property): The
verification protocol ( , ) in CPDP scheme
is a computational zero-knowledge system under a
simulator model, that is, for every probabilistic
polynomial-time interactive machine +, there exists
a probabilistic polynomial-time algorithm ∗ such
that the ensembles (⟨Σ ∈ ( ( ), ( )) ↔
↔ ∗
⟩ ( , )) and ∗ ( , ) are
computationally indistinguishable. Zero-knowledge
is a property that achieves the CSPs’ robustness
against attempts to gain knowledge by interacting
with them. For our construction, we make use of the
zero-knowledge property to preserve the privacy of
data blocks and signature tags. Firstly, randomness is
adopted into the CSPs’ responses in order to resist the
data leakage attacks (see Attacks 1 and 3 in
Appendix A). That is, the random integer , is
introduced into the response , , i.e., ,�=��,�
+Σ(�,��)∈ �� ⋅ ��,� . This means that the
cheating verifier cannot obtain ��,� from ��,�
because he does not know the random integer ��,�.
At the same time, a random integer � is also
introduced to randomize the verification tag �, i.e.,
�′ ← (Π��∈ � �′ � ⋅ �−��)�. Thus, the tag �
cannot reveal to the cheating verifier in terms of
randomness.
4.4 Knowledge soundness of verification
For every data-tag pairs (�∗ , �∗ ) ∕∈
��(��, �), in order to prove nonexistence
of fraudulent �∗ and �∗ , we require that the
scheme satisfies the knowledge soundness property,
that is,
Where � is a negligible error. We prove that our
scheme has the knowledge soundness property by
using reduction to absurdity 1: we make use of �∗ to
construct a knowledge extractor ℳ, which gets the
common input (��, �) and rewindable black box
accesses to the prover �∗ , and then attempts to
break the computational Diffie-Hellman (CDH)
problem in �: given �,�1=��,�2=��∈ ��, output
��
∈ �.But it is unacceptable because the CDH
problem is widely regarded as an unsolved problem
in polynomial-time. Thus, the opposite direction of
the theorem also follows.
Theorem 3 (Knowledge Soundness Property): Our
scheme has (�, �′) knowledge soundness in random
oracle and rewind able knowledge extractor model
assuming the (�, �)-computational Diffie-Hellman
(CDH) assumption holds in the group � for �′ ≥ �.
Essentially, the soundness means that it is infeasible
to fool the verifier to accept false statements. Often,
the soundness can also be regarded as a stricter
notion of unforgeability for file tags to avoid cheating
the ownership. This means that the CSPs, even if
collusion is attempted, cannot be tampered with the
data or forge the data tags if the soundness property
holds. Thus, the Theorem 3 denotes that the CPDP
scheme can resist the tag forgery attacks to avoid
cheating the CSPs’ ownership.
V. PERFORMANCE EVALUATIONS
In this section, to detect abnormality in a
low overhead and timely manner, we analyze and
optimize the performance of CPDP scheme based on
the above scheme from two aspects: evaluation of
probabilistic queries and optimization of length of
blocks. To validate the effects of scheme, we
introduce a prototype of CPDP-based audit system
and present the experimental results.
5.1 Performance Analysis for CPDP Scheme
We present the computation cost of our
CPDP scheme in Table 3. We use [�] to denote the
computation cost of an exponent operation in �,
namely, ��, where � is a positive integer in ℤ � and
� ∈ � or ��. We neglect the computation cost of
algebraic operations and simple modular arithmetic
operations because they run fast enough [16]. The
most complex operation is the computation of a
bilinear map (⋅ ,⋅ ) between two elliptic points
(denoted as [�]).
Table 3: Comparison of computation overheads
between our CPDP scheme and non-cooperative
(trivial) scheme.
CPDP Scheme Trivial Scheme
KeyGen 3[�] 2[E]
TagGen (2� + )[�] (2� + �)[�]
Proof(�) �[�] + (� + ��+
1)[�]
�[�] + (� + ��
− �)[�]
Proof(V) 3[�] + (� + �)[�] 3�[�] + (� +
��)[�]
Then, we analyze the storage and
communication costs of our scheme. We define the
bilinear pairing takes the form: �(��) ×
�(��) → �∗ �� (The definition given here
is from [17], [18]), where � is a prime, � is a
positive integer, and � is the embedding degree (or
security multiplier). In this case, we utilize an
asymmetric pairing: �1×�2 → �� to replace the
symmetric pairing in the original schemes. In Table
3, it is easy to find that client’s computation
overheads are entirely irrelevant for the number of
CSPs. Further, our scheme has better performance
compared with non-cooperative approach due to the
total of computation overheads decrease 3(�−1)
times bilinear map operations, where � is the number
of clouds in a multicloud. The reason is that, before
the responses are sent to the verifier from � clouds,
the organizer has aggregate these responses into a

2245 | P a g e
response by using aggregation algorithm, so the
verifier only need to verify this response once to
obtain the final result.
Table 4: Comparison of communication overheads
between our CPDP and non-cooperative (trivial)
scheme.
CPDP Scheme Trivial Scheme
Commitment �2 cl2
Challenge 1 2tl0
2tl0Challenge 2 2tl0/c
Response1 sl0 + 2l1+ lT
(sl0 + l1+ lT)cResponse2 sl0 + l1+ lT
Without loss of generality, let the security parameter
� be 80 bits, we need the elliptic curve domain
parameters over �� with ∣ �∣ = 160 bits and � = 1
in our experiments. This means that the length of
integer is �0 = 2� in ℤ �. Similarly, we have �1 =
4� in �1, �2 = 24� in �2, and �� = 24� in ��
for the embedding degree � = 6. The storage and
communication cost of our scheme is shown in Table
4. The storage overhead of a file with ��(�) = 1�-
bytes is ��(�) = � ⋅ � ⋅ �0 + � ⋅ �1 =
1.04�-bytes for � = 103 and � = 50. The storage
overhead of its index table � is � ⋅ �0 = 20�-
bytes. We define the overhead rate as � = ��(�)
��(�) −1 = �1 �⋅ �0 and it should therefore
be kept as low as possible in order to minimize the
storage in cloud storage providers. It is obvious that a
higher � means much lower storage. Furthermore, in
the verification protocol, the communication
overhead of challenge is 2� ⋅ �0 = 40⋅ �-Bytes in
terms of the number of challenged blocks �, but its
response (response1 or response2) has a constant-size
communication overhead �⋅ �0+�1+�� ≈ 1.3�-
bytes for different file sizes. Also, it implies that
client’s communication overheads are of a fixed size,
which is entirely irrelevant for the number of CSPs.
5.2 Parameter Optimization
In the fragment structure, the number of
sectors per block � is an important parameter to
affect the performance of storage services and audit
services. Hence, we propose an optimization
algorithm for the value of s in this section. Our
results show that the optimal value can not only
minimize the computation and communication
overheads, but also reduce the size of extra storage,
which is required to store the verification tags in
CSPs. Assume � denotes the probability of sector
corruption. In the fragment structure, the choosing of
� is extremely important for improving the
performance of the CPDP scheme. Given the
detection probability � and the probability of sector
corruption � for multiple clouds � = {��}, the
optimal value of � can be computed by
min�∈ ℕ{log(1−�)/(Σ��∈ ��⋅ log(1−��))⋅ �/� +
�⋅ � + �}, where � ⋅ � + � ⋅ � + � denotes the
computational cost of verification protocol in PDP
scheme, �, �, � ∈ ℝ, and � is a constant. This
conclusion can be obtained from following process:
Let �� = � ⋅ � = ��(�)/ 0. According to above-
mentioned results, the sampling probability holds �
≥ (log(1−�)) / (��⋅ Σ��∈ ��⋅ log(1−��)) =
(log(1−�)) / �⋅ �⋅ Σ��∈ ��⋅ log(1−��). In order
to minimize the computational cost, we have
where �� denotes the proportion of data blocks in
the �-th CSP, �� denotes the probability of file
corruption in the �-th CSP. Since �/� is a monotone
decreasing function and � ⋅ � is a monotone
increasing function for � > 0, there exists an optimal
value of � ∈ ℕ in the above equation. The optimal
value of � is unrelated to a certain file from this
conclusion if the probability � is a constant value.
For instance, we assume a multi-cloud storage
involves three CSPs � = {�1, �2, �3} and the
probability of sector corruption is a constant value
{�1, �2, �3} = {0.01, 0.02, 0.001}. We set the
detection probability � with the range from 0.8 to 1,
e.g.,={0.8, 0.85, 0.9, 0.95, 0.99, 0.999}. For a file,
the proportion of data blocks is 50%, 30%, and 20%
in three CSPs, respectively, that is, �1 = 0.5, �2 =
0.3, and �3 = 0.2. In terms of Table 3, the
computational cost of CSPs can be simplified to � +
3�+9. Then, we can observe the computational cost
under different � and � in Figure 4. When � is less
than the optimal value, the computational cost
decreases evidently with the increase of �, and then
it raises when � is more than the optimal value.
More accurately, we show the influence of
parameters, ��⋅ �, �, and �, under different
detection probabilities in Table 6. It is easy to see that
computational cost rises with the increase of �.
Moreover, we can make sure the sampling number of
challenge with following conclusion:
Fig 3: Applying CPDP scheme in Hadoop
distributed file system (HDFS)
Given the detection probability �, the
probability of sector corruption �, and the number of
sectors in each block �, the sampling number of
verification protocol are a constant � = � ⋅

2246 | P a g e
�≥(log(1−�))/�⋅ Σ��∈ ��⋅ log(1−��) for
different files.
Table 6: The influence of parameters under
different detection probabilities � (� = {�1, �2,
�3} = {0.01, 0.02, 0.001}, {�1, �2, �3} = {0.5, 0.3,
0.2}).
P 0.8 0.85 0.9 0.95 0.99 0.999
S
z
.
w
142.
6
168.0
9
204.0
2
265.4
3
408.0
4
612.0
6
s 7 8 10 11 13 16
w 20 21 20 29 31 38
Finally, we observe the change of � under different
� and �. The experimental results are shown in
Table 5. It is obvious that the optimal value of �
rises with increase of � and with the decrease of �.
We choose the optimal value of � on the basis of
practical settings and system requisition. For NTFS
format, we suggest that the value of � is 200 and the
size of block is 4KBytes, which is the same as the
default size of cluster when the file size is less than
16TB in NTFS. In this case, the value of � ensures
that the extra storage doesn’t exceed 1% in storage
servers.
5.3 CPDP for Integrity Audit Services
Based on our CPDP scheme, we introduce
audit system architecture for outsourced data in
multiple clouds by replacing the TTP with a third
party auditor (TPA) in Figure 1. In this architecture,
this architecture can be constructed into a
visualization infrastructure of cloud-based storage
service. In Figure 5, we show an example of applying
our CPDP scheme in Hadoop distributed file system
(HDFS) 4, which a distributed, scalable, and portable
file system. HDFS’ architecture is composed of
NameNode and DataNode, where NameNode maps a
file name to a set of indexes of blocks and DataNode
indeed stores data blocks. To support our CPDP
scheme, the index-hash hierarchy and the metadata of
NameNode should be integrated together to provide
an enquiry service for the hash value (3)
�,� or index-
hash record ��. Hence, it is easy to replace the
checksum methods with the CPDP scheme for
anomaly detection in current HDFS. To validate the
effectiveness and efficiency of our proposed
approach for audit services, we have implemented a
prototype of an audit system. We simulated the audit
service and the storage service by using two local
IBM servers with two Intel Core 2 processors at 2.16
GHz and 500M RAM running Windows Server 2003.
These servers were connected via 250 MB/sec of
network bandwidth. Using GMP and PBC libraries,
we have implemented a cryptographic library upon
which our scheme can be constructed. This C library
contains approximately 5,200 lines of codes and has
been tested on both Windows and Linux platforms.
The elliptic curve utilized in the experiment is a
MNT curve, with base field size of 160 bits and the
embedding degree 6. The security level is chosen to
be 80 bits, which means ∣ �∣ = 160.
Fig 4: Experimental results under different file
size, sampling ratio, and sector number
Firstly, we quantify the performance of our
audit scheme under different parameters, such as file
size ��, sampling ratio �, sector number per block
�, and so on. Our analysis shows that the value of �
should grow with the increase of �� in order to
reduce computation and communication costs. Thus,
our experiments were carried out as follows: the
stored files were chosen from 10KB to 10MB; the
sector numbers were changed from 20 to 250 in terms
of file sizes; and the sampling ratios were changed
from 10% to 50%. The experimental results are
shown in the left side of Figure 6. These results
dictate that the computation and communication costs
(including I/O costs) grow with the increase of file
size and sampling ratio. Next, we compare the
performance of each activity in our verification
protocol. We have shown the theoretical results in
Table 4: the overheads of “commitment” and
“challenge” resemble one another, and the overheads
of “response” and “verification” resemble one
another as well. To validate the theoretical results, we
changed the sampling ratio � from 10% to 50% for a
10MB file and 250 sectors per block in a multi-cloud
�={�1, �2, �3}, in which the proportions of data
blocks are 50%, 30%, and 20% in three CSPs,
respectively. In the right side of Figure 6, our
experimental results show that the computation and
communication costs of “commitment” and
“challenge” are slightly changed along with the
sampling ratio, but those for “response” and
“verification” grows with the increase of the

2247 | P a g e
sampling ratio. Here, “challenge” and “response” can
be divided into two sub-processes: “challenge1” and
“challenge2”, as well as “response1” and
“response2”, respectively. Furthermore, the
proportions of data blocks in each CSP have greater
influence on the computation costs of “challenge”
and “response” processes. In summary, our scheme
has better performance than non-cooperative
approach.
VI. CONCLUSIONS
In this paper, we presented the construction
of an efficient PDP scheme for distributed cloud
storage. Based on homomorphic verifiable response
and hash index hierarchy, we have proposed a
cooperative PDP scheme to support dynamic
scalability on multiple storage servers. We also
showed that our scheme provided all security
properties required by zero knowledge interactive
proof system, so that it can resist various attacks even
if it is deployed as a public audit service in clouds.
Furthermore, we optimized the probabilistic query
and periodic verification to improve the audit
performance. Our experiments clearly demonstrated
that our approaches only introduce a small amount of
computation and communication overheads.
Therefore, our solution can be treated as a new
candidate for data integrity verification in
outsourcing data storage systems. Finally, it is still a
challenging problem for the generation of tags with
the length irrelevant to the size of data blocks. We
would explore such an issue to provide the support of
variable-length block verification.
REFERENCES
[1]. B. Sotomayor, R. S. Montero, I. M.
Llorente, and I. T. Foster, “Virtual
infrastructure management in private and
hybrid clouds,” IEEE Internet Computing,
vol. 13, no. 5, pp. 14–22, 2009.
[2]. G. Ateniese, R. C. Burns, R. Curtmola, J.
Herring, L. Kissner, Z. N. J. Peterson, and
D. X. Song, “Provable data possession at
untrusted stores,” in ACM Conference on
Computer and Communications Security, P.
Ning, S. D. C. di Vimercati, and P. F.
Syverson, Eds. ACM, 2007, pp. 598–609.
[3]. A. Juels and B. S. K. Jr., “Pors: proofs of
retrievability for large files,” in
ACMConference on Computer and
Communications Security, P. Ning, S. D. C.
di Vimercati, and P. F. Syverson, Eds.
ACM, 2007, pp. 584–597.
[4]. G. Ateniese, R. D. Pietro, L. V. Mancini,
and G. Tsudik, “Scalable and efficient
provable data possession,” in Proceedings of
the 4th international conference on Security
and privacy in communication netowrks,
SecureComm, 2008, pp. 1–10.
[5]. C. C. Erway, A. Küpç ü, C. Papamanthou,
and R. Tamassia, “Dynamic provable data
possession,” in ACM Conference on
Computer and Communications Security, E.
Al-Shaer, S. Jha, and A. D. Keromytis, Eds.
ACM, 2009, pp. 213–222.
[6]. H. Shacham and B. Waters, “Compact
proofs of retrievability,” in ASIACRYPT, ser.
Lecture Notes in Computer Science, J.
Pieprzyk, Ed., vol. 5350. Springer, 2008, pp.
90–107.
[7]. Q. Wang, C.Wang, J. Li, K. Ren, and W.
Lou, “Enabling public verifiability and data
dynamics for storage security in cloud
computing,” in ESORICS, ser. Lecture Notes
in Computer Science, M. Backes and P.
Ning, Eds., vol. 5789. Springer, 2009, pp.
355–370.
[8]. Y. Zhu, H. Wang, Z. Hu, G.-J. Ahn, H. Hu,
and S. S. Yau, “Dynamic audit services for
integrity verification of outsourced storages
in clouds,” in SAC, W. C. Chu, W. E. Wong,
M. J. Palakal, and C.-C. Hung, Eds. ACM,
2011, pp. 1550–1557.
[9]. K. D. Bowers, A. Juels, and A. Oprea,
“Hail: a high-availability and integrity layer
for cloud storage,” in ACM Conference on
Computer and Communications Security, E.
Al-Shaer, S. Jha, and A. D. Keromytis, Eds.
ACM, 2009, pp. 187–198.
[10]. Y. Dodis, S. P. Vadhan, and D. Wichs,
“Proofs of retrievability via hardness
amplification,” in TCC, ser. Lecture Notes
in Computer Science, O. Reingold, Ed., vol.
5444. Springer, 2009, pp. 109–127.
[11]. L. Fortnow, J. Rompel, and M. Sipser, “On
the power of multiprover interactive
protocols,” in Theoretical Computer
Science, 1988, pp. 156–161.
[12]. Y. Zhu, H. Hu, G.-J. Ahn, Y. Han, and S.
Chen, “Collaborative integrity verification
in hybrid clouds,” in IEEE Conference on
the 7th International Conference on
Collaborative Computing: Networking,
Applications and Worksharing,
CollaborateCom, Orlando Florida, USA,
October 15-18, 2011, pp. 197–206.
[13]. M. Armbrust, A. Fox, R. Griffith, A. D.
Joseph, R. H. Katz, A. Konwinski, G. Lee,
D. A. Patterson, A. Rabkin, I. Stoica, and M.
Zaharia, “Above the clouds: A berkeley
view of cloud computing,” EECS
Department, University of California,
Berkeley, Tech. Rep., Feb 2009.
[14]. D. Boneh and M. Franklin, “Identity-based
encryption from the weil pairing,” in
Advances in Cryptology (CRYPTO’2001),
vol. 2139 of LNCS, 2001, pp. 213–229.

2248 | P a g e
[15]. O. Goldreich, Foundations of Cryptography:
Basic Tools. Cambridge University Press,
2001.
[16]. P. S. L. M. Barreto, S. D. Galbraith, C.
O’Eigeartaigh, and M. Scott, “Efficient
pairing computation on supersingular
abelian varieties,” Des. Codes
Cryptography, vol. 42, no. 3, pp. 239–271,
2007.
[17]. J.-L. Beuchat, N. Brisebarre, J. Detrey, and
E. Okamoto, “Arithmetic operators for
pairing-based cryptography,” in CHES, ser.
Lecture Notes in Computer Science, P.
Paillier and I. Verbauwhede, Eds., vol. 4727.
Springer, 2007, pp. 239–255.
[18]. H. Hu, L. Hu, and D. Feng, “On a class of
pseudorandom sequences from elliptic
curves over finite fields,” IEEE Transactions
on Information Theory, vol. 53, no. 7, pp.
2598–2605, 2007.
[19]. A. Bialecki, M. Cafarella, D. Cutting, and O.
O’Malley, “Hadoop: A framework for
running applications on large clusters built
of commodity hardware,” Tech. Rep., 2005.
[Online]. Available:
http://lucene.apache.org/hadoop/
[20]. [20] E. Al-Shaer, S. Jha, and A. D.
Keromytis, Eds., Proceedings of the 2009
ACM Conference on Computer and
Communications Security, CCS 2009,
Chicago, Illinois, USA, November 9-13,
2009. ACM, 2009.
About The Authors
B.SHANMUKHI, received his
B.Tech degree in Information
Technology from JNTU,
Anantapur, India, in 2010.
Currently pursuing M.Tech in
computer science and engineering
at Dr.KVSRCEW Institute of Technology, Kurnool,
India.
D.SATYANARAYANA, received
his M.Tech in Computer Science
in MISTE from Jawaharlal Nehru
Technological University,
Anantapur, India.in 2011. He is an
Asst.Professor at
DR.K.V.S.R.C.E.W, Kurnool,
India

Mn3422372248

More Related Content

What's hot

Viewers also liked

Similar to Mn3422372248

Recently uploaded

Mn3422372248