Privacy-Preserving Public Auditing for Regenerating-Code-Based Cloud Storage

IEEE TRANSACTIONS ON INFORMATION FORENSICS AND SECURITY, VOL. 10, NO. 7, JULY 2015 1513
Privacy-Preserving Public Auditing for
Regenerating-Code-Based Cloud Storage
Jian Liu, Kun Huang, Hong Rong, Huimei Wang, and Ming Xian
Abstract—To protect outsourced data in cloud storage against
corruptions, adding fault tolerance to cloud storage together
with data integrity checking and failure reparation becomes
critical. Recently, regenerating codes have gained popularity due
to their lower repair bandwidth while providing fault tolerance.
Existing remote checking methods for regenerating-coded data
only provide private auditing, requiring data owners to always
stay online and handle auditing, as well as repairing, which
is sometimes impractical. In this paper, we propose a public
auditing scheme for the regenerating-code-based cloud storage.
To solve the regeneration problem of failed authenticators in
the absence of data owners, we introduce a proxy, which is
privileged to regenerate the authenticators, into the traditional
public auditing system model. Moreover, we design a novel public
verifiable authenticator, which is generated by a couple of keys
and can be regenerated using partial keys. Thus, our scheme can
completely release data owners from online burden. In addition,
we randomize the encode coefficients with a pseudorandom
function to preserve data privacy. Extensive security analysis
shows that our scheme is provable secure under random oracle
model and experimental evaluation indicates that our scheme
is highly efficient and can be feasibly integrated into the
regenerating-code-based cloud storage.
Index Terms—Cloud storage, regenerating codes, public audit,
privacy preserving, authenticator regeneration, proxy, privileged,
provable secure.
I. INTRODUCTION
CLOUD storage is now gaining popularity because it
offers a flexible on-demand data outsourcing service
with appealing benefits: relief of the burden for storage
management, universal data access with location
independence, and avoidance of capital expenditure on
hardware, software, and personal maintenances, etc., [1].
Nevertheless, this new paradigm of data hosting service also
brings new security threats toward users data, thus making
individuals or enterprisers still feel hesitant.
It is noted that data owners lose ultimate control over the
fate of their outsourced data; thus, the correctness, availability
and integrity of the data are being put at risk. On the one
hand, the cloud service is usually faced with a broad range
Manuscript received August 26, 2014; revised December 19, 2014
and March 9, 2015; accepted March 9, 2015. Date of publication
March 25, 2015; date of current version June 2, 2015. The associate editor
coordinating the review of this manuscript and approving it for publication
was Prof. Nitesh Saxena.
The authors are with the State Key Laboratory of Complex
Electromagnetic Environment Effects on Electronic and Information
System, National University of Defense Technology, Changsha 410073,
China (e-mail: ljabc730@gmail.com; khuangresearch923@gmail.com;
ronghong01@gmail.com; freshcdwhm@163.com; qwertmingx@sina.com).
Color versions of one or more of the figures in this paper are available
online at http://ieeexplore.ieee.org.
Digital Object Identifier 10.1109/TIFS.2015.2416688
of internal/external adversaries, who would maliciously delete
or corrupt users’ data; on the other hand, the cloud service
providers may act dishonestly, attempting to hide data loss
or corruption and claiming that the files are still correctly
stored in the cloud for reputation or monetary reasons. Thus it
makes great sense for users to implement an efficient protocol
to perform periodical verifications of their outsourced data to
ensure that the cloud indeed maintains their data correctly.
Many mechanisms dealing with the integrity of outsourced
data without a local copy have been proposed under different
system and security models up to now. The most signifi-
cant work among these studies are the PDP (provable data
possession) model and POR (proof of retrievability) model,
which were originally proposed for the single-server scenario
by Ateniese et al. [2] and Juels and Kaliski [3], respectively.
Considering that files are usually striped and redundantly
stored across multi-servers or multi-clouds, [4]–[10] explore
integrity verification schemes suitable for such multi-servers
or multi-clouds setting with different redundancy schemes,
such as replication, erasure codes, and, more recently,
regenerating codes.
In this paper, we focus on the integrity verification prob-
lem in regenerating-code-based cloud storage, especially
with the functional repair strategy [11]. Similar studies have
been performed by Chen et al. [7] and Chen and Lee [8]
separately and independently. [7] extended the single-server
CPOR scheme (private version in [12]) to the regenerating-
code-scenario; [8] designed and implemented a data integrity
protection (DIP) scheme for FMSR [13]-based cloud storage
and the scheme is adapted to the thin-cloud setting.1 However,
both of them are designed for private audit, only the data
owner is allowed to verify the integrity and repair the faulty
servers. Considering the large size of the outsourced data and
the user’s constrained resource capability, the tasks of auditing
and reparation in the cloud can be formidable and expensive
for the users [14]. The overhead of using cloud storage should
be minimized as much as possible such that a user does not
need to perform too many operations to their outsourced data
(in additional to retrieving it) [15]. In particular, users may not
want to go through the complexity in verifying and reparation.
The auditing schemes in [7] and [8] imply the problem that
users need to always stay online, which may impede its
adoption in practice, especially for long-term archival storage.
To fully ensure the data integrity and save the users’
computation resources as well as online burden, we propose
1Indicating that the cloud servers are only provided with the RESTful
interface.
1556-6013 © 2015 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission.
See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.

1514 IEEE TRANSACTIONS ON INFORMATION FORENSICS AND SECURITY, VOL. 10, NO. 7, JULY 2015
a public auditing scheme for the regenerating-code-based
cloud storage, in which the integrity checking and regeneration
(of failed data blocks and authenticators) are implemented
by a third-party auditor and a semi-trusted proxy separately
on behalf of the data owner. Instead of directly adapting the
existing public auditing scheme [12] to the multi-server
setting, we design a novel authenticator, which is more
appropriate for regenerating codes. Besides, we “encrypt” the
coefficients to protect data privacy against the auditor, which
is more lightweight than applying the proof blind technique
in [14] and [15] and data blind method in [16]. Several
challenges and threats spontaneously arise in our new system
model with a proxy (Section II-C), and security analysis shows
that our scheme works well with these problems. Specifically,
our contribution can be summarized by the following aspects:
• We design a novel homomorphic authenticator based on
BLS signature [17], which can be generated by a couple
of secret keys and verified publicly. Utilizing the linear
subspace of the regenerating codes, the authenticators can
be computed efficiently. Besides, it can be adapted for
data owners equipped with low end computation devices
(e.g. Tablet PC etc.) in which they only need to sign the
native blocks.
• To the best of our knowledge, our scheme is the first to
allow privacy-preserving public auditing for regenerating-
code-based cloud storage. The coefficients are masked
by a PRF (Pseudorandom Function) during the Setup
phase to avoid leakage of the original data. This method
is lightweight and does not introduce any computational
overhead to the cloud servers or TPA.
• Our scheme completely releases data owners from online
burden for the regeneration of blocks and authenticators
at faulty servers and it provides the privilege to a proxy
for the reparation.
• Optimization measures are taken to improve the flexibility
and efficiency of our auditing scheme; thus, the storage
overhead of servers, the computational overhead of the
data owner and communication overhead during the audit
phase can be effectively reduced.
• Our scheme is provable secure under random oracle
model against adversaries illustrated in Section II-C.
Moreover, we make a comparison with the state of the
art and experimentally evaluate the performance of our
scheme.
The rest of this paper is organized as follows: Section II
introduces some preliminaries, the system model, threat model,
design goals and formal definition of our auditing scheme.
Then we provide the detailed description of our scheme
in Section III; Section IV analyzes its security and Section V
evaluates its performance. Section VI presents a review of the
related work on the auditing schemes in cloud storage. Finally,
we conclude this paper in Section VII.
II. PRELIMINARIES AND PROBLEM STATEMENT
A. Notations and Preliminaries
1) Regenerating Codes: Regenerating codes are first intro-
duced by Dimakis et al. [18] for distributed storage to
reduce the repair bandwidth. Viewing cloud storage to be
a collection of n storage servers, data file F is encoded
and stored redundantly across these servers. Then F can
be retrieved by connecting to any k-out-of-n servers, which
is termed the MDS2-property. When data corruption at a
server is detected, the client will contact healthy servers
and download β bits from each server, thus regener-
ating the corrupted blocks without recovering the entire
original file. Dimakis et al. [18] showed that the repair
bandwidth γ = β can be significantly reduced with ≥ k.
Furthermore, they analyzed the fundamental tradeoff between
the storage cost α and the repair bandwidth γ , then
presented two extreme and practically relevant points on the
optimal tradeoff curve: the minimum bandwidth regenerat-
ing (MBR) point, which represents the operating point with
the least possible repair bandwidth, and the minimum storage
regenerating (MSR) point, which corresponds to the least
possible storage cost on the servers. Denoted by the parameter
tuple (n, k, , α , γ ), we obtain:
(αMSR, γMSR) =
|F|
k
,
|F|
k( − k + 1)
(1)
(αM BR, γM BR) =
2|F|
2k − k2 + k
,
2|F|
2k − k2 + k
(2)
Moreover, according to whether the corrupted blocks can be
exactly regenerated, there are two versions of repair strategy:
exact repair and functional repair [11]. Exact repair strategy
requires the repaired server to store an exact replica of
the corrupted blocks, while functional repair indicates that
the newly generated blocks are different from the corrupted
ones with high probability. As one basis of our work, the
functional repair regenerating codes are non-systematic and
do not perform as well for read operation as systematic codes,
but they really make sense for the scenario in which data repair
occurs much more often than read, such as regulatory storage,
data escrow and long-term archival storage [7].
The regenerating codes with functional repair strategy
can be achieved using the random network coding.
Given a file represented by m blocks {wi}m
i=1, with each
wi = (wi1, wi2, . . . , wis), where wij ’s belong to the finite
field GF(2ω) and are referred to as symbols, the data
owner then generates coded blocks from these native blocks;
specifically, m coding coefficients {εi}m
i=1 are chosen randomly
from GF(2ω) and computed out v = m
i=1 εi · wi, where all
algebraic operations work over GF(2ω). When the size of
the finite field GF(2ω), where the coefficients are drawn, is
large enough, any m coded blocks will be linearly independent
with high probability [19]; thus, the original file can be
reconstructed from any m coded blocks by solving a set
of m equations. The coded blocks will be distributed across
n storage servers, with each server storing α blocks. Any
k-out-of-n servers can be used to recover the original data
file when the inequality kα m is maintained, thus satis-
fying the MDS property. When the periodic auditing process
detect data corruption at one server, the repair procedure will
contact servers and obtain β blocks from each to regenerate
2Maximum Distance Separable.

