Patent Grant
9749418
The present invention relates to cloud storage, in particular, to a cloud storage system and method where a client can perform a fast and secure update on the outsourced data.
There is a universal trend toward storage outsourcing through the cloud (e.g., Google Drive, Amazon S3, Microsoft OneDrive), bringing advantages such as cost saving, global access to data, and reduced management overhead. Yet, the most important disadvantage is that the data owner (client), by outsourcing her data to a cloud storage provider (server), loses the direct control over her data. Therefore, the client expects having an authenticated storage and guaranteed retrievability. The former means that the client wants each data access to return the correct value; i.e., a value that is the most recent version of data that has been written by the client herself. The latter means that the client wants to make sure that her data is retrievable; i.e., she can retrieve all her data correctly. These authenticity and retrievability checks should be much more efficient than downloading the whole data.
A simple mechanism to provide an authenticated storage is to compute a digest (e.g., hash. MAC, or signature) of data and keep it locally after transferring the data to the server (or in case of a MAC or signature, the key is kept locally, while the tags can be stored at the server). But, the client needs to download the whole data and check it against the locally-stored digest to investigate the authenticity of her data, which is prohibitive given current trends of outsourcing tens of gigabytes of data.
Provable Data Possession (PDP) is a very close line of work, providing probabilistic guarantees of possession of the outsourced file using a challenge-response mechanism. Similar schemes were later proposed targeting public verifiability and availability. A PDP does not use erasure-correcting codes (ECC) and guarantees that the client can retrieve most of die outsourced data but not the whole data. PDP can be improved by adding ECC to enhance the possession guarantee.
As a first attempt to create dynamic PDP, techniques were developed to enable clients to update a single block where they pre-compute and store at the server a limited number of random challenges with the corresponding answers. Therefore, the number of challenges is limited and later updates affect all remaining answers.
Then, a fully dynamic PDP scheme was developed, which uses rank-based authenticated skip lists providing O(log(n)) complexity for updates and audits, where n is the number of blocks. Later variants use other data structures, supply additional properties, distribute and replicate, or enhance efficiency.
The PDP framework does not use erasure-correcting codes (ECC) and hence is more efficient. However, PDP does not provide the same retrievability guarantee as other schemes. One of these schemes is Proofs of Retrievability (PoR) which will be discussed below. The security guarantee a PDP gives is weaker than a PoR in the sense that it guarantees that the client can retrieve most of the outsourced data. In contrast, the PoR guarantees retrieving the whole data. PoR construction can further be improved. The compact PoR may be created from a PDP combined with erasure-correcting code. Yet, this only shows the relationship between the static versions of PDP and PoR.
Static techniques include Proofs of Retrievability (PoR). In a PoR scheme, the client, before outsourcing her data, encodes it with an erasure-correcting code (ECC), and then applies an encryption and a permutation on the result to make it difficult for the server to locate the related parts of the encoded data. Using erasure-correcting codes brings some redundancy while giving the guarantee that the server should manipulate a significant portion of the outsourced (encoded) data in order to impose a data loss or corruption.
There are different PoR schemes, one using pseudorandom functions that is secure in the standard model and the other using BLS signatures that is secure in the random oracle model. The former supports only private verifiability while the latter allows public verifiability. The main advantage over previous schemes is that it supports unlimited number of challenges. Using PoR systems, such a misbehavior resulting in a large data loss or corruption will be caught with a very high probability. Efficiency and security are seemingly two conflicting properties related to update in PoR schemes.
PoR schemes fail to provide efficient and secure update on the outsourced data. In order to have an efficient update, it should affect as small part of the data as possible. But, the server can erase or modify all affected blocks, with a small probability of being caught. To prevent such misbehavior, a small change should affect a significant fraction of the outsourced data, which is not efficient.
The first real dynamic PoR scheme has constant client storage and polylogarithmic communication and computation. As a building block, they use an ORAM satisfying a special property called next-read-pattern-hiding. Although it achieves asymptotic efficiency. ORAM is a complicated and heavy cryptographic primitive that is (currently) not practically efficient. Later, locally updatable and locally decodable codes are used to construct a dynamic PoR scheme. The data is erasure-coded, and the client stores it remotely inside a hierarchical authenticated data structure similar to ORAM. Later updates are also erasure-coded and stored in the same data structure. Reading through that structure requires O(n) cost, hence, they store the plain data and subsequent updates in another similar structure.
Later improvements, at a high level, separate the updated data from the original data, and store the update logs in a hierarchical data structure similar to ORAM. On the other hand, the first dynamic PDP protocol was created before the first dynamic PoR. The reason is that, since PDP-type schemes do not employ erasure-correcting codes, the above mentioned problems did not exist.
Another dynamic PoR scheme similar to the previous one uses the fast incrementally-contractible codes to achieve efficiency. Later, the dynamic PoR was improved by outsourcing some part of computation to the server, reducing the communication and client computation. Using the introduced homomorphic checksum, the client only performs the computation on these checksums, leaving computation on data itself to the server.
One important difficulty in existing DPoR schemes is the excessive volume of communication.
It has also been pointed out in prior art that adding local storage to the client has no effect on the asymptotic costs.
The invention is a DPoR scheme that is built given black-box access to a DPDP and a static PoR scheme (which, in turn, can be obtained from a static PDP and an ECC scheme).
An objective of the invention is to generate an efficient dynamic PoR scheme.
Another objective of the invention is to reduce the audit bandwidth from O(λ log(n)) to O(λ), where n is the number of outsourced blocks and λ is the security parameter.
Another objective of the invention is to improve the update cost by adding local storage. Adding local storage to the client considered to have no affect on the asymptotic costs of the existing schemes by prior art. However this invention shows that adding local storage to the client improves the update cost. The problem of improving the update cost is solved by adding local memory to the client.
Another objective of the invention is to generate a dynamic PoR scheme construction framework with various optimizations.
Another objective of the invention is generation of the erasure-coded and authenticated log (ECAL) as an efficient data structure to store the update logs, in different configurations. While previous works' reshuffling operations require O(n) temporary storage at the client for each update, our invention's equibuffers configuration reduces it considerably into orders that are available in almost all existing hand-held electronic devices, letting us employ even mobile phones for updating data on the cloud storage. (Note that a rebuild still requires large client memory (e.g., a computer), but needs to be done only once every O(n) updates.) We consider a client storage of size O(λ√{square root over (n)}) which is about 3 MB for 10 GB outsourced data. This is a reasonable assumption since most of hand-held electronic devices at the time this invention was made have more than 3 MB local memory. Thus, without the need for large reshuffling memory, our protocol may even be used by smart phones for updating data (e.g., now you can update a text file on your secure Dropbox on the go).
Notation.
We use x←X to denote that x is sampled uniformly from the set X, |X| to show the number of elements in X, and ∥ to show concatenation. PPT denotes probabilistic polynomial time, and λ is the security parameter. By log, we mean the footprint an update operation leaves, while log(•) indicates logarithm calculation. A function v(λ):Z+→[0,1] is called negligible if ∀ positive polynomials p. ∃ a constant c such that ∀λ>c, v(λ)<1/p(λ). Overwhelming probability is greater than or equal to 1−v(λ) for some negligible function v(λ). By efficient algorithms, we mean those with expected running time polynomial in λ.
PDP.
In a PDP scheme, the client first divides a file E into n blocks, F=(f1, f2, . . . , fn), then computes a tag Ti for each block, and finally transfers the file along with the tags to the server, deleting its local copy. Later, she sends a challenge, which is a subset of block indices selected randomly, to the server. Upon receipt, the server constructs a proof using the tags and blocks stored, and sends it back to the client for verification. The tags are homomorphic, meaning that it is possible to combine multiple of them into a single tag, reducing the proof size.
Dynamic PDP.
The DPDP scheme stores the block tags in a rank-based authenticated skip list that is used to generate cryptographic proofs. The rank-based authenticated skip list supports update operations efficiently, with O(log(n)) cost.
Erasure-correcting codes are used to deal with correcting the errors that occur during data transmission over a noisy channel, or data storage in a device. An (n,k,d)Σ erasure-connecting code over a finite alphabet Σ is a pair of efficient encoding and decoding algorithms (encode,decode) such that encode: Σk→Σn transforms a message M=(m1, m2, . . . , mn)εΣk into a codeword C=(c1, c2, . . . , cn)εΣn, and decode: Σn−d+1→Σk recovers the original message from a codeword in the presence of at most d−1 erasures.
Compact PoR can be obtained from an efficient PDP scheme together with an erasure-correcting code. At a high level, the data is erasure-coded, permuted (pseudo-) randomly, and the (PDP) tags are computed for the resulting blocks. Throughout this application, when we talk about PoR schemes, we mean this scheme of construction.
To ensure retrievability of the outsourced data, erasure-correcting codes can be used. Using an (n,k,d)Σ erasure-correcting code, if the adversary manages to manipulate a small part of the data (i.e., up to d−1 out of n blocks), the data retrievability is still guaranteed. However if the adversary manipulates a significant part of the data (i.e., more than d−1 blocks), it cannot be recovered using the erasure-correcting code. An integrity checking mechanism is needed to catch such an adversary, with high probability. Note that the integrity checking mechanism needs to detect only such significant modifications/deletions.
Furthermore, simple updates on erasure-coded data is not enough. Two possibilities are:
It is better to store the update information separately, rather than applying the updates on the encoded data. There should be two parts of server storage: one part stores the encoded original data, and the other part stores the update information (referred to as the log store). The log store, which is empty at the outset can grow to be as much as linear in the data size. When the log store becomes full, the updates in it will be applied on the original data. This generates the last version of data and an empty log store.
Since the log store can be as large as (linear in the size of) the original data, the efficiency problem is again encountered. The remedy is to use a hierarchical data structure. Each level is erasure-coded, updated, and audited independently, and possibly merged into the next level once filled up.
Although the insecurity and inefficiency problem of the update logs can be solved using the observations above, we are now faced with a new problem: to read the latest version of some data, we need to decode the encoded data and apply all the logs, which requires O(n) time. To solve this issue, one should store an uncoded version of data, protected by a dynamic memory checking scheme, at the sever. This frees the read operation from difficulties of struggling with the erasure-correcting codes. For read operations, the membership proofs of the memory checking scheme serves as the authenticity proof (i.e., if the proof is accepted, we can be assured with high probability that the challenged data is kept intact on the server).
It is enough that the memory checking scheme is only responsible for authenticity of the data read, and hence the read operations need not be oblivious. This reveals the access pattern of the client, but access privacy is not a requirement of the dynamic PoR definition. The log store, on the other hand, needs oblivious operations, due to the explained failed attempts regarding the update information enabling the server to create data loss or corruption. Both read and update operations are performed obliviously. We also observe that the log store can be append-only.
An ORAM structure tries to perform both read and update operations in a similar manner that an adversary cannot distinguish them. Hence, a read operation cuts (or just copies) the requested data item and inserts it back in the ORAM from the top level [9], requiring reshuffling operation. If the read operations will not be run through the ORAM, then there is no need to perform the extra heavy reshufflings. This is an important observation that we will utilize to construct an efficient structure for storing the logs.
Dynamic Proof of Retrievability
Now that we have observed some important aspects of the design, we can present an overview of our general framework. In our framework, any update operation leaves a footprint, which is called a log. If these logs are kept securely and erasure-coded, even in case of any data loss, the data can be recovered using the logs. This is conceptually similar to what a database management system or a journal-based file system performs in the background. However, a main difference is that we do not trust the server to keep the logs correctly, so we should audit the server.
Our scheme has two parts: one is a data structure responsible for keeping update logs securely and providing the retrievability guarantee, the other is a dynamic memory-checking scheme that responds to read queries providing authenticity, as shown in
During normal execution, read operations are responded by the memory-checking scheme together with authenticity proofs. However, in case of any data loss in the memory-checking part such that the read operation returns incorrect responses (or nothing), the log store is used to recover the requested data. If it cannot be recovered even using the logs, the server is misbehaving, and this will be caught with high probability. Since the log store supports retrievability, it is enough that audits are performed over that part. Answers to both the read and audit are accompanied with cryptographic proofs, so the client can verify them.
Definition 3.1 (Dynamic PoR.)
A dynamic PoR scheme consists of the following protocols run between a stateful client and a stateful server. The client, using these interactive protocols, can outsource and later update her data at an untrusted server, while retrievability of her data is guaranteed (with overwhelming probability):
PInit((1λ, 1W, n, M): the client uses this protocol to initialize an empty memory of size on the server, given the alphabet Σ={0,1}w and security parameter λ. She is outsourcing the initial data M.
PUpdate(i,OP,v): using this protocol, the client performs the operation OPε{Insert,Delete,Modify} on the ith location of the memory (on the server) with input value v (if required).
(v,p)←PRead(i): is used to read the value stored at the ith location of the memory managed by the server. The client specifies the location i as input, and outputs some value v, and a proof p proving authenticity of v.
PAudit( ): The client starts up this protocol to check whether the server keeps storing her data correctly. She finally outputs an acceptance or rejection signal.
Security Definitions
Correctness considers the honest behavior of the (client and) server in a protocol run. A scheme is correct if the following is satisfied with probability l over the randomness of the client: Each execution of PRead, to read the ith data, returns a value v such that v is the ith value that has already been written by a PUpdate protocol. If less than i data exists, it returns ⊥. Moreover, the PAudit protocol, once executed, results in an acceptance.
Authenticity. If the server deviates from honest behavior by providing proofs while he has manipulated the challenged part of data, the client should detect it with overwhelming probability. The authenticity game AuthGameŜ(λ) between a challenger and a malicious server Ŝ is defined as:
Initialization. The challenger starts the PInit protocol to initialize the environment. The challenger also starts a copy of the honest client C and the honest server S, and runs PInit among them.
Setup. The server Ŝ asks the challenger to start a protocol execution (PRead, PUpdate or PAudit) by providing the required information. The challenger starts two parallel executions of the same protocol between C and S, and between itself (acting as the client) and Ŝ, using the information provided by the server. This is repeated polynomially-many times.
Challenge. Ŝ sends an audit request to the challenger, who initiates two parallel PAudit protocols, one between C and S, and one between itself and Ŝ, using the same randomness.
Ŝ Wins the game if his answer is accepted while it differs from that of S; in such a case the game returns l. It is expected that Pr[AuthGameŜ(λ)=1]≦v(λ) for any efficient adversarial server Ŝ, and some negligible function v(λ).
Definition 3.2 (Authenticity). A dynamic PoR scheme is authentic if no PPT adversary Ŝ can win the above game with probability better than negligible in the security parameter.
Retrievability. We want the DPoR to guarantee that if a malicious adversary performs more than d−1 erasures within some level he should not pass the subsequent audit: i.e., if a malicious adversary passes the audit with a non-negligible probability, then he should have sufficient knowledge of all update logs, and hence the whole data. The knowledge is formalized via existence of an efficient extractor that, given black-box access to the malicious adversary, can retrieve all data M. The retrievability game among a challenger, an extractor, and a malicious server Ŝ is as:
Initialization. The challenger creates a copy of an honest client C, and starts the PInit between C and Ŝ.
Setup. Ŝ adaptively chooses a protocol ε {PRead,PUpdate,PAudit} and sends the challenger requests for starting the protocol by providing the required information. The challenger forwards the request to the client who starts up the protocol. The adversary can repeat this process polynomially-many times. Call the final states of the client and malicious server, stc and stŜ, respectively.
Challenge. The extractor repeats the PAudit protocol polynomially-many times with Ŝ in the final state stŜ (via rewinding). Call the extracted data M′.
Definition (Retrievability). An dynamic PoR scheme provider retrievability if there exists a PPT extractor such that for all PPT Ŝ, if Ŝ passes the PAudit protocol with non-negligible probability; then at the end of the retrievability game we have M′=M with overwhelming probability.
Erasure-Coded Authenticated Log
The log store plays an important role in our scheme. We call it the Erasure-Coded Authenticated Log (ECAL). The ECAL first erasure-codes the logs (to guarantee retrievability), and garbles the result in some way (e.g., by encrypting the blocks and permuting them randomly) to make locating any part of the original data difficult for the server. Finally, it provides authenticity using a homomorphic tag. Any scheme supplying retrievability and authenticity can be used to store the update logs. We show that a static PoR scheme does the job, when used hierarchically. Hereafter, we use the compact PoR [25] as our static PoR building block.
Bearing the abovementioned architecture in mind, this means that given a dynamic memory-checking scheme (e.g., DPDP [15]) and a static PoR (e.g., [25]), we can construct an efficient dynamic PoR. Moreover, given an erasure-correcting code scheme and a data authentication scheme (e.g., PDP [1], or any—homomorphic for efficiency—MAC or signature scheme), we can construct a static PoR [25]. Therefore, a dynamic PoR scheme can be constructed given black box access to a dynamic memory-checking scheme, an erasure-correcting code, and a data authentication scheme.
(ECAL). An erasure-coded authenticated log scheme includes the following PPT interactive protocols between a stateful client and a stateful server:
LInit(1λ, 1w, l, M): The client starts up this protocol to initialize an empty ECAL memory on the server, providing as input the security parameter λ, the word size w, and the memory size l. (The memory need not be bounded.) The initial data M is also prepared accordingly and outsourced as well.
LAppend(l): The client uses this protocol to ask the server append the log l to the set of logs already stored.
LAudit( ): The client specifies a challenge vector and uses this protocol to check whether the server keeps storing the logs correctly (i.e., the logs are retrievable). She finally emits an acceptance or a rejection signal.
Both the client and the server create their own local states during execution of the LInit protocol. These local states will be used and updated during execution of the other protocols following LInit. We assume that LInit creates an empty memory at the server, but if the client has some initial logs, she can send them all using LInit and ask the server to store them as the initial logs, or she can append them one-by-one using LAppend. LInit and LAppend do not include verification. If the server misbehaves, it will be caught by the subsequent LAudit executions.
The security definitions of DPoR are applicable to ECAL with very small modifications (essentially just changing the protocol names), hence, we do not repeat them.
DPoR Construction
Let n,kεZ+(k<n), and Σm={0,1}w and Σl={0,1}w′ be finite alphabets. The client is going to outsource a data M=(m1, m2, . . . , mk)εΣmk. She stores M inside a DPDP construction D=KeyGen,PerformUpdate,VerifyUpdate,Challenge,Prove,Verify). Moreover, she initializes an ECAL instantiation E=LInit,LAppend,LAudit) storing the corresponding encoded version. On each update, she updates both D and E, which support read and audit, respectively. Our dynamic PoR construction is as follows:
PInit(1λ, 1w, n, M):
The server runs (MI,sts,stc′,Pst′)←D.PerformUpdate(pk,e(M),e(‘full rewrite’),e(stc′)), where MI is the first version of the client data hosted by the server, and stc′ and Pst
The client executes D.VerifyUpdate(sk,pk,M,‘full rewrite’,stc,stc′,Pst
The client starts E.LInit(1λ, 1w, n, M).
PUpdate (i,OP,v):
PRead(i):
PAudit:
Dynamic PoR Security
If D=(KeyGen,PrepareUpdate,PerformUpdate,VerifyUpdate,Challenge, Prove,Verify) is a secure DPDP scheme, and E=(LInit,LAppend,LAudit) is a secure ECAL scheme, then DPoR=(PInit,PRead,PUpdate,PAudit) is a secure dynamic PoR scheme.
Correctness of DPoR follows from the correctness of DPDP and ECAL. Since DPoR has nothing to do apart from DPDP and ECAL, if both of them operate correctly, then any PRead(i) will return the most recent version stored at the ith location through DPDP, and all PAudit operations will lead to acceptance.
Authenticity of the plain data is provided by the underlying DPDP scheme. Whenever a data is read, the underlying DPDP scheme sends an associated proof of integrity, assuring authenticity. When that fails, the logs will be read through ECAL, which also provides authenticity. In particular, if a PPT adversary A wins the DPoR authenticity game with non-negligible probability, we can use it in a straightforward reduction to construct a PPT algorithm B who breaks security of the underlying ECAL scheme or DPDP protocol with non-negligible probability.
Retrierability immediately follows from retrievability of the ECAL. Since ECAL is secure, it guarantees retrievability of the logs that can be used to reconstruct and retrieve the plaintext data. We bypass the proof details as it is straight forward to reduce the retrievability of our dynamic PoR scheme to that of the underlying ECAL.
Erasure-Coded Authenticated Log
Generic ECAL Construction
Assume that Σm={0, 1}w and Σl={0, 1}wl are two finite alphabets showing the message space and log space, respectively, and each update log is a symbol of Σl. The client initializes a compact PoR scheme CP=(Kg,St,P,V), puts the original data M=(m1, m2, . . . , mk)εΣmk, inside it, and outsources the result to the server. The result will be stored at Buff* (part of the log store) and will not be changed until the next rebuild, which puts the last version of the client data inside a new compact PoR instantiation and outsources the result again into the Buff*. Later, she performs updates (insertion, deletion, or modification) on the original data, and outsources the corresponding update logs at the Buff (part of the log store) in a way that the adversary cannot differentiate or locate the recently-added logs among the already-existing ones. The content of Buff changes as new update logs are outsourced. The client wants to rest assured the logs are retrievable, which means that she can rebuild the final (or any intermediate) version of her data.
We present each update log as a single block in Σl, therefore, each insertion, deletion, or modification operation on the original data appends a new block to the existing logs. Each update log contains the location on the plain data, the operation type, and the new value to be stored. Indeed, a log is of the form iOv, where i is the index on the plain data, Oε{I,D,M} is an update operation (insertion, deletion, or modification), and v is the new value to be stored at the stated index (v is empty for deletion). As an example, let M=‘abcde’ be a message of length 5. The update log ‘2Mf’ states the value at the second location is modified to f. Applying the series of update logs L=(2Mf, 5Mk, 3It, 5My, 4Ms) brings M to the final state M=‘aftsyk’.
The age of an update log is the time elapsed since the time the log is arrived, i.e., the log that arrived first is the oldest one, and the log that arrived most recently is the youngest one. It is important to store the logs ordered according to their age, since applying the same logs in a different order may lead to a different data.
The logs L={ijOjvj}j=1k are ordered according to their age and put in a compact PoR scheme, which generates an encoded version of the logs C=(c1, c2, . . . , cn)εΣn. The encoded logs are then outsourced to the server. The authenticity is handled by the compact PoR, which ensures that the logs are retrievable (or, the server is caught misbehaving). This, in turn, ensures retrievability of the client data even if the outsourced uncoded data is corrupted. Once in every O(n) updates, when the Buff becomes full, a rebuild operation empties the whole Buff, puts the last state of the client's data in a new compact PoR, and stores the result at Buff* (whose size is increased if needed). Note, however, that our rebuild operation is very light compared to that of due to the existence of the memory-checking scheme who can provide the client with the (authenticated) last version of her data, i.e., she does not need to apply all logs on the original data one-by-one to compute the last version. The client only verifies the received data and if accepted, puts it inside a new compact PoR instantiation and outsources the result again at Buff*.
Existing Configurations of the Buff
Linear configuration. Buff can be, in the simplest form, a one-dimensional buffer (of length n) storing the output of the compact PoR [25] constructed over the logs. The client stores a counter ctr to keep the size of the logs, initialized to zero and incremented every time a new log is created. To add a new log (or a set of new logs up to the size of the client local storage) to the Buff, the client should download all the existing outsourced logs, decode it to retrieve the plaintext logs, append the new log, initialize a new compact PoR instantiation to put the logs inside, and upload the result. Although the audit is an O(λ) operation, this construction suffers from the same efficiency problem as the original static PoR: to prevent the adversary from tampering with the recently-added parts of the logs, a small update affects all the outsourced logs. Therefore, the amortized server computation and bandwidth (after n updates) will be: (1+2+ . . . +n)/n=n/2=O(n).
Incremental-buffers configuration. Similar to ORAM, there is a sequence of buffers whose sizes grow at a geometric rate and are organized in a way that the buffer at the ith level stores 2i elements, as shown in
A dynamic PoR scheme using ORAM was proposed by Cash et al. [9]. Since access privacy is not specified by the PoR definition [25, 27], a complete ORAM scheme is not needed. Instead, only the hierarchical buffers idea from the ORAM is taken to preserve the obliviousness of update operations [10, 27]. This means that the adversary can observe the access pattern of the client. With each update, a buffer is totally re-encoded (in a new compact PoR), making it hard for the adversary to correlate the new content to the old one, or to locate the newly-added logs.
If the total size of the (encoded) log memory is n, then there are log(n) levels, first level storing 20=1 log and last level storing 2log(n)−1=n/2 logs. In this structure, an update operation adds a new log to the first level, if it is empty. Otherwise, if the first empty level is j (the client can find it using her local state, as we will see later), then the logs stored at all levels i<j are read by the client, the new log is appended, all are put in a new compact PoR scheme, the result is stored at level j, and all levels i<j are emptied.
Equibuffers Configuration
Direct application of the incremental-buffers configuration to the dynamic PoR is not suitable as it imposes unnecessary burden. First, although the upper-level buffers are small, but the lower-level buffers are of size O(n) that requires O(n) temporary storage at the client to perform the reshuffling. This amount of memory is not available in most current hand-held devices, thus, these devices cannot update the outsourced data. Second, adding some (permanent) local storage to the client will not improve the asymptotic costs of this configuration as pointed to in [33] and proven in Appendix A. Third, managing a buffer divided into levels of different size is complicated for the client.
As an alternative, we propose the equibuffers configuration in which all levels are buffers of the same capacity. If the total size of the Buff is n and there are t levels, each level has size n/t. A simple representation is shown in
Assume there are t levels, each of size n/t on the server, and a local storage of size nδ with 1<nδ≦n/t on the client. The client can accumulate nδ update logs at her local storage and outsource them at once, reducing the amortized update complexity from O(n/t) to O(n1−δ/t). Setting δ=1/2, √{square root over (n)} local memory is available on almost all existing hand-held electronic devices (e.g., around 3 MB memory is required for 10 GB outsourced data).
The update logs are accumulated into the buffers from one end, until all buffers become full. Then, the client can either ask for further storage, or perform a rebuild that stores the (encoded) last state of her data at Buff* and resets Buff. This rebuild, however, can be performed using a computer.
ECAL Protocols
In both hierarchical configurations, the client's local state contains the keys of the compact PoR schemes in all levels and a counter ctr, which is incremented with each update. Using the ctr, the client can find the buffer that the current update log should be directed to. One can think of these hierarchical buffers as a one-dimensional buffer storing the update logs sequentially, as represented in
The general ECAL construction is as follows:
LAppend(l); is used to add a new update log, l. The client:
The server is responsible for responding the clients read query for buffer j, and then replacing its contents with the new ones received from the client.
Communication-Efficiency for Audits.
If all logs appear together, we can put them all inside a single compact PoR. But they grow gradually over the time, and we cannot simply add new logs to the existing ones inside a compact PoR instantiation. That is why we use the hierarchical buffer with each level as a separate compact PoR instantiation that generates separate (aggregated) proofs. These proofs cannot be aggregated further with the proofs of the other levels, and this leads to increased communication.
To solve the problem, we change the tag generation algorithm of the PDP inside the compact PoR in a way that we can handle adding later logs into the same PoR instantiation, without leading to replay attacks. Indeed, we can aggregate all challenged tags (of all buffers) into one, and reduce communication. We call the resulting scheme using this modified PDP the modified compact PoR. This brings another advantage: the client needs to store only one pair of keys since there is only one PDP instantiation in use.
In PDP [1], a random number v is generated and concatenated with the block number: Wi=v∥i. Wi is used in tag generation to bind the generated tag to a specific PDP construction and the corresponding block. The tags are computed as ti=(h(Wi)gm
The proof generation by the server remains the same. Our modification only affects the verification: the client should use the correct v values for each buffer. This, however, is not complicated since for each full buffer buffj, CodeRate* Σi=0j|buffj| will be used as input to the PRF, where CodeRate is the code rate of the compact PoR in use.
For the current working buffer, the largest value ≦ctr that is a multiple of the client local storage size is used. Thus, the client can easily compute the required v values for verification, and does not need to keep different keys locally.
The prime result of this modification is that the server can aggregate all challenged tags into one, and send it together with the corresponding hash value to the client. This reduces the proof size (and the client storage for keys) from O(λt) to O(λ) in audits, where t is the number of memory levels on the server.
We compare the three configurations and select the optimized ones regarding the audit bandwidth. The server provides a proof for all audit commands coming from the client. Different configurations pose different proof sizes:
Linear.
There is only one modified compact PoR instantiation. O(λ) blocks (and their tags) are accessed (and aggregated) to generate the proof Thus, both the server computation and the communication are O(λ).
Incremental and Equibuffers.
There are t levels, and hence, t modified compact PoR instantiations. The challenge samples O(λ) blocks at each level. The server accesses all challenged blocks (and their tags), leading to O(λt) computation. Using the stated optimization, the proofs of all levels can be aggregated together to reduce the proof size from O(λt) to O(λ).
Regarding the above discussion, we observe that applying our modification on the equibuffers configuration, and using client local storage of size a level (at the server) achieves the best performance. The remaining thing is choosing t, as it directly affects the memory requirements and performance: the level capacity affects the update cost, and the number of levels affects the audit cost, directly. Having t=√{square root over (n)} levels, each of size √{square root over (n)}, balances the update and audit costs. Therefore, the Buff (of size n on the server) is divided into √{square root over (n)} buffers buff1, . . . , buff√{square root over (n)}, each of size √{square root over (n)}. (Buff*, of size n, stores the encoded version of the original data.)
With a local memory locbuff of size nδ (0≦δ≦1/2, up to the size of a level), the client accumulates the most recent logs and outsources them together, which decreases the (amortized) update complexity from O(nδ) to O(n1/2−δ). If δ=1/2, the whole client memory is sent to the server, who puts it on a level without further computation, and the updates complexity will be O(1). Moreover, there is no need to read some logs from the server and combine with those on the client side. A comparison of the operation complexities for different ECAL configurations is given in Table 1.
ECAL Security
Theorem 4.1 If CP=(Kg,St,P,V) is a secure compact PoR scheme [25], then E=(LInit,LAppend,LAudit) is a secure ECAL scheme according to (modified versions of) definitions 3.2 and 3.3.
Correctness immediately follows from the correctness of the compact PoR scheme.
Authenticity is provided by the underlying compact PoR scheme. The linear buffer case is obvious. The incremental-buffers case was shown by others. We treat the equibuffers construction below, then focus on our communication-efficient optimized version.
For the hierarchical equibuffers case, assume that there are t levels, and each level is a distinct compact PoR instantiation. If a PPT adversary A wins the ECAL authenticity game with non-negligible probability, we can use it to construct a PPT algorithm B who breaks the security of at least one of the compact PoR schemes used in one of the levels, with non-negligible probability. B acts as the challenger in the ECAL game with the adversary A, and simultaneously, plays role of the server in compact PoR game played with the compact PoR challenger C. He receives the public key of a compact PoR scheme from C, and produces t−1 other pairs of compact PoR public and private keys himself. Then, he guesses some i and puts the received key in ith position, and sends the t public keys to A.
From this point on, B just keeps forwarding messages from A on the level i to C, and vice versa. For other levels, he himself performs the operations.
When A wins the ECAL security game, if the guessed level i was the related compact PoR level, then B would also win the compact PoR security game. Thus, if A passes the ECAL verification with non-negligible probability p, then B passes the compact PoR verification with probability at least p/t. Since we employ secure compact PoRs, p/t must be negligible, which implies that p is negligible, hence, A has negligible probability of winning the ECAL game. Our ECAL scheme is secure if the underlying compact PoRs are.
When the communication-efficient configuration is used, the reduction is even simpler (for both incremental- and equi-buffers). All levels use the same key. The only difference is that, when C sends an append operation to B, then B internally calculates the associated level i and sends the related append operation to A. Further observe that the only difference of our optimization from the original compact PoR is the tag calculation. Since we employ the same PRF idea, with just a slightly different input, this does not affect the security. Therefore, if A wins with probability p. B wins with the same probability.
Retrievability. We give a high level proof of retrievability here without going into details, since the proof is similar to the already-existing proofs.
We reduce extractability of the incremental- and equi-buffers constructions to that of the compact PoR (the linear case is exactly compact PoR). There are multiple compact PoR instances in both constructions. Due to the security of compact PoR, if the server manipulates more than d−1 blocks in some level, he will be caught with high probability (see [25]). Hence, if he can pass the verification, each level is extractable, which means that the portion of logs stored in that compact PoR instantiation is retrievable with overwhelming probability. Putting together all these PoR instantiations guarantees retrievability of the whole logs stored in these constructions with overwhelming probability. For the communication-efficient configuration, the compact PoR extractability proof is again applicable, since changing the PRF input in the tag does not affect extractability.
Comparison to Previous Work
Investigating the equibuffer configuration of ECAL in detail and using the complexities in Table 1 reveals that the client storage (Sclient), and the update and audit costs (Cupdate and Caudit) are related together via the following formula (ignoring factors depending on the security parameter): Sclient*Cupdate*Caudit=O(n). This formula describes a nice trade-off between the client storage, and the update and audit costs, that can be used to design dynamic PoR schemes with different requirements. A similar statement is given by Cash et al. [9] for the linear configuration (in the Appendix A of their paper), such that for any δ>0, using blocks of size nδ the complexity of read, update, and audit will be O(1), O(nδ), and O(n1−δ), respectively.
Similarly, our scheme also covers the schemes given in [10, 27]. Using the incremental-buffers configuration together with MAC instead of PDP tags reduces our scheme to [27]. If, in addition, the incremental-buffers together with MAC are used to store the plain data as a memory-checking scheme instead of DPDP, the resulting scheme will be. However, our schemes pose important advantages compared the previous work [9, 10, 27]. First, the bandwidth optimization makes the audit and (amortized) update bandwidth O(λ), which are optimal. Second, our equibuffer configuration with reasonable amount of permanent client storage, i.e., O(√{square root over (n)}) that is ˜3 MB for an outsourced data of size 10 GB, makes possible using smart phones (and other hand-held electronic devices) for updating the outsourced data.
Table 2 represents a comparison among the dynamic PoR schemes. The operation complexities of our schemes are computed using the version with the equibuffer optimization and the audit bandwidth optimization applied on. These two optimizations can be applied independently. The bandwidth optimization, for instance, can be applied on top of previous work [27, 10] achieving optimal audit bandwidth in those configurations as well. Therefore, we manage to obtain the most general and efficient DPoR construction known.
Since outsourcing the whole data as a single block requires downloading the whole data for later audits, the data is divided into blocks before being outsourced.
By performing subsequent updates on the outsourced data, the server learns some information about the updates, and hence, may bypass the whole updates and answer the client queries using the old data. To prevent this misbehavior, a single data should affect the whole outsourced data, which is not efficient. To balance these two conflicting properties, we append the subsequent updates as logs to the outsourced data, and audit the data and the logs to investigate the integrity of the correct (the most recent version of the) outsourced data.
To provide the same conflicting properties (stated in step 128), we divide the log memory into smaller parts. The advantage of this partitioning is that each update affects a small part of the logs, not the whole logs. However, when the logs memory becomes full, all logs are applied on the data, and the log memory becomes empty for later updates.
Each update on the data leads to a log. Applying all the outsourced logs on the outsourced data, generates the most recent version of the data.
The above descriptions of the present invention are intended to be illustrative only. Numerous alternative methods may be devised by persons skilled in the art without departing from the scope of the following claims.
| Number | Name | Date | Kind |
|---|---|---|---|
| 8650434 | Orsini et al. | Feb 2014 | B2 |
| 9436722 | Bent | Sep 2016 | B1 |
| 9460008 | Leshinsky | Oct 2016 | B1 |
| 20120166576 | Orsini | Jun 2012 | A1 |
| 20130159452 | Saldana De Fuentes | Jun 2013 | A1 |
| 20130254538 | Orsini | Sep 2013 | A1 |
| Number | Date | Country | |
|---|---|---|---|
| 20170041395 A1 | Feb 2017 | US |
