How to construct random functions
Journal of the ACM (JACM)
Programming pearls
Small-bias probability spaces: efficient constructions and applications
SIAM Journal on Computing
An efficient representation for sparse sets
ACM Letters on Programming Languages and Systems (LOPLAS)
The invasiveness of off-line memory checking
STOC '02 Proceedings of the thiry-fourth annual ACM symposium on Theory of computing
Foundations of Cryptography: Basic Tools
Foundations of Cryptography: Basic Tools
The Design and Analysis of Computer Algorithms
The Design and Analysis of Computer Algorithms
Foundations of Cryptography: Volume 2, Basic Applications
Foundations of Cryptography: Volume 2, Basic Applications
Towards Constant Bandwidth Overhead Integrity Checking of Untrusted Data
SP '05 Proceedings of the 2005 IEEE Symposium on Security and Privacy
The Complexity of Online Memory Checking
FOCS '05 Proceedings of the 46th Annual IEEE Symposium on Foundations of Computer Science
Pors: proofs of retrievability for large files
Proceedings of the 14th ACM conference on Computer and communications security
Integrity checking in cryptographic file systems with constant trusted storage
SS'07 Proceedings of 16th USENIX Security Symposium on USENIX Security Symposium
Compact Proofs of Retrievability
ASIACRYPT '08 Proceedings of the 14th International Conference on the Theory and Application of Cryptology and Information Security: Advances in Cryptology
Proceedings of the 15th ACM conference on Computer and communications security
The complexity of online memory checking
Journal of the ACM (JACM)
MAC Precomputation with Applications to Secure Memory
ISC '09 Proceedings of the 12th International Conference on Information Security
Fair and dynamic proofs of retrievability
Proceedings of the first ACM conference on Data and application security and privacy
Optimal authenticated data structures with multilinear forms
Pairing'10 Proceedings of the 4th international conference on Pairing-based cryptography
Optimal verification of operations on dynamic sets
CRYPTO'11 Proceedings of the 31st annual conference on Advances in cryptology
Verifiable delegation of computation over large datasets
CRYPTO'11 Proceedings of the 31st annual conference on Advances in cryptology
Bus and memory protection through chain-generated and tree-verified IV for multiprocessors systems
Future Generation Computer Systems
Transparent, distributed, and replicated dynamic provable data possession
ACNS'13 Proceedings of the 11th international conference on Applied Cryptography and Network Security
Hi-index | 0.00 |
We consider the problem of memory checking, where a user wants to maintain a large database on a remote server but has only limited local storage. The user wants to use the small (but trusted and secret) local storage to detect faults in the large (but public and untrusted) remote storage. A memory checker receives from the user store and retrieve operations to the large database. The checker makes its own requests to the (untrusted) remote storage and receives answers to these requests. It then uses these responses, together with its small private and reliable local memory, to ascertain that all requests were answered correctly, or to report faults in the remote storage (the public memory). A fruitful line of research investigates the complexity of memory checking in terms of the number of queries the checker issues per user request (query complexity) and the size of the reliable local memory (space complexity). Blum et al., who first formalized the question, distinguished between online checkers (that report faults as soon as they occur) and offline checkers (that report faults only at the end of a long sequence of operations). In this work we revisit the question of memory checking, asking how efficient can memory checking be? For online checkers, Blum et al. provided a checker with logarithmic query complexity in n , the database size. Our main result is a lower bound: we show that for checkers that access the remote storage in a deterministic and non-adaptive manner (as do all known memory checkers), their query complexity must be at least *** (logn /loglogn ). To cope with this negative result, we show how to trade off the read and write complexity of online memory checkers: for any desired logarithm base d , we construct an online checker where either reading or writing is inexpensive and has query complexity O (log d n ). The price for this is that the other operation (write or read respectively) has query complexity O (d ·log d n ). Finally, if even this performance is unacceptable, offline memory checking may be an inexpensive alternative. We provide a scheme with O (1) amortized query complexity, improving Blum et al.'s construction, which only had such performance for long sequences of at least n operations.