LIU et al.: PRIVACY-PRESERVING PUBLIC AUDITING FOR REGENERATING-CODE-BASED CLOUD STORAGE 1515
Fig. 1. An example of functional repair regenerating code with parameters
(n = 3, k = 2, = 2, α = 2, β = 1). The data owner computes
six coded blocks as random linear combinations of the native three blocks,
and distributes them across three servers. When Server 1 gets corrupted, the
proxy contacts the remaining two servers and retrieves one block (obtained
also by linear combination) from each, then it linearly combines them to
generate two new coded blocks. Finally, the new coded blocks are sent to a
new healthy server. The resulting storage system turns out to satisfy the (3, 2)
MDS property.
the corrupted α blocks. Fig.1 shows an example of functional
repair regenerating code. The guidelines for choosing
parameter tuple (n, k, , α, β) can be found in [7] and [18].
2) Linear Subspace From Regenerating Code: As
mentioned above, each coded block represents the linear
combination of m native blocks in the functional repair
regenerating code scenario. Thus, we can generate a linear
subspace with dimension m for file F in the following
way [20]:
Before encoding, F is split into m blocks, and the orig-
inal m s-dimensional vectors (or blocks indistinguishably)
{wi ∈ GF(p)s}m
i=1 are properly augmented as:
wi = (wi1, wi2, . . . , wis,
m
0, . . . , 0, 1
i
, 0, . . . , 0) ∈ GF(p)s+m
(3)
for each symbol, wij ∈ GF(p). Eq.(3) shows that each
original block wi is appended with the vector of length m
containing a single ‘1’ in the ith position and is otherwise
zero.
Then, the augmented vectors are encoded into nα coded
blocks. Specifically, they are linearly combined and generate
coded blocks with randomly chosen coefficients εi ∈ GF(p).
v =
m
i=1
εiwi ∈ GF(p)s+m
(4)
Obviously, the latter additional m elements in the vector v
keep track of the ε values of the corresponding blocks, i.e.,
v = (vi1, vi2, . . . , vis
data
, ε1, . . . , εm
coef f icients
) ∈ GF(p)s+m
(5)
where (vi1, vi2, . . . , vis ) are the data, and the remaining
elements indicate the coding coefficients. Notice that the
blocks regenerated in the repair phase also meet the form
of Eq.(5), thus we can construct a linear subspace V of
m-dimension by spanning the base vectors w1, w2, . . . , wm; all
valid coded blocks appended with coding coefficients would
belong to subspace V .
Under the construction of linear subspace V , we can
generate tags for vectors in V efficiently, i.e., we only
need to sign the m base vectors in the beginning.
Fig. 2. The system model.
Such a signature scheme can be viewed as similar with
signing on the subspace V [20]. We will further introduce this
procedure and its better performance in the following section.
3) Bilinear Pairing Map: Let G and GT be multiplicative
cyclic groups of the same large prime order p. A bilinear
pairing map e : G × G → GT is a map with the following
properties:
• Bilinear: e(ua, vb) = e(u, v)ab for all u, v ∈ G and
a, b ∈ Z∗
p, this property can be stretch to the multiplica-
tive property that e(u1 · u2, v) = e(u1, v) · e(u2, v) for
any u1, u2 ∈ G;
• Non-degenerate: e(g, g) generates the group GT when
g is generator of group G;
• Computability: There exists an efficient algorithm to
compute e(u, v) for all u, v ∈ G.
Such a bilinear map e can be constructed by the modified
Weil [21] or Tate pairings [22] on elliptic curves.
B. System Model
We consider the auditing system model for Regenerating-
Code-based cloud storage as Fig.2, which involves four
entities: the data owner, who owns large amounts of data
files to be stored in the cloud; the cloud, which are
managed by the cloud service provider, provide storage service
and have significant computational resources; the third party
auditor (TPA), who has expertise and capabilities to conduct
public audits on the coded data in the cloud, the TPA is trusted
and its audit result is unbiased for both data owners and cloud
servers; and a proxy agent, who is semi-trusted and acts on
behalf of the data owner to regenerate authenticators and data
blocks on the failed servers during the repair procedure. Notice
that the data owner is restricted in computational and storage
resources compared to other entities and may becomes off-line
even after the data upload procedure. The proxy, who would
always be online, is supposed to be much more powerful
than the data owner but less than the cloud servers in terms
of computation and memory capacity. To save resources as
well as the online burden potentially brought by the periodic
auditing and accidental repairing, the data owners resort to

the TPA for integrity verification and delegate the reparation
to the proxy.
Compared with the traditional public auditing system model,
our system model involves an additional proxy agent. In order
to reveal the rationality of our design and make our following
description in Section III to be more clear and concrete,
we consider such a reference scenario: A company employs
a commercial regenerating-code-based public cloud and
provides long-term archival storage service for its staffs,
the staffs are equipped with low end computation devices
(e.g., Laptop PC, Tablet PC, etc.) and will be frequently
off-line. For public data auditing, the company relies on a
trusted third party organization to check the data integrity;
Similarly, to release the staffs from heavy online burden for
data and authenticator regeneration, the company supply a
powerful workstation (or cluster) as the proxy and provide
proxy reparation service for the staffs’ data.
C. Threat Model
Apparently, threat in our scheme comes from the
compromised servers, curious TPA and semi-trusted proxy.
In terms of compromised servers, we adopt a mobile
adversary under the multi-servers setting, similar with [5],
who can compromise at most n −k out of the n servers in any
epoch, subject to the (n, k)-MDS fault tolerance requirement.
To avoid creeping-corruption which may lead to the unrecover-
able of the stored data, the repair procedure will be triggered
at the end of each epoch once some corruption is detected.
There are some differences in our model compared with
the one in [5]: First, the adversary can corrupt not only
the data blocks but also the coding coefficients stored
in the compromised servers; and second, the compromised
server may act honestly for auditing but maliciously for
reparation. We assume that some blocks stored in server Si
are corrupted at some time, the adversary may launch the
following attacks in order to prevent the auditor from detecting
the corruption:
• Replace Attack: The server Si may choose another valid
and intact pair of data block and authenticator to replace
the corrupted pair, or even simply store the blocks
and authenticators at another healthy server Sj , thus
successfully passing the integrity check.
• Replay Attack: The server may generate the proof from
an old coded block and corresponding authenticator to
pass the verification, thus leading to a reduction of data
redundancy to the point that the original data becomes
unrecoverable.3
• Forge Attack: The server may forge an authenticator for
modified data block and deceive the auditor.
• Pollution Attack: The server may use correct data to avoid
detection in the audit procedure but provide corrupted
data for repairing; thus the corrupted data may pollute all
the data blocks after several epoches.
With respect to the TPA, we assume it to be honest
but curious. It performs honestly during the whole auditing
procedure but is curious about the data stored in the cloud.
3We refer readers to [7] for the details of such replay attack.
The proxy agent in our system model is assumed to be
semi-trusted. It will not collude with the servers but might
attempt to forge authenticators for some specified invalid
blocks to pass the following verification.
D. Design Goals
To correctly and efficiently verify the integrity of data and
keep the stored file available for cloud storage, our proposed
auditing scheme should achieve the following properties:
• Public Auditability: To allow TPA to verify the intactness
of the data in the cloud on demand without introducing
additional online burden to the data owner.
• Storage Soundness: To ensure that the cloud server can
never pass the auditing procedure except when it indeed
manage the owner’s data intact.
• Privacy Preserving: To ensure that neither the auditor nor
the proxy can derive users’ data content from the auditing
and reparation process.
• Authenticator Regeneration: The authenticator of the
repaired blocks can be correctly regenerated in the
absence of the data owner.
• Error Location: To ensure that the wrong server can be
quickly indicated when data corruption is detected.
E. Definitions of Our Auditing Scheme
Our auditing scheme consists of three procedures:
Setup, Audit and Repair. Each procedure contains certain
polynomial-time algorithms as follows:
Setup: The data owner maintains this procedure to initialize
the auditing scheme.
KeyGen(1κ) → (pk, sk): This polynomial-time algorithm
is run by the data owner to initialize its public and secret
parameters by taking a security parameter κ as input.
Degelation(sk) → (x): This algorithm represents the
interaction between the data owner and proxy. The data owner
delivers partial secret key x to the proxy through a secure
approach.
SigAnd BlockGen(sk, F) → ( , , t): This polynomial
time algorithm is run by the data owner and takes the secret
parameter sk and the original file F as input, and then outputs
a coded block set , an authenticator set and a file tag t.
Audit: The cloud servers and TPA interact with one another
to take a random sample on the blocks and check the data
intactness in this procedure.
Challenge(Finf o) → (C): This algorithm is performed by
the TPA with the information of the file Finf o as input and a
challenge C as output.
Proof Gen(C, , ) → (P): This algorithm is run by each
cloud server with input challenge C, coded block set and
authenticator set , then it outputs a proof P.
Veri f y(P, pk, C) → (0, 1): This algorithm is run by TPA
immediately after a proof is received. Taking the proof P,
public parameter pk and the corresponding challenge C as
input, it outputs 1 if the verification passed and 0 otherwise.
Repair: In the absence of the data owner, the proxy interacts
with the cloud servers during this procedure to repair the
wrong server detected by the auditing process.

Fig. 3. The sequence chart of our scheme.
ClaimFor Rep(Finf o) → (Cr ): This algorithm is similar
with the Challenge() algorithm in the Audit phase, but
outputs a claim for repair Cr.
GenFor Rep(Cr, , ) → (B A): The cloud servers run
this algorithm upon receiving the Cr and finally output the
block and authenticators set B A with another two inputs , .
Block AndSigReGen(Cr, B A) → ( , , ⊥): The proxy
implements this algorithm with the claim Cr and responses
B A from each server as input, and outputs a new coded block
set and authenticator set if successful, outputting ⊥ if
otherwise.
The sequence chart of our scheme is shown in Fig.3.
III. THE PROPOSED SCHEME
In this section we start from an overview of our auditing
scheme, and then describe the main scheme and discuss how
to generalize our privacy-preserving public auditing scheme.
Furthermore, we illustrate some optimized methods to improve
its performance.
A. Overview
Although [7], [8] introduced private remote data checking
schemes for regenerating-code-based cloud storage, there are
still some other challenges for us to design a public auditable
version.
First, although a direct extension of the techniques
in [2], [12], and [15] can realize public verifiability in
the multi-servers setting by viewing each block as a set
of segments and performing spot checking on them, such
a straightforward method makes the data owner generate
tags for all segments independently, thus resulting in high
computational overhead. Considering that data owners com-
monly maintains limited computation and memory capacity,
it is quite significant for us to reduce those overheads.
Second, unlike cloud storage based on traditional erasure
code or replication, a fixed file layout does not exist
in the regenerating-code-based cloud storage. During the
repair phase, it computes out new blocks, which are
totally different from the faulty ones, with high probability.
Thus, a problem arises when trying to determine how to
regenerate authenticators for the repaired blocks. A direct
solution, which is adopted in [7], is to make data owners
handle the regeneration. However, this solution is not prac-
tical because the data owners will not always remain online
through the life-cycle of their data in the cloud, more
typically, it becomes off-line even after data uploading.
Another challenge is brought in by the proxy in our system
model (see Section II-C).
The following parts of this section shows our solution to
the problems above. First, we construct a BLS-based [17]
authenticator, which consists of two parts for each segment
of coded blocks. Utilizing its homomorphic property and the
linearity relation amongst the coded blocks, the data owner is
able to generate those authenticators in a new method, which
is more efficient compared to the straightforward approach.
Our authenticator contains the information of encoding
coefficients to avoid data pollution in the reparation with
wrong coefficients. To reduce the bandwidth cost during the
audit phase, we perform a batch verification over all α blocks
at a certain server rather than checking the integrity of each
block separately as [7] does. Moreover, to make our scheme
secure against the replace attack and replay attack, information
about the indexes of the server, blocks, and segments are
all embedded into the authenticator. Besides, our primitive
scheme can be easily improved to support privacy-preserving
through the masking of the coding coefficients with
a keyed PRF.
All the algebraic operations in our scheme work over the
field GF(p) of modulo p, where p is a large prime (at least
80 bits).4
B. Construction of Our Auditing Scheme
Considering the regenerating-code-based cloud storage with
parameters (n, k, , α, β), we assume β = 1 for simplicity. Let
G and GT be multiplicative cyclic groups of the same large
prime order p, and e : G × G → GT be a bilinear pairing
map as introduced in the preliminaries. Let g be a generator
of G and H(·) : {0, 1}∗ → G be a secure hash function that
maps strings uniformly into group G. Table I list the primary
notations and terminologies used in our scheme description.
Setup: The audit scheme related parameters are initialized
in this procedure.
KeyGen(1κ) → (pk, sk): The data owner generates
a random signing key pair (spk, ssk), two random elements
x, y
R
←− Zp and computes pkx ← gx, pky ← gy. Then the
secret parameter is sk = (x, y, ssk) and the public parameter
is pk = (pkx, pky, spk).
Delegation(sk) → (x): The data owner sends encrypted x
to the proxy using the proxy’s public key, then the proxy
decrypts and stores it locally upon receiving.
SigAnd BlockGen(sk, F) → ( , , t): The data owner
uniformly chooses a random identifier I D
R
←− {0, 1}∗,
a random symbol u
R
←− G, one set = {w1, w2, . . . wm}
4Analysis in [23] showed that the successful decoding probability for the
functional repair regenerating code over G F(2ω) and over G F(p) is similar
while the two fields have about the same order (e.g., when ω = 8, p is 257).

TABLE I
SOME PRIMARY NOTATIONS IN OUR SCHEME DESCRIPTION
Fig. 4. An example with m = 3 for the SigAndBlockGen(·) algorithm.
with elements wi
R
←− G, and a file tag t =
(I D||u||w1|| . . .||wm)||Sigssk(I D||u||w1|| . . .||wm) for F.
Sig() means a standard signature scheme. Recall that the
original file F is split into m blocks, {wi }m
i=1; the client
computes and stores nα coded blocks amongst n cloud servers.
Viewing each segment of the blocks as a single symbol for
simplicity, our signature is generated simultaneously with the
encoding process as follows (Fig.4 shows an instance of this
algorithm with m = 3.):
Augmentation: The data owner properly augments the
native m blocks as Eq.(3).
Signing for Native Blocks: The data owner views the
data parts of the augmented blocks as a set of segments and
computes authenticator for each segment, i.e.,
σ∗∗
joko
= uw joko ·
m
λ=1
w
w jo(s+λ)
λ
y
= uw joko · wjo
y
(6)
where 1 ≤ jo ≤ m, 1 ≤ ko ≤ s.
Combination and Aggregation: The data owner randomly
chooses m elements {εijλ}m
λ=1 from GF(p) to be coefficients
and linearly combines the augmented native blocks to generate
coded blocks vij (1 ≤ i ≤ n, 1 ≤ j ≤ α), as follows:
vij =
m
λ=1
εijλwλ ∈ GF(p)s+m
(7)
and apparently each symbol can be obtained by
vijk =
m
λ=1
εijλwλk ∈ GF(p) (8)
with 1 ≤ k ≤ s + m. Then we can get the aggregated tags as:
σ∗
ijk =
m
λ=1
(σ∗∗
λk )εijλ
= uvijk ·
m
λ=1
w
εijλ
λ
y
(9)
with 1 ≤ k ≤ s.
Authenticator Generation: The data owner generates an
authenticator for vijk as:
σijk = H(I D||i|| j||k)x
· σ∗
ijk
= H(I D||i|| j||k)x
uvijk
m
λ=1
w
εijλ
λ
y
(10)
where the symbols i, j, k denote the index of the server, the
index of the block at a server and the index of a segment in
a certain coded block.
Then, authenticator set = { i = {σijk}1≤ j≤α
1≤k≤s
}1≤i≤n and
coded block set = { i = {vij }1≤ j≤α}1≤i≤n are obtained.
Finally the data owner distributes these two sets across n cloud
servers, specifically sending { i, i, t} to server i and delete
them from local storage.
Audit: For each of the n servers, TPA verifies the
possession of α coded blocks by randomly checking samples
of segments of every block and performing a batch verification.
Challenge(Finf o) → (C): Taking the information of file
Finf o as input, TPA randomly generates a c-element set
Qi = {(k∗
ξ , a∗
ξ )}1≤ξ≤c for server i (1 ≤ i ≤ n) with the
sampled segment indexes k∗ ∈R [1, s] and corresponding
randomness a∗ R
←− GF(p). Furthermore, to execute a
batch auditing, TPA picks another random symbol set
i = {aξ }1≤ξ≤α with each aξ
R
←− GF(p). TPA sends
C = {Qi , i} to the server i.
Proof Gen(C, , ) → (P): Upon receiving the challenge
C = {Qi , i}, server i first computes
μij =
c
τ=1
a∗
τ vijk∗
τ
, σij =
c
τ=1
σijk∗
τ
a∗
τ (11)
for coded block j ∈ [1, α] stored on itself, and then it
generates an aggregated proof using i , i.e.,
μi =
α
j=1
aj μij , σi =
α
j=1
σij
aj (12)
For the coefficients checking, server i generates m symbols
as
ρiλ =
⎛
⎝
α
j=1
aj εijλ
⎞
⎠ ·
c
τ=1
a∗
τ (13)
where 1 ≤ λ ≤ m. Let i = {ρi1, ρi2, . . . , ρim}.

