Efficient consistency proofs for generalized queries on a committed database

Rafail Ostrovsky, Charles Rackoff, Adam Davison Smith

Research output: Contribution to journalArticle

23 Citations (Scopus)

Abstract

A consistent query protocol (CQP) allows a database owner to publish a very short string c which commits her and everybody else to a particular database D, so that any copy of the database can later be used to answer queries and give short proofs that the answers are consistent with the commitment c. Here commits means that there is at most one database D that anybody can find (in polynomial time) which is consistent with c. (Unlike in some previous work, this strong guarantee holds even for owners who try to cheat while creating c.) Efficient CQPS for membership and one-dimensional range queries are known [4, 11,16]: given a query pair a, b ∈ ℝ the server answers with all the keys in the database which lie in the interval [a, b] and a proof that the answer is correct. This paper explores CQPS for more general types of databases. We put forward a general technique for constructing CQPS for any type of query, assuming the existence of a data structure/algorithm with certain inherent robustness properties that we define (called a data robust algorithm). We illustrate our technique by constructing an efficient protocol for orthogonal range queries, where the database keys are points in ℝd and a query asks for all keys in a rectangle [a1,b1] x ... x [ad,bd]. Our data-robust algorithm is within a O (log N) factor of the best known standard data structure (a range tree, due to Bentley [2]). We modify our protocol so that it is also private, that is, the proofs leak no information about the database beyond the query answers. We show a generic modification to ensure privacy based on zero-knowledge proofs, and also give a new, more efficient protocol tailored to hash trees.

Original languageEnglish (US)
Pages (from-to)1041-1053
Number of pages13
JournalLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
Volume3142
StatePublished - Dec 1 2004

Fingerprint

Query
Network protocols
Range Query
Robust Algorithm
Data structures
Data Structures
Zero-knowledge Proof
Rectangle
Privacy
Polynomial time
Servers
Server
Strings
Polynomials
Robustness
Interval
Range of data

All Science Journal Classification (ASJC) codes

  • Theoretical Computer Science
  • Computer Science(all)

Cite this

@article{8a62e2447deb4fefb1b00f11cc7c5278,
title = "Efficient consistency proofs for generalized queries on a committed database",
abstract = "A consistent query protocol (CQP) allows a database owner to publish a very short string c which commits her and everybody else to a particular database D, so that any copy of the database can later be used to answer queries and give short proofs that the answers are consistent with the commitment c. Here commits means that there is at most one database D that anybody can find (in polynomial time) which is consistent with c. (Unlike in some previous work, this strong guarantee holds even for owners who try to cheat while creating c.) Efficient CQPS for membership and one-dimensional range queries are known [4, 11,16]: given a query pair a, b ∈ ℝ the server answers with all the keys in the database which lie in the interval [a, b] and a proof that the answer is correct. This paper explores CQPS for more general types of databases. We put forward a general technique for constructing CQPS for any type of query, assuming the existence of a data structure/algorithm with certain inherent robustness properties that we define (called a data robust algorithm). We illustrate our technique by constructing an efficient protocol for orthogonal range queries, where the database keys are points in ℝd and a query asks for all keys in a rectangle [a1,b1] x ... x [ad,bd]. Our data-robust algorithm is within a O (log N) factor of the best known standard data structure (a range tree, due to Bentley [2]). We modify our protocol so that it is also private, that is, the proofs leak no information about the database beyond the query answers. We show a generic modification to ensure privacy based on zero-knowledge proofs, and also give a new, more efficient protocol tailored to hash trees.",
author = "Rafail Ostrovsky and Charles Rackoff and Smith, {Adam Davison}",
year = "2004",
month = "12",
day = "1",
language = "English (US)",
volume = "3142",
pages = "1041--1053",
journal = "Lecture Notes in Computer Science",
issn = "0302-9743",
publisher = "Springer Verlag",

}

Efficient consistency proofs for generalized queries on a committed database. / Ostrovsky, Rafail; Rackoff, Charles; Smith, Adam Davison.

In: Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), Vol. 3142, 01.12.2004, p. 1041-1053.

Research output: Contribution to journalArticle

TY - JOUR

T1 - Efficient consistency proofs for generalized queries on a committed database

AU - Ostrovsky, Rafail

AU - Rackoff, Charles

AU - Smith, Adam Davison

PY - 2004/12/1

Y1 - 2004/12/1

N2 - A consistent query protocol (CQP) allows a database owner to publish a very short string c which commits her and everybody else to a particular database D, so that any copy of the database can later be used to answer queries and give short proofs that the answers are consistent with the commitment c. Here commits means that there is at most one database D that anybody can find (in polynomial time) which is consistent with c. (Unlike in some previous work, this strong guarantee holds even for owners who try to cheat while creating c.) Efficient CQPS for membership and one-dimensional range queries are known [4, 11,16]: given a query pair a, b ∈ ℝ the server answers with all the keys in the database which lie in the interval [a, b] and a proof that the answer is correct. This paper explores CQPS for more general types of databases. We put forward a general technique for constructing CQPS for any type of query, assuming the existence of a data structure/algorithm with certain inherent robustness properties that we define (called a data robust algorithm). We illustrate our technique by constructing an efficient protocol for orthogonal range queries, where the database keys are points in ℝd and a query asks for all keys in a rectangle [a1,b1] x ... x [ad,bd]. Our data-robust algorithm is within a O (log N) factor of the best known standard data structure (a range tree, due to Bentley [2]). We modify our protocol so that it is also private, that is, the proofs leak no information about the database beyond the query answers. We show a generic modification to ensure privacy based on zero-knowledge proofs, and also give a new, more efficient protocol tailored to hash trees.

AB - A consistent query protocol (CQP) allows a database owner to publish a very short string c which commits her and everybody else to a particular database D, so that any copy of the database can later be used to answer queries and give short proofs that the answers are consistent with the commitment c. Here commits means that there is at most one database D that anybody can find (in polynomial time) which is consistent with c. (Unlike in some previous work, this strong guarantee holds even for owners who try to cheat while creating c.) Efficient CQPS for membership and one-dimensional range queries are known [4, 11,16]: given a query pair a, b ∈ ℝ the server answers with all the keys in the database which lie in the interval [a, b] and a proof that the answer is correct. This paper explores CQPS for more general types of databases. We put forward a general technique for constructing CQPS for any type of query, assuming the existence of a data structure/algorithm with certain inherent robustness properties that we define (called a data robust algorithm). We illustrate our technique by constructing an efficient protocol for orthogonal range queries, where the database keys are points in ℝd and a query asks for all keys in a rectangle [a1,b1] x ... x [ad,bd]. Our data-robust algorithm is within a O (log N) factor of the best known standard data structure (a range tree, due to Bentley [2]). We modify our protocol so that it is also private, that is, the proofs leak no information about the database beyond the query answers. We show a generic modification to ensure privacy based on zero-knowledge proofs, and also give a new, more efficient protocol tailored to hash trees.

UR - http://www.scopus.com/inward/record.url?scp=35048885162&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=35048885162&partnerID=8YFLogxK

M3 - Article

VL - 3142

SP - 1041

EP - 1053

JO - Lecture Notes in Computer Science

JF - Lecture Notes in Computer Science

SN - 0302-9743

ER -