Thus the ith server responds to the TPA with proof
P = {μi, σi , i, t}.
V eri f y(P, pk, C) → (0, 1): Upon receiving a proof P
from server i, TPA uses spk to verify the signature on t to
check whether or not it is the delegated file that needs auditing,
retrieves u and = {w1, w2, . . . wm} if successful and aborts
if otherwise.
Then, TPA computes:
RH S = e
⎛
⎝
α
j=1
c
τ=1
H
aja∗
τ
ijk∗
τ
, pkx
⎞
⎠ · e uμi
, pky (14)
where Hijk∗
τ
= H(I D||i|| j||k∗
τ). Finally, TPA verify if the
following equation holds:
e
m
λ=1
w
−ρiλ
λ , pky · e (σi, g)
?
= RH S (15)
if so, output 1; otherwise, output 0.
Repair: As previously introduced, the data owner empow-
ers a proxy to take charge of faulty server reparation and
moves off-line once it completes its upload procedure. When
TPA detects a server corruption, an alert will be sent to
proxy and then a repair procedure will be triggered. Moreover,
to avoid pollution attack, the blocks downloaded from
servers will be first verified before they are used for block
regeneration. Without loss of generality, we assume that the
TPA has identified a certain faulty server η.
ClaimFor Rep(Finf o) → (Cr ): The proxy randomly
contacts healthy servers {iθ}1≤θ≤ . For each server
i ∈ {iθ }1≤θ≤ , the proxy draws a coefficient set i =
{aξ }1≤ξ≤α with aξ ∈ GF(p). Then it sends claim Cr = { i}
to server i.
GenFor Rep(Cr, , ) → (B A): When server i receives
the repair claim Cr , it linearly combines α local coded blocks
into one single block and then generates tags for verification:
vi =
α
j=1
ajvij , σik =
α
j=1
σijk
aj (16)
where (1 ≤ k ≤ s). Then server i responds with the block and
authenticators set B Ai = vi, {σik }1≤k≤s .
Block AndSigReGen(Cr, B A) → ( , , ⊥): Before
regeneration, the proxy will execute batch verification
for the received blocks. By viewing each vi as
(vi1, . . . , vis, εi1, . . . , εim) consulting Eq.(5), the proxy
verifies whether the k following equations hold,
e(
i∈{iθ }
σik , g)
?
= e
⎛
⎝
i∈{iθ }
α
j=1
H
aj
ijk, pkx
⎞
⎠
· e u i∈{iθ } vik
, pky
· e
m
λ=1
w
i∈{iθ } εiλ
λ , pky (17)
where 1 ≤ k ≤ s and Hijk = H(I D||i|| j||k). If verification
fails, which means that some of the servers connected are
malicious for repair, proxy aborts the reparation; otherwise,
it continues to generate new coded blocks and authenticators.
Assuming that the repaired coded blocks would be stored at
a new added server η , the proxy rebuilds α blocks as follows:
The proxy picks up random coefficients zi
R
←− GF(p) for
each i ∈ {iθ}1≤θ≤ and then computes a linear combination
vη j =
i∈{iθ }
zivi (18)
and regenerate authenticators for each segment,
ση jk = T x
jk ·
i∈{iθ }
(σik )zi
(19)
where 1 ≤ j ≤ α, 1 ≤ k ≤ s and the transform operator
Tjk denotes
Tjk =
H(I D||η || j||k)
i∈{iθ }
α
j∗=1 H(I D||i|| j∗||k)aj∗ zi
(20)
Finally, the regenerated block set = {vη j }1≤ j≤α and
authenticator set = {ση jk} 1≤k≤s
1≤ j≤α
are sent to server η . Thus,
the repair process is finished.
Example Description: To make our contribution easier to
follow, we briefly introduce our above scheme under the
reference scenario in Section II-B: The staffs (i.e., cloud users)
first generate their public and private keys, and then delegate
the authenticator regeneration to a proxy (a cluster or powerful
workstation provided by the company) by sharing partial
private key. After producing encoded blocks and
authenticators, the staffs upload and distribute them to
the cloud servers. Since that the staffs will be frequently
off-line, the company employs a trust third party (the TPA)
to interact with the cloud and perform periodical verification
on the staffs’ data blocks in a sampling mode. Once some
data corruption is detected, the proxy is informed, it will
act on behalf of the staffs to regenerate the data blocks as
well as corresponding authenticators in a secure approach.
So we could see that our scheme guarantees that the staffs
can use the regenerating-code-based cloud in a practical and
lightweight way, which completely releases the staffs from
online burden for data auditing and reparation.
Enabling Privacy-Preserving Auditable: The privacy
protection of the owner’s data can be easily achieved through
integrating with the random proof blind technique [15] or
other technique [9]. However, all these privacy-preservation
methods introduce additional computation overhead to the
auditor, who usually needs to audit for many clouds and a
large number of data owners; thus, this could possibly make
it create a performance bottleneck. Therefore, we prefer
to present a novel method, which is more light-weight,
to mitigate private data leakage to the auditor. Notice that in
a regenerating-code-based cloud storage, data blocks stored
at servers are coded as linear combinations of the original
blocks {wi}m
i=1 with random coefficients. Supposing that the
curious TPA has recovered m coded blocks by elaborately
performing Challenge-Response procedures and solving
systems of linear equations [14], the TPA still requies to
solve another group of m linearly independent equations
to derive the m native blocks. We can utilize a keyed
pseudorandom function fkey(·) : {0, 1}∗ × K → GF(p) to

mask the coding coefficients and thus prevent the TPA from
correctly obtaining the original data. Specifically, the data
owner maintains a secret key κ for fκ (·) in the beginning of
the Setup procedure and augments m original data blocks as
wi = (wi1, wi2, . . . , wis,
m
0, . . . , 0, fκ (i)
i
, 0, . . . , 0) (21)
thus every coded blocks can be represented as
v = (vi1, vi2, . . . , vis
data
part
, ε1, . . . , εm
masked
coef f icients
) ∈ GF(p)s+m
(22)
where εi = fκ(i) · εi, i.e., the ith coefficient of a coded block
is masked with fκ (i). The TPA is unable to recover correct
coding coefficients as the key κ is kept secret by the data
owner. Without the knowledge of coding coefficients, the TPA
can not retrieve the original data blocks {wi }m
i=1 correctly, thus
realizing the privacy-preserve. Specifically, this method also
guarantees that the proxy can not obtain the private original
data either.
Apparently, our novel privacy-preserve method can be
easily integrated with the above primitive auditing scheme.
We only need to modify the “Augmentation” step of
SigAnd BlockGen(·) as Eq.(21) and leave the rest unchanged.
The experiment in Section V-B shows the efficiency of this
method.
Mitigating the Overhead of Data Owner: Despite that the
data owner has been released from online burden for auditing
and repairing, it still makes sense to reduce its computation
overhead in the Setup phase because data owners usually
maintain very limited computational and memory resources.
As previously described, authenticators are generated in a new
method which can reduce the computational complexity of
the owner to some extent; however, there exists a much more
efficient method to introduce further reduction.
Considering that there are so many modular exponent
arithmetic operations during the authenticator generation, the
data owner can securely delegate part of its computing task
to the proxy in the following way: The data owner first
properly augments the m native blocks, signs for them as
Eq.(6), and thus obtains the {σ∗∗
joko
}1≤ jo≤m
1≤ko≤s
, then it sends the
augmented native blocks and {σ∗∗
joko
} to the proxy. After
receiving from the data owner, the proxy implements the
last two steps of SigAndBlockGen(·) and finally generates
entire authenticators σijk for each segment vijk with secret
value x. In this way, the data owner can migrate the expen-
sive encoding and authenticator generation task to the proxy
while itself maintaining only the first two lightweight steps;
thus, the workload of data owner can be greatly mitigated.
A detailed analysis will be shown in Section V. Besides,
Theorem 4 in Section IV argues that the proxy can not forge
valid authenticators for invalid segments with non-negligible
probability.
A Tradeoff Between Storage and Communication: In our
auditing scheme described above, we assume that each
segment contains only one symbol for simplicity and is accom-
panied by an authenticator of equal length. This approach gives
a storage overhead twice as much as the length of the data
block (i.e., 2 · s · |p| bits), and the server’s response in each
epoch is (m + 2) · |p| bits. As noted in paper [12], we can
introduce a parameter ζ that gives a tradeoff between storage
overhead and response length: By denoting each segment as
a collection of ζ symbols and computing an authenticator for
each segment, the server storage overhead can be reduced by a
factor of ζ (i.e., (1+ 1
ζ )·s ·|p|) bits, while the communication
overhead will be increased to (m + ζ + 1) · |p| bits. We omit
a detailed description of the variant scheme due to space
limitations.
Detection Probability: The TPA performs random spot
checking on each coded block to improve the efficiency of
our auditing scheme, while still achieving detection of faulty
servers with high probability [2]. Supposing that an adversary
is able to corrupt data blocks as well as coefficients at a certain
server with probability p1 and p2 respectively, we can compute
the probability of detection as PD = 1−(1− p1)cα(1− p2)mα,
where c denotes the number of segments selected from each
coded block during each Audit phase. More specifically, if
the corruption proportion is set to be p1 = 0.5%, p2 = 0.2%,
and the system parameter is chosen as m = 15, α = 5, then
the TPA can detect the corrupted server with a probability
99% or 95%, where the number of sampled segments c in
each coded block is 185 or 120, respectively.
IV. SECURITY ANALYSIS
In this section, we first elaborate on the correctness of
verification in our auditing scheme and then formally eval-
uate the security by analyzing its fulfillment of soundness,
regeneration-unforgeable and secure guarantee against replay
attack.
A. Correctness
There are two verification process in our scheme, one for
spot checking during the Audit phase and another for block
integrity checking during the Repair phase.
Theorem 1: Given a cloud server i storing data blocks i
and accompanied authenticators i, TPA is able to correctly
verify its possession of those data blocks during audit phase,
and the proxy can correctly check the integrity of downloaded
blocks during repair phase.
Proof: Proving the correctness of our auditing scheme is
equivalent of proving that Eq.(15) and Eq.(17) is correct. The
correctness of Eq.(15) is shown in Appendix A and Eq.(17)
in Appendix B.
B. Soundness
Following from paper [12], we say that our auditing protocol
is sound if any cheating server that convinces the verification
algorithm that it is storing the coded blocks and corresponding
coefficients is actually storing them.
Before proving the soundness, we will first show that the
authenticator as Eq.(10) is unforgeable against malicious cloud
servers (referred to as adversary in the following definition)
under the random oracle model. Similar to the standard
notion of security for a signature scheme [24], we give the

formal definition of security model for our authenticator in
Definition 1.5
Definition 1: Our authenticator as Eq.(10) is existentially
unforgeable under adaptive chosen message attacks if no PPT
adversary has a non-negligible advantage in the following
game-Game 0:
1. Setup: The challenger runs the KeyGen() algorithm
on input 1κ and gives the public parameter (pkx, pky) to
adversary A.
2. Queries: The challenger maintains the following oracles
which can be queried by the adversary A:
• Hash Oracle(Ohash): provide result of H(·) for hash
queries.
• UW Oracle(Ouw): produce the random parameters u,
wλ(1 ≤ λ ≤ m) for signature or forgery.
• Sign Oracle(Osign): produce authenticators on adaptively
chosen tuple {I D, i, j, k, vijk , {εijλ}m
λ=1}, and return an
authenticator σijk.
3. Output: Eventually, the adversary A produces a
tuple {I D∗, i,∗ j∗, k∗, v∗, {ε∗
λ}m
λ=1, σ∗}, and we say that
A wins the game if Eq.(23) holds while the input tuple
{I D∗, i,∗ j∗, k∗, v∗, {ε∗
λ}m
λ=1} was not submitted to the Sign
Oracle Osign.
e(σ∗
, g) = e Hi∗ j∗k∗ , pkx · e uv∗
m
λ=1
w
ε∗
λ
λ , pky (23)
In the following theorem, we will show that our authentica-
tor is secure under the CDH (Computational Diffie-Hellman)
assumption.
Theorem 2: If the adversary A is able to win Game 0 with
non-negligible advantage after at most qh hash queries and
quw UW queries (quw = qh implied by our assumption in
footnote 5), then there exist a PPT algorithm S that can solve
the CDH problem with non-negligible probability .6
Proof: See Appendix C.
The formal definition of auditing soundness is shown in
Definition 2.
Definition 2: Our auditing scheme is sound if no PPT
adversary has a non-negligible advantage in the following
game-Game 1:
1. Setup: The challenger runs the KeyGen() algorithm
on input 1κ and gives the public parameter (pkx, pky) to
adversary A.
2. Store Query: The adversary A queries store oracle on
data F∗, the challenger implements the SigAndBlockGen()
algorithm of our protocol and returns { ∗
i , ∗
i , t} to A.
3. Challenge: For any F∗ on which A previously
made a store query, the challenger generates a challenge
C = {Qi , i } and requests A to provide a proof of possession
for the selected segments and corresponding coefficients.
5Notice that in the definition, we modeled the randomness u,
wλ(1 ≤ λ ≤ m) as a random oracle Ouw just as Dan Boneh et al. did
in [20] (Section 4). Besides, we assume that A is well-behaved that it
always queries the oracles Ohash and Ouw before it requests a signature
for adaptively chosen input tuple, and that it always query the Ohash and
Ouw before it outputs the forgery [17].
6In this paper we only give a sketch proof due to space limitation, a rigorous
version can be conducted similar with the proof in [17] (Section 4).
4. Forge: Suppose the expected proof P should be
{μi, σi , {ρiλ}m
λ=1}, which can pass the verification with
Eq.(15). However, the adversary A generates a forgery of the
proof as P = {μi, σi , {ρiλ}m
λ=1}. If the P can still pass the
verification in the following two case:
• Case 1: σi = σi ;
• Case 2: σi = σi , but at least one of the following
inequalities should be satisfied: μi = μi , ρiλ = ρiλ with
1 ≤ λ ≤ m;
then adversary A wins this game, otherwise, it fails.
Theorem 3: If the authenticator scheme is existentially
unforgeable and adversary A is able to win Game 1 with non-
negligible probability , then there exist a PPT algorithm S
that can solve the CDH problem or DL (Discrete Logarithm
Problem) problem with non-negligible probability .
Proof: See Appendix D.
C. Regeneration-Unforgeable
Noting that the semi-trusted proxy handles regeneration
of authenticators in our model, we say our authenticator is
regeneration-unforgeable if it satisfies the following theorem.
Theorem 4: The adversary (or proxy) can only regenerate
a forgery of authenticator for invalid segment from certain
coded block (augmented) and pass the next verification with
negligible probability, except that it implements the Repair
procedure correctly.
Proof: See Appendix E.
D. Resistant to Replay Attack
Theorem 5: Our public auditing scheme is resistant to replay
attack mentioned in [7, Appendix B], since the repaired server
maintains identifier η which is different with the corrupted
server η.
V. EVALUATION
A. Comparison
Table II lists the features of our proposed mechanism
and makes a comparison with other remote data checking
schemes [7], [8] for regenerating-coding-based cloud storage.
The security parameter κ is eliminated in the costs estimation
for simplicity. While the previously presented schemes
in [7] and [8] are designed for private verification, ours allows
anyone to challenge the servers for data possession while
preserving the privacy of the original data. Moreover, our
scheme can completely release the owners from online burden
compared with schemes in [7] and [8] where data owners
should stay online for faulty server reparation. To localize the
faulty server during the audit phase, [8] suggested a traversal
method and thus demanded many times of auditing operation
with complexity O(Ck
n(n − k)α) before the auditor can pick
up the wrong server, while our scheme is able to localize the
faulty server by a one-time auditing procedure.
For the storage overhead of each cloud server, our scheme
performs slightly better than Chen Bo’s as the servers do not
store the “repair tags” [7], but computes them on the fly.
For communication overhead during the audit phase, both [7]
and ours generate aggregated proofs for blocks verification,

TABLE II
COMPARISON OF DIFFERENT AUDIT SCHEMES FOR REGENERATING-CODE-BASED CLOUD STORAGE
thus significantly reducing the bandwidth compared with [8].
Besides, the communication cost of our scheme is lower
than Chen Bo’s [7] by a factor of α, because we generate
a single aggregated proof for all α blocks at each server,
while [7] checks the integrity of each one separately.
Nevertheless, the bandwidth cost during the repair procedure
of our scheme is higher; this comes from the transmission
of authenticators (total number s) for each segment of the
block generated by a helper server. These authenticators are
not only for verifying the integrity of the received blocks but
also for the regeneration of authenticators for repaired blocks;
this type of overhead can be reduced by reducing the number
of authenticators which can be achieved through increasing
the parameter ζ ≥ 1.
B. Performance Analysis
We focus on evaluating the performance of our
privacy-preserving public audit scheme during the Setup,
Audit and Repair procedure. In our experiments, all the codes
are written in C++ language on an OpenSUSE 12.2 Linux
platform with kernel version 3.4.6-2-desktop and compiler
version g++ 4.7.1. All entities in our prototype (as shown
in Fig.2) are represented by PCs with Intel Core i5-2450
2.5GHz, 8G DDR3 RAM and a 7200 RPM Hitachi 500G
SATA drive. The implementation of our algorithms uses
open source PBC (Pairing-Based Cryptography) Library
version 0.5.14, GMP version 5.13 and Openssl
version 1.0.1e. The elliptic curve utilized here is
Barreto-Naehrig curve [25], with base field size of 160 bits
and embedding degree 12. The security level is chosen to
be 80 bits and thus |p| = 160. All the experimental results
represent the mean of 10 trials. In addition, the choice
of parameters (n, k, , α, β) for regenerating codes is in
reference [7]. Notice that we only focus on the choice of
β = 1 and ζ = 1 here, from which similar performance
results can be easily obtained for other choices of β and ζ.
1) Setup Computational Complexity: During the Setup
phase, the authenticators are generated in a novel method
instead of computing an authenticator for each segment of
every coded block independently (meaning that the file is first
encoded and then authenticator is directly computed for each
segment as Eq.(10), we call this the straightforward approach
hereafter). Fixing the parameters (n = 10, k = 3, = 3,
α = 3, β = 1), we assume that the original data file
is split into m = 6 native blocks and would be encoded
Fig. 5. Time for system setup with different segment number s.
into nα = 30 coded blocks. First we evaluate the running
time of the data owner for auditing system setup. We mainly
measure the time cost of the block and authenticator generation
in this experiment.
Fig.5 compares the running time of setup phase utilizing
three different authenticator generation methods (with variable
s = 60, 80, 100): the straightforward approach, our primi-
tive approach (described in Section III-B “Setup”) and our
delegation approach (described in Section III-B “Mitigating
The Overhead Of Data Owner”). Apparently, all the three
approaches introduce higher time cost with larger s, as
there are more units need to sign; nevertheless, ours is
always more efficient than the straightforward approach. The
reason is that our primitive generation method decreases the
times of the time-consuming modular exponent operations to
nαs(m + 1) + 2m compared to the straightforward approach,
which requires nαs(m + 3) operations totally. However,
it is still intensive resource consuming and even unaf-
fordable when data owners use resource limited equipment
(e.g., Tablet PC et al.) to sign their data blocks and upload
them. Thus, we introduce another delegation method to solve
this problem. Experimental result shows that our delegation
method releases the data owner from heavy computational
overhead; the computational complexity of data owner is
reduced to about 1/18 of that with our primitive method, which
makes our schemes more flexible and practical for low power
cloud users.
Moreover, we evaluate the efficiency of our
privacy-preserving method and the results in Table III
show that our design is perfectly lightweight for the data
owner to execute. Because our privacy-preservation method
is implemented only once during the whole life of a user’s
file, while the random blind process in [9] and [15] would

TABLE III
COMPUTATIONAL COST INTRODUCED BY
THE PRIVACY-PRESERVING METHOD
Fig. 6. Time for Audit with different α.
be performed in each Audit instance, apparently our scheme
is much more efficient and thus we do not experimentally
compare their performance. In addition, [16] introduced a
similar privacy preserve method for their public auditing
protocol. Both their scheme and ours utilize random mask
in linear-code-based distributed storage to avoid the auditor
getting enough information for original data retrieve. However,
there is one significant difference between the two, i.e., [16]’s
method used the PRF to blind the data blocks before the
encoding process, while ours choose to mask the coding
coefficients instead. Numberically comparing them, we can
see that they need to execute PRF for s ·m times and m times
during the Setup phase, separately. Thus our privacy preserve
method is more efficient and effective than [16].
2) Audit Computational Complexity: Considering that the
cloud servers are usually powerful in computing capacity, we
focus on analyzing the computational overhead on the auditor
side and omit those on the cloud side. Theoretically, verifica-
tion for an aggregated proof requires less pairing operations,
which is the most expensive operation compared to modular
exponentiations and multiplication, than for separate α proofs.
To get a complete view of the batching efficiency, we conduct
two timed batch auditing tests, the first is implemented with
variable α from 1 to 8, and other parameters are set as n = 10,
c = 25, s = 60, k = α and m = (k2 + k)/2, while the
second one maintains the number of spot segment per block c
from 1 to 25 with fixed n = 10, s = 60, k = 3, m = 6
and α = 3. Fig.6 and Fig.7 show the time cost of auditing tasks
for a single server, and it can be found that the batch auditing
indeed helps reduce the TPA’s computational complexity by a
factor of approximately α.
3) Repair Computational Complexity: The regeneration
of the faulty blocks and authenticators is delegated to
a proxy in our auditing scheme; we now experimentally
evaluate its performance here. Fixing the parameters as
n = 10, k = 3, = 3, α = 3 and letting s vary to
be 60, 80 and 100, we measure the running time of three
sub-processes: Verification for Repair, Regeneration for Blocks
and Regeneration for Authenticators, thus obtaining the results
Fig. 7. Time for Audit with different c.
Fig. 8. Time for Repair with different s.
in Fig.8. Obviously, it takes the proxy much more time to
verify the received blocks for repair, less to regenerate the
authenticators, and negligible to regenerate the faulty blocks.
This situation occurs mainly because there are a mass of
expensive pairing operations and less expensive modular expo-
nentiations during the verification, thus leading to the most
time consuming sub-process. In contrast, there are only asymp-
totic αs( +α +1) modular exponentiations and αs inversions
in a finite group across the authenticator regeneration, and only
αs multiplications during the block regeneration. However,
the efficiency of the verification can be significantly improved
using a batch method, where we can randomly choose s
weights for each received blocks, aggregate the segments and
authenticators, and then verify them all in one, thus we can
avoid applying so many pairing operations.
VI. RELATED WORK
The problem of remote data checking for integrity was first
introduced in [26] and [27]. Then Ateniese et al. [2] and
Juels and Kaliski [3] gave rise to the similar notions provable
data possession (PDP) and proof of retrievability (POR),
respectively. Ateniese et al. [2] proposed a formal definition
of the PDP model for ensuring possession of files on untrusted
storage, introduced the concept of RSA-based homomorphic
tags and suggested randomly sampling a few blocks of the
file. In their subsequent work [28], they proposed a dynamic
version of the prior PDP scheme based on MAC, which allows
very basic block operations with limited functionality but
block insertions. Simultaneously, Erway et al. [29] gave a
formal framework for dynamic PDP and provided the first
fully dynamic solution to support provable updates to stored
data using rank-based authenticated skit lists and RSA trees.
To improve the efficiency of dynamic PDP, Wang et al. [30]
proposed a new method which uses merkle hash tree to support
fully dynamic data.

To release the data owner from online burden for
verification, [2] considered the public auditability in the PDP
model for the first time. However, their variant protocol
exposes the linear combination of samples and thus gives no
data privacy guarantee. Then Wang et al. [14], [15] developed
a random blind technique to address this problem in their
BLS signature based public auditing scheme. Similarly,
Worku et al. [31] introduced another privacy-preserving
method, which is more efficient since it avoids involving a
computationally intensive pairing operation for the sake of data
blinding. Yang and Jia [9] presented a public PDP scheme,
where the data privacy is provided through combining the
cryptography method with the bilinearity property of bilinear
pairing. [16] utilized random mask to blind data blocks in
error-correcting coded data for privacy-preserving auditing
with TPA. Zhu et al. [10] proposed a formal framework
for interactive provable data possession (IPDP) and a
zero-knowledge IPDP solution for private clouds.
Their ZK-IPDP protocol supports fully data dynamics,
public verifiability and is also privacy-preserving against the
verifiers.
Considering that the PDP model does not guarantee
the retrievability of outsourced data, Juels and Kaliski [3]
described a POR model, where spot-checking and error
correcting codes are used to ensure both “possession”
and “retrievability” of data files on remote archive service
systems. Later, Browers et al. [32] proposed an improved
framework for POR protocols that generalizes Juels’ work.
Dodis et al. [33] also gave a study on different variants of POR
with private auditability. A representative work upon the POR
model is the CPOR presented by Shacham and Waters [12]
with full proofs of security in the security model defined
in [3]. They utilize the publicly verifiable homomorphic linear
authenticator built from BLS signatures to achieve public
auditing. However, their approach is not privacy preserving
due to the same reason as [2].
To introduce fault tolerance in practical cloud storage,
outsourced data files are commonly striped and redundantly
stored across multi-servers or even multi-clouds. It is desired
to design efficient auditing protocols for such settings.
Specifically, [4]–[6] extend those integrity checking schemes
for the single-server setting to the multi-servers setting
under replication and erasure coding respectively. Both
Chen et al. [7] and Chen and Lee [8] make great effort to
design auditing schemes for regenerating-code-based cloud
storage, which is similar to our contribution except that
ours release the data owner from online burden for ver-
ification and regeneration. Furthermore, Zhu et al. [10]
proposed an efficient construction of cooperative provable data
possession (CPDP) which can be used in multi-clouds,
and [9] extend their primitive auditing protocol to support
batch auditing for both multiple owners and multiple clouds.
VII. CONCLUSION
In this paper, we propose a public auditing scheme for
the regenerating-code-based cloud storage system, where the
data owners are privileged to delegate TPA for their data
validity checking. To protect the original data privacy against
the TPA, we randomize the coefficients in the beginning rather
than applying the blind technique during the auditing process.
Considering that the data owner cannot always stay online in
practise, in order to keep the storage available and verifiable
after a malicious corruption, we introduce a semi-trusted proxy
into the system model and provide a privilege for the proxy to
handle the reparation of the coded blocks and authenticators.
To better appropriate for the regenerating-code-scenario,
we design our authenticator based on the BLS signature.
This authenticator can be efficiently generated by the data
owner simultaneously with the encoding procedure. Extensive
analysis shows that our scheme is provable secure, and the per-
formance evaluation shows that our scheme is highly efficient
and can be feasibly integrated into a regenerating-code-based
cloud storage system.
APPENDIX A
CORRECTNESS OF EQ. (15)
e(σi, g2) = e
⎛
⎝
α
j=1
σ
aj
ij , g2
⎞
⎠
=
α
j=1
e σij , g2
aj
=
α
j=1
e
c
τ=1
σ
a∗
τ
ijk∗
τ
, g2
aj
=
α
j=1
e
c
τ=1
H
a∗
τ
jτ
x
, g2
aj
·
α
j=1
e
⎛
⎝
⎛
⎝u
c
τ=1
a∗
τ vijk∗
τ
⎞
⎠
y
, g2
⎞
⎠
aj
·
α
j=1
e
⎛
⎜
⎝
m
λ=1
w
εijλ
λ
y
c
τ=1
a∗
τ
, g2
⎞
⎟
⎠
aj
=
α
j=1
e
c
τ=1
H
a∗
τ
jτ , pkx
aj
·
α
j=1
e uμij , pky
aj
·
α
j=1
e
⎛
⎜
⎝
m
λ=1
w
εijλ
λ
c
τ=1
a∗
τ
, pky
⎞
⎟
⎠
aj
= e
⎛
⎝
α
j=1
c
τ=1
H
a∗
τ aj
jτ , pkx
⎞
⎠ · e
⎛
⎝u
α
j=1
aj μij
, pky
⎞
⎠
· e
⎛
⎜
⎝
m
λ=1
w
α
j=1
aj εijλ·
c
τ=1
a∗
τ
λ , pky
⎞
⎟
⎠
= e
⎛
⎝
α
j=1
c
τ=1
H
a∗
τ aj
jτ , pkx
⎞
⎠ · e uμi , pky
· e
m
λ=1
w
ρiλ
λ , pky

thus we get
e
m
λ=1
w
−ρiλ
λ , pky · e (σi , g2) = RH S.
APPENDIX B
CORRECTNESS OF EQ. (17)
e(σik, g2) = e
⎛
⎝
α
j=1
σijk
aj
, g2
⎞
⎠
= e
⎛
⎝
α
j=1
H x
ijk uvijk ·
m
λ=1
w
εijλ
λ
y aj
, g2
⎞
⎠
= e
⎛
⎝
α
j=1
H
xaj
ijk , g2
⎞
⎠ · e
⎛
⎝u
y
α
j=1
aj vijk
, g2
⎞
⎠
· e
⎛
⎜
⎝
m
λ=1
w
y
α
j=1
aj εijλ
λ , g2
⎞
⎟
⎠
= e
⎛
⎝
α
j=1
H
aj
ijk, pkx
⎞
⎠ · e uvik , pky
· e
m
λ=1
wεiλ
λ , pky
Obviously we can easily get:
e
⎛
⎝
i∈{iθ }
σik, g2
⎞
⎠ = e
⎛
⎝
i∈{iθ }
α
j=1
H
aj
ijk, pkx
⎞
⎠
· e u i∈{iθ } vik
, pky
· e
m
λ=1
w
i∈{iθ } εiλ
λ , pky .
APPENDIX C
PROOF OF THEOREM 2
Given g, gx, gy ∈ G, the algorithm S maintains the chal-
lenger in Game 0 and interacts with adversary A as follows:
Setup: S runs the KeyGen() algorithm on input 1κ and gives
the public parameter (pkx, pky) to adversary A.
Queries: S operates the oracles as follows.
• Hash Oracle(Ohash): For each query with input tuple
{I D, i, j, k}, if it has already been queried, the oracle
returns Hijk. If this query is a new one, S guesses
whether this current query is for forgery or not, if so,
it sets Hijk = gy, otherwise sets Hijk = gγijk with
γijk
R
←− GF(p).
• UW Oracle(Ouw): For each query for u, wλ(1 ≤
λ ≤ m) with input {I D, i, j, k, vijk, {εijλ}m
λ=1} ,
if this tuple has been queried, returns correspond-
ing u, wλ(1 ≤ λ ≤ m). Otherwise, S randomly
chooses r,rλ ∈ GF(p), 1 ≤ λ ≤ m, and guesses whether
this current query is for forgery or not, if so, S sets
u = (gx)r, wλ = (gx)rλ (1 ≤ λ ≤ m), if not, S sets
u = (gζ )r , wλ = (gζ )rλ (1 ≤ λ ≤ m) with ζ
R
←− GF(p).
• Sign Oracle(Osign): For each input {pkx, pky} and
tuple {I D, i, j, k, vijk , {εijλ}m
λ=1}, S outputs the
σijk = (gγijk )x ((gζ )rvijk + m
λ=0 rλεijλ )y by querying the
Ohash and Ouw.
Output: Eventually, the adversary A outputs a result tuple
{I D∗, i,∗ j∗, k∗, v∗, {ε∗
λ}m
λ=1, σ∗}, if Eq.(23) holds while the
input tuple {I D∗, i,∗ j∗, k∗, v∗, {ε∗
λ}m
λ=1} was not submitted
to the Sign Oracle Osign, A wins Game 0 and S declares
“success”, otherwise A loses Game 0 and S aborts.
If S declares “success”, she obtains σ∗ =
(gy)x((gx)rv∗+ m
λ=1 rλε∗
λ )y = (gxy)1+rv∗+ m
λ=0 rλε∗
λ .
Thus the proposed CDH problem can be solved as
gxy = (σ∗)
1
1+rv∗+ m
λ=0 rλε∗
λ .
The probability that S guesses the forged input tuple is more
than 1/qh, then S can solve the CDH problem with probability
≥ /qh which is non-negligible.
APPENDIX D
PROOF OF THEOREM 3
The authenticator in our auditing mechanism is existentially
unforgeable as Theorem 2 shows.
Treating the cloud server i as an adversary A, we let S
maintain the challenger and simulate the environment for
each auditing instance. Our proof follows from [12] with one
modiﬁcation that we introduce a stronger adversary, who can
not only obtain the public parameters but also can retrieve the
ratio y/x from the environment. Obviously, if an adversary
with the value y/x cannot forge a proof under our scheme,
the auditing proof is unforgeable for a common adversary as
deﬁned in [12].
Initially, the challenger/simulator S sets pkx = gx,
pky = gy as public keys, meaning that it does not know the
corresponding secret keys x, y. However, we assume that S
knows the ratio value y/x as mentioned above.
For each k in the Qi = {(k∗
ξ , a∗
ξ )} of a challenge, the
simulator S randomly chooses rk
R
←− GF(p), sets u = gγ hζ
and wλ = gγλhζλ with each γ, γλ, ζ, ζλ
R
←− GF(p). Then
S programs the random oracle at k as
H(I D||i|| j||k)
=
grk
(gγ vijk + m
λ=1 γλεijλ · hζvijk + m
λ=1 ζλεijλ )y/x
(1)
and computes σijk as
σijk = H(I D||i|| j||k)x
uvijk
m
λ=1
w
εijλ
λ
y
=
grk
(gγ vijk + m
λ=1 ζλεijλ )y/x
x
· gγ vijk+ m
λ=1 ζλεijλ
y
= (gx
)rk (2)
Assuming that the adversary A wins Game 1, we will show
that the simulator can solve the CDH problem or DL problem
in the following cases:

Case 1 (σi = σi ): In this case, the simulator is given input
values g, gy, h ∈ G, and its goal is to output hy.
We know that the expected proof satisfies the verification
equation:
e (σi , g) = e
⎛
⎝
α
j=1
c
τ=1
H
aja∗
τ
jτ , pkx
⎞
⎠
· e uμi
, pky · e
m
λ=1
w
ρiλ
λ , pky (3)
and the forged proof can also pass the verification as
e σi , g = e
⎛
⎝
α
j=1
c
τ=1
H
aja∗
τ
jτ , pkx
⎞
⎠
· e uμi , pky · e
m
λ=1
w
ρiλ
λ , pky (4)
Obviously, equations μi = μi, ρiλ = ρiλ(1 ≤ λ ≤ m)
cannot be satisfied simultaneously, otherwise contradicts our
assumption σi = σi. Therefore, we define μi = μi −μi and
ρiλ = ρiλ −ρiλ(1 ≤ λ ≤ m), it must be the case that at least
one of { μi, ρiλ} is nonzero.
Now we divide Eq.(4) by Eq.(3) and obtain
e σi σ−1
i , g = e u μi
, pky · e
m
λ=1
w
ρiλ
λ , pky
= e u μi
m
λ=1
w
ρiλ
λ , pky
= e (gγ
hζ
) μi ·
m
λ=1
(gγλ hζλ ) ρiλ , pky
(5)
Rearranging terms yields
e σi σ−1
i pk
−(γ μi+ m
λ=1 γλ ρiλ)
y , g
= e hy
, g
ζ μi + m
λ=1 ζλ ρiλ
(6)
From the property of bilinear pairing map, it is clear that
the simulator solves the CDH problem
hy
= σi σ−1
i pk
−(γ μi + m
λ=1 γλ ρiλ)
y
1
ζ μi + m
λ=1 ζλ ρiλ
(7)
unless the denominator ζ μi + m
λ=1 ζλ ρiλ equals to zero.
Notice that not all of the set { μi, ρiλ} can be zero, and
the value ζ, ζiλ are chosen by the challenger and hidden from
the adversary, so the denominator is zero with a negligible
probability 1/p.
Thus, if the adversary can win Game 1 with non-negligible
probability , the simulator is able to solve the CDH problem
with probability = (1−1/p) which is also non-negligible.
Case 2: σi = σi , but at least one of the following
inequalities should be satisfied: μi = μi, ρiλ = ρiλ with
1 ≤ λ ≤ m.
Given g, h ∈ G as input in this case, the simulator aims to
output ϕ such that h = gϕ.
Similar with notations above, we define μi = μi −μi and
ρiλ = ρiλ −ρiλ(1 ≤ λ ≤ m), and at least one of { μi, ρiλ}
is nonzero. Now we have
e (σi , g) = e σi , g
e uμi
m
λ=1
w
ρiλ
λ , pky = e uμi
m
λ=1
w
ρiλ
λ , pky
1 = u μi
m
λ=1
w
ρiλ
λ
1 = (gγ
hζ
) μi (
m
λ=1
(gγλhζλ ) μiλ )
obviously the simulator gets the solution of DL problem
h = gϕ with
ϕ = −
γ μi + m
λ=1 γλ ρiλ
ζ μi + m
λ=1 ζλ ρiλ
(8)
Analyzing similar with above, we see the denominator is
zero with a negligible probability 1/p since the prime p is
large enough. Then the simulator can solve the DL problem
with non-negligible probability = (1 − 1/p) .
APPENDIX E
PROOF OF THEOREM 4
As mentioned in Section II-A, any non-zero vector
v∗ ∈ GF(p)s+m does not belong to the linear subspace V
spanned by base vectors {wi}m
i=1 is invalid, and will result
in data unrecoverable in the regenerating-code-based cloud
storage after a series of epoches.
Without loss of generality, we assume that each segment
contains ζ symbols. By viewing the kth segment of coded
block v as a vector vk = (vk1, vk2, . . . vkζ ) ∈ GF(p)ζ and
appending it with m corresponding coefficients, we can get the
augment vector vk = (vk1, . . . vkζ , εk1, . . . εkm) ∈ GF(p)ζ+m.
Denoting Vs to be the linear subspace spanned by m base
vectors, each base vector is obtained by properly augmenting
the kth segment of one native vectors wi . Similarly with
previously described, any vector vk belonging to subspace
Vs is valid, otherwise invalid. Extended from Eq.(10) (in the
main body of this paper), we can easily get the authenticator
for the kth segment as
σk = H(I D|| . . .)x
⎛
⎝
ζ
τ=1
uvkτ
τ ·
m
λ=1
wεkλ
λ
⎞
⎠
y
(9)
Since that the proxy owns the secret value x, the proof of
Theorem 4 is equivalent to the unforgeability of the tag in the
following equation for invalid segment vk without knowledge
of key y.
σk =
⎛
⎝
ζ
τ=1
uvkτ
τ ·
m
λ=1
w
εkλ
λ
⎞
⎠
y
(10)
Viewing each wλ as the output of an independent hash
function Hw(I D||λ) (also modeled as a random oracle as

Boneh et al. [20] does), we get
σk =
⎛
⎝
ζ
τ=1
uvkτ
τ ·
m
λ=1
Hw(I D||λ)εkλ
⎞
⎠
y
(11)
which is identical to NCS1 signature scheme presented in [20].
In [20, Th. 6], Boneh et al. proved that NCS1 signature
scheme is secure against forgery under random oracle model.
That is, it is computational infeasible for an adversary to
generate a valid signature for any vectors not belonging to
the subspace Vs.
Consequently, we get that the proxy can not forge a valid σk
for an invalid segment vk with non-negligible probability in
our proposed scheme.
REFERENCES
[1] M. Armbrust et al., “Above the clouds: A Berkeley view of cloud
computing,” Dept. Elect. Eng. Comput. Sci., Univ. California, Berkeley,
CA, USA, Tech. Rep. UCB/EECS-2009-28, 2009.
[2] G. Ateniese et al., “Provable data possession at untrusted stores,” in
Proc. 14th ACM Conf. Comput. Commun. Secur. (CCS), New York, NY,
USA, 2007, pp. 598–609.
[3] A. Juels and B. S. Kaliski, Jr., “PORs: Proofs of retrievability for
large files,” in Proc. 14th ACM Conf. Comput. Commun. Secur., 2007,
pp. 584–597.
[4] R. Curtmola, O. Khan, R. Burns, and G. Ateniese, “MR-PDP:
Multiple-replica provable data possession,” in Proc. 28th Int. Conf.
Distrib. Comput. Syst. (ICDCS), Jun. 2008, pp. 411–420.
[5] K. D. Bowers, A. Juels, and A. Oprea, “HAIL: A high-availability and
integrity layer for cloud storage,” in Proc. 16th ACM Conf. Comput.
Commun. Secur., 2009, pp. 187–198.
[6] J. He, Y. Zhang, G. Huang, Y. Shi, and J. Cao, “Distributed data
possession checking for securing multiple replicas in geographically-
dispersed clouds,” J. Comput. Syst. Sci., vol. 78, no. 5, pp. 1345–1358,
2012.
[7] B. Chen, R. Curtmola, G. Ateniese, and R. Burns, “Remote data
checking for network coding-based distributed storage systems,” in Proc.
ACM Workshop Cloud Comput. Secur. Workshop, 2010, pp. 31–42.
[8] H. C. H. Chen and P. P. C. Lee, “Enabling data integrity protection in
regenerating-coding-based cloud storage: Theory and implementation,”
IEEE Trans. Parallel Distrib. Syst., vol. 25, no. 2, pp. 407–416,
Feb. 2014.
[9] K. Yang and X. Jia, “An efficient and secure dynamic auditing protocol
for data storage in cloud computing,” IEEE Trans. Parallel Distrib. Syst.,
vol. 24, no. 9, pp. 1717–1726, Sep. 2013.
[10] Y. Zhu, H. Hu, G.-J. Ahn, and M. Yu, “Cooperative provable data
possession for integrity verification in multicloud storage,” IEEE Trans.
Parallel Distrib. Syst., vol. 23, no. 12, pp. 2231–2244, Dec. 2012.
[11] A. G. Dimakis, K. Ramchandran, Y. Wu, and C. Suh, “A survey on
network codes for distributed storage,” Proc. IEEE, vol. 99, no. 3,
pp. 476–489, Mar. 2011.
[12] H. Shacham and B. Waters, “Compact proofs of retrievability,” in
Advances in Cryptology. Berlin, Germany: Springer-Verlag, 2008,
pp. 90–107.
[13] Y. Hu, H. C. H. Chen, P. P. C. Lee, and Y. Tang, “NCCloud: Applying
network coding for the storage repair in a cloud-of-clouds,” in Proc.
USENIX FAST, 2012, p. 21.
[14] C. Wang, Q. Wang, K. Ren, and W. Lou, “Privacy-preserving public
auditing for data storage security in cloud computing,” in Proc. IEEE
INFOCOM, Mar. 2010, pp. 1–9.
[15] C. Wang, S. S. M. Chow, Q. Wang, K. Ren, and W. Lou,
“Privacy-preserving public auditing for secure cloud storage,” IEEE
Trans. Comput., vol. 62, no. 2, pp. 362–375, Feb. 2013.
[16] C. Wang, Q. Wang, K. Ren, N. Cao, and W. Lou, “Toward secure and
dependable storage services in cloud computing,” IEEE Trans. Service
Comput., vol. 5, no. 2, pp. 220–232, Apr./Jun. 2012.
[17] D. Boneh, B. Lynn, and H. Shacham, “Short signatures from the Weil
pairing,” J. Cryptol., vol. 17, no. 4, pp. 297–319, 2004.
[18] A. G. Dimakis, P. B. Godfrey, Y. Wu, M. J. Wainwright, and
K. Ramchandran, “Network coding for distributed storage systems,”
IEEE Trans. Inf. Theory, vol. 56, no. 9, pp. 4539–4551, Sep. 2010.
[19] T. Ho et al., “A random linear network coding approach to multicast,”
IEEE Trans. Inf. Theory, vol. 52, no. 10, pp. 4413–4430, Oct. 2006.
[20] D. Boneh, D. Freeman, J. Katz, and B. Waters, “Signing a linear
subspace: Signature schemes for network coding,” in Public Key
Cryptography. Berlin, Germany: Springer-Verlag, 2009, pp. 68–87.
[21] D. Boneh and M. Franklin, “Identity-based encryption from the Weil
pairing,” in Advances in Cryptology. Berlin, Germany: Springer-Verlag,
2001, pp. 213–229.
[22] A. Miyaji, M. Nakabayashi, and S. Takano, “New explicit conditions of
elliptic curve traces for FR-reduction,” IEICE Trans. Fundam. Electron.,
Commun., Comput. Sci., vol. E84-A, no. 5, pp. 1234–1243, 2001.
[23] R. Gennaro, J. Katz, H. Krawczyk, and T. Rabin, “Secure network
coding over the integers,” in Public Key Cryptography. Berlin, Germany:
Springer-Verlag, 2010, pp. 142–160.
[24] S. Goldwasser, S. Micali, and R. L. Rivest, “A digital signature scheme
secure against adaptive chosen-message attacks,” SIAM J. Comput.,
vol. 17, no. 2, pp. 281–308, 1988.
[25] P. S. L. M. Barreto and M. Naehrig, “Pairing-friendly elliptic curves
of prime order,” in Selected Areas in Cryptography. Berlin, Germany:
[26] Y. Deswarte, J.-J. Quisquater, and A. Saïdane, “Remote integrity
checking,” in Integrity and Internal Control in Information Systems VI.
Berlin, Germany: Springer-Verlag, 2004, pp. 1–11.
[27] D. L. G. Filho and P. S. L. M. Barreto, “Demonstrating data posses-
sion and uncheatable data transfer,” Cryptology ePrint Archive, Tech.
Rep. 2006/150, 2006. [Online]. Available: http://eprint.iacr.org/
[28] G. Ateniese, R. Di Pietro, L. V. Mancini, and G. Tsudik, “Scalable and
efficient provable data possession,” in Proc. 4th Int. Conf. Secur. Privacy
Commun. Netw., 2008, Art. ID 9.
[29] C. Erway, A. Küpçü, C. Papamanthou, and R. Tamassia, “Dynamic
provable data possession,” in Proc. 16th ACM Conf. Comput. Commun.
Secur., 2009, pp. 213–222.
[30] Q. Wang, C. Wang, J. Li, K. Ren, and W. Lou, “Enabling
public verifiability and data dynamics for storage security in cloud
computing,” in Computer Security. Berlin, Germany: Springer-Verlag,
2009, pp. 355–370.
[31] S. G. Worku, C. Xu, J. Zhao, and X. He, “Secure and efficient privacy-
preserving public auditing scheme for cloud storage,” Comput. Elect.
Eng., vol. 40, no. 5, pp. 1703–1713, 2013.
[32] K. D. Bowers, A. Juels, and A. Oprea, “Proofs of retrievability: Theory
and implementation,” in Proc. ACM Workshop Cloud Comput. Secur.,
2009, pp. 43–54.
[33] Y. Dodis, S. Vadhan, and D. Wichs, “Proofs of retrievability via
hardness amplification,” in Theory of Cryptography. Berlin, Germany:
Jian Liu received the bachelor’s and master’s
degrees from the National University of Defense
Technology, in 2009 and 2011, respectively, where
he is currently pursuing the Ph.D. degree with the
State Key Laboratory of Complex Electromagnetic
Environment Effects on Electronics and Information
System. His research interests include secure storage
and computation outsourcing in cloud computing,
and security of distributed systems.
Kun Huang received the bachelor’s and master’s
degrees from the National University of Defense
Technology, in 2010 and 2012, respectively, where
he is currently pursuing the Ph.D. degree with
the State Key Laboratory of Complex Electromag-
netic Environment Effects on Electronics and Infor-
mation System and is currently studying abroad
with the University of Melbourne with advisor
Prof. U. Parampalli. His research interests include
applied cryptography, network encoding, and cloud
computing.

Hong Rong received the bachelor’s degree from the
South China University of Technology, in 2011, and
the master’s degree from the National University of
Defense Technology, in 2013, where he is currently
pursuing the Ph.D. degree with the State Key Lab-
oratory of Complex Electromagnetic Environment
Effects on Electronics and Information System. His
research interests include privacy preservation of big
data, cloud computing, and virtualization.
Huimei Wang received the bachelor’s degree from
Southwest Jiaotong University, in 2004, and the
master’s and Ph.D. degrees in information and com-
munication engineering from the National University
of Defense Technology, in 2007 and 2012, respec-
tively. She is currently with the State Key Laboratory
of Complex Electromagnetic Environment Effects
on Electronics and Information System, National
University of Defense Technology, as a Lecturer. Her
research interests include network security, cloud
computing, and distributed systems.
Ming Xian received the bachelor’s, master’s, and
Ph.D. degrees from the National University of
Defense Technology, in 1991, 1995, and 1998,
respectively. He is currently a Professor with the
State Key Laboratory of Complex Electromagnetic
Environment Effects on Electronics and Information
System, National University of Defense Technology.
His research focus on cryptography and informa-
tion security, cloud computing, distributed systems,
wireless sensor network and system modeling, and
simulation and evaluation.

Privacy-Preserving Public Auditing for Regenerating-Code-Based Cloud Storage

More Related Content

What's hot (19)

Viewers also liked (20)

Similar to Privacy-Preserving Public Auditing for Regenerating-Code-Based Cloud Storage (20)

Recently uploaded (20)

Privacy-Preserving Public Auditing for Regenerating-Code-Based Cloud Storage