Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:1406.0589 · IEEE Journal of Selected Topics in Quantum Electronics

Postprocessing of the Oblivious Key in Quantum Private Query

Fei Gao, Bin Liu, Wei Huang, Qiaoyan Wen

Published Sep 16, 2014• 125 citations
arXivHTMLPDF

Abstract

Private query is a kind of cryptographic protocols to protect both users' privacies in their communication. For instance, Alice wants to buy one item from Bob's database. The aim of private query is to ensure that Alice can get only one item from Bob, and simultaneously, Bob cannot know which one was taken by Alice. In pursuing high security and efficiency, some quantum private query protocols were proposed. As a practical model, Quantum-Oblivious-Key-Transfer (QOKT)-based private query, which utilizes a QOKT protocol to distribute oblivious key between Alice and Bob and then applies the key to achieve the aim of private query, has drawn much attention. Here, we focus on postprocessing of the oblivious key, and the following two contributions are achieved. 1) We analyze three recently proposed dilution methods and find two of them have serious security loophole. That is, Alice can illegally obtain much additional information about Bob's database by multiple queries. For example, Alice can obtain the whole database, which contains 104items, by only 53.4 queries averagely. 2) We present an effective error-correction method for the oblivious key, which can address the realistic scenario with channel noises and make QOKT-based private query more practical.

DOI
10.1109/jstqe.2014.2358192

Related papers

Practical quantum private query with better performance in resisting joint-measurement attack

Chun‐Yan Wei, Tian‐Yin Wang, Fei Gao

As a kind of practical protocol, quantum-key-distribution (QKD)-based quantum private queries (QPQs) have drawn lots of attention. However, joint-measurement (JM) attack poses a noticeable threat to the database security in such protocols. That is, by JM attack a malicious user can illegally elicit many more items from the database than the average amount an honest one can obtain. Taking Jacobi et al.'s protocol as an example, by JM attack a malicious user can obtain as many as 500 bits, instead of the expected 2.44 bits, from a ${10}^{4}$-bit database in one query. It is a noticeable security flaw in theory, and would also arise in application with the development of quantum memories. To solve this problem, we propose a QPQ protocol based on a two-way QKD scheme, which behaves much better in resisting JM attack. Concretely, the user Alice cannot get more database items by conducting JM attack on the qubits because she has to send them back to Bob (the database holder) before knowing which of them should be jointly measured. Furthermore, JM attack by both Alice and Bob would be detected with certain probability, which is quite different from previous protocols. Moreover, our protocol retains the good characters of QKD-based QPQs, e.g., it is loss tolerant and robust against quantum memory attack.

Physical Review A•Apr 12, 2016•140 citations

Practical private database queries based on a quantum-key-distribution protocol

Markus Jakobi, Christoph Simon, Nicolas Gisin +4 more

Private queries allow a user, Alice, to learn an element of a database held by a provider, Bob, without revealing which element she is interested in, while limiting her information about the other elements. We propose to implement private queries based on a quantum-key-distribution protocol, with changes only in the classical postprocessing of the key. This approach makes our scheme both easy to implement and loss tolerant. While unconditionally secure private queries are known to be impossible, we argue that an interesting degree of security can be achieved by relying on fundamental physical principles instead of unverifiable security assumptions in order to protect both the user and the database. We think that the scope exists for such practical private queries to become another remarkable application of quantum information in the footsteps of quantum key distribution.

arXiv:1002.4360•Physical Review A•Feb 2, 2011•224 citations

Reexamination of the realtime protection for user privacy in practical quantum private query

Chun‐Yan Wei, Xiao‐Qiu Cai, Tian‐Yin Wang

Abstract Quantum private query (QPQ) is the quantum version for symmetrically private information retrieval. However, the user privacy in QPQ is generally guarded in the delayed and cheat-sensitive way. That is, the dishonest database holder Bob’s cheating to elicit user privacy can only be discovered after the protocol is finished (when the user finds some errors in the retrieved database item). Such delayed detection may cause very unpleasant results for the user Alice in real-life applications. Without the realtime conscious of privacy leaking, Alice may make faulty decisions according to the received faulty item and suffer great loss. Worse yet, it is difficult for Alice to accuse a dishonest database to any one else though she can detect the cheating. Current efforts to protect user privacy in realtime in existing QPQ protocols mainly use two techniques, i.e. adding an honesty checking on the database or allowing the user to reorder the qubits. We reexamine these two kinds of QPQ protocols and find neither of them can work very well. We give concrete cheating strategies for both participants and show that honesty checking of inner participant should be dealt more carefully in for example the choosing of checking qubits. Finally, we give an idea to realize realtime detection of dishonest database in QPQ of blocks (i.e. multi-bit database items).

arXiv:2407.19147•Physica Scripta•Nov 18, 2024•1 citation

Error Tolerance Bound in QKD-Based Quantum Private Query

Chun‐Yan Wei, Xiao‐Qiu Cai, Tian‐Yin Wang +3 more

Most existing quantum private query (QPQ) protocols can hardly work in the presence of noise. The user Alice may obtain a false database item in noisy environments and both participants may cheat under the disguise of noise, so dealing with the noise needs an overall consideration of error correction, user privacy and database security. However, the only two existing protocols aiming to correct errors in QPQ lack such an overall consideration (at least one party's privacy can be revealed), and they did not estimate what extent of errors can be tolerated (actually, noise is seldom discussed in quantum two-party secure computations, and to the best of our knowledge, relevant bounds on tolerable errors remain unattainable so far). To solve this problem, we first exemplify how one participant reveals the other party's privacy in the existing QPQ protocols aiming to correct errors. Then we propose a practical protocol which can really work via noisy channel, that is, the error rate of the retrieved database item is reduced significantly and both parties' privacy are well protected. Besides, we deduce that the final error rate, user privacy and database security are pairwise in a “trade-off” relationship. By balancing them according to the required level of security and reliability, we obtain an upper bound on tolerable errors.

IEEE Journal on Selected Areas in Communications•Jan 23, 2020•60 citations

Practical quantum private query of blocks based on unbalanced-state Bennett-Brassard-1984 quantum-key-distribution protocol

Chun‐Yan Wei, Fei Gao, Qiaoyan Wen +1 more

Until now, the only kind of practical quantum private query (QPQ), quantum-key-distribution (QKD)-based QPQ, focuses on the retrieval of a single bit. In fact, meaningful message is generally composed of multiple adjacent bits (i.e., a multi-bit block). To obtain a message a1a2···al from database, the user Alice has to query l times to get each ai. In this condition, the server Bob could gain Alice's privacy once he obtains the address she queried in any of the l queries, since each a(i) contributes to the message Alice retrieves. Apparently, the longer the retrieved message is, the worse the user privacy becomes. To solve this problem, via an unbalanced-state technique and based on a variant of multi-level BB84 protocol, we present a protocol for QPQ of blocks, which allows the user to retrieve a multi-bit block from database in one query. Our protocol is somewhat like the high-dimension version of the first QKD-based QPQ protocol proposed by Jacobi et al., but some nontrivial modifications are necessary.

Scientific Reports•Dec 18, 2014•65 citations

Towards communication-efficient quantum oblivious key distribution

M. V. Panduranga Rao, Markus Jakobi

Symmetrically private information retrieval, a fundamental problem in the field of secure multiparty computation, is defined as follows: A database $D$ of $N$ bits held by Bob is queried by a user Alice who is interested in the bit ${D}_{b}$ in such a way that (1) Alice learns ${D}_{b}$ and only ${D}_{b}$ and (2) Bob does not learn anything about Alice's choice $b$. While solutions to this problem in the classical domain rely largely on unproven computational complexity theoretic assumptions, it is also known that perfect solutions that guarantee both database and user privacy are impossible in the quantum domain. Jakobi et al. [Phys. Rev. A 83, 022301 (2011)] proposed a protocol for oblivious transfer using well-known quantum key device (QKD) techniques to establish an oblivious key to solve this problem. Their solution provided a good degree of database and user privacy (using physical principles like the impossibility of perfectly distinguishing nonorthogonal quantum states and the impossibility of superluminal communication) while being loss-resistant and implementable with commercial QKD devices (due to the use of the Scarani-Acin-Ribordy-Gisin 2004 protocol). However, their quantum oblivious key distribution (QOKD) protocol requires a communication complexity of $O(N\mathrm{log}N)$. Since modern databases can be extremely large, it is important to reduce this communication as much as possible. In this paper, we first suggest a modification of their protocol wherein the number of qubits that need to be exchanged is reduced to $O(N)$. A subsequent generalization reduces the quantum communication complexity even further in such a way that only a few hundred qubits are needed to be transferred even for very large databases.

arXiv:1208.2501•Physical Review A•Jan 28, 2013•63 citations
Private query is a kind of cryptographic protocols to protect both users' privacies in their communication. For instance, Alice wants to buy one item from Bob's database. The aim of private query is to ensure that Alice can get only one item from Bob, and simultaneously, Bob cannot know which one was taken by Alice. In pursuing high security and efficiency, some quantum private query protocols were proposed. As a practical model, Quantum-Oblivious-Key-Transfer (QOKT)-based private query, which utilizes a QOKT protocol to distribute oblivious key between Alice and Bob and then applies the key to achieve the aim of private query, has drawn much attention. Here, we focus on postprocessing of the oblivious key, and the following two contributions are achieved. 1) We analyze three recently proposed dilution methods and find two of them have serious security loophole. That is, Alice can illegally obtain much additional information about Bob's database by multiple queries. For example, Alice can obtain the whole database, which contains 104items, by only 53.4 queries averagely. 2) We present an effective error-correction method for the oblivious key, which can address the realistic scenario with channel noises and make QOKT-based private query more practical.
As a kind of practical protocol, quantum-key-distribution (QKD)-based quantum private queries (QPQs) have drawn lots of attention. However, joint-measurement (JM) attack poses a noticeable threat to the database security in such protocols. That is, by JM attack a malicious user can illegally elicit many more items from the database than the average amount an honest one can obtain. Taking Jacobi et al.'s protocol as an example, by JM attack a malicious user can obtain as many as 500 bits, instead of the expected 2.44 bits, from a 104{10}^{4}104-bit database in one query. It is a noticeable security flaw in theory, and would also arise in application with the development of quantum memories. To solve this problem, we propose a QPQ protocol based on a two-way QKD scheme, which behaves much better in resisting JM attack. Concretely, the user Alice cannot get more database items by conducting JM attack on the qubits because she has to send them back to Bob (the database holder) before knowing which of them should be jointly measured. Furthermore, JM attack by both Alice and Bob would be detected with certain probability, which is quite different from previous protocols. Moreover, our protocol retains the good characters of QKD-based QPQs, e.g., it is loss tolerant and robust against quantum memory attack.
Private queries allow a user, Alice, to learn an element of a database held by a provider, Bob, without revealing which element she is interested in, while limiting her information about the other elements. We propose to implement private queries based on a quantum-key-distribution protocol, with changes only in the classical postprocessing of the key. This approach makes our scheme both easy to implement and loss tolerant. While unconditionally secure private queries are known to be impossible, we argue that an interesting degree of security can be achieved by relying on fundamental physical principles instead of unverifiable security assumptions in order to protect both the user and the database. We think that the scope exists for such practical private queries to become another remarkable application of quantum information in the footsteps of quantum key distribution.
Abstract Quantum private query (QPQ) is the quantum version for symmetrically private information retrieval. However, the user privacy in QPQ is generally guarded in the delayed and cheat-sensitive way. That is, the dishonest database holder Bob’s cheating to elicit user privacy can only be discovered after the protocol is finished (when the user finds some errors in the retrieved database item). Such delayed detection may cause very unpleasant results for the user Alice in real-life applications. Without the realtime conscious of privacy leaking, Alice may make faulty decisions according to the received faulty item and suffer great loss. Worse yet, it is difficult for Alice to accuse a dishonest database to any one else though she can detect the cheating. Current efforts to protect user privacy in realtime in existing QPQ protocols mainly use two techniques, i.e. adding an honesty checking on the database or allowing the user to reorder the qubits. We reexamine these two kinds of QPQ protocols and find neither of them can work very well. We give concrete cheating strategies for both participants and show that honesty checking of inner participant should be dealt more carefully in for example the choosing of checking qubits. Finally, we give an idea to realize realtime detection of dishonest database in QPQ of blocks (i.e. multi-bit database items).
Most existing quantum private query (QPQ) protocols can hardly work in the presence of noise. The user Alice may obtain a false database item in noisy environments and both participants may cheat under the disguise of noise, so dealing with the noise needs an overall consideration of error correction, user privacy and database security. However, the only two existing protocols aiming to correct errors in QPQ lack such an overall consideration (at least one party's privacy can be revealed), and they did not estimate what extent of errors can be tolerated (actually, noise is seldom discussed in quantum two-party secure computations, and to the best of our knowledge, relevant bounds on tolerable errors remain unattainable so far). To solve this problem, we first exemplify how one participant reveals the other party's privacy in the existing QPQ protocols aiming to correct errors. Then we propose a practical protocol which can really work via noisy channel, that is, the error rate of the retrieved database item is reduced significantly and both parties' privacy are well protected. Besides, we deduce that the final error rate, user privacy and database security are pairwise in a “trade-off” relationship. By balancing them according to the required level of security and reliability, we obtain an upper bound on tolerable errors.
Until now, the only kind of practical quantum private query (QPQ), quantum-key-distribution (QKD)-based QPQ, focuses on the retrieval of a single bit. In fact, meaningful message is generally composed of multiple adjacent bits (i.e., a multi-bit block). To obtain a message a1a2···al from database, the user Alice has to query l times to get each ai. In this condition, the server Bob could gain Alice's privacy once he obtains the address she queried in any of the l queries, since each a(i) contributes to the message Alice retrieves. Apparently, the longer the retrieved message is, the worse the user privacy becomes. To solve this problem, via an unbalanced-state technique and based on a variant of multi-level BB84 protocol, we present a protocol for QPQ of blocks, which allows the user to retrieve a multi-bit block from database in one query. Our protocol is somewhat like the high-dimension version of the first QKD-based QPQ protocol proposed by Jacobi et al., but some nontrivial modifications are necessary.
Symmetrically private information retrieval, a fundamental problem in the field of secure multiparty computation, is defined as follows: A database DDD of NNN bits held by Bob is queried by a user Alice who is interested in the bit Db{D}_{b}Db​ in such a way that (1) Alice learns Db{D}_{b}Db​ and only Db{D}_{b}Db​ and (2) Bob does not learn anything about Alice's choice bbb. While solutions to this problem in the classical domain rely largely on unproven computational complexity theoretic assumptions, it is also known that perfect solutions that guarantee both database and user privacy are impossible in the quantum domain. Jakobi et al. [Phys. Rev. A 83, 022301 (2011)] proposed a protocol for oblivious transfer using well-known quantum key device (QKD) techniques to establish an oblivious key to solve this problem. Their solution provided a good degree of database and user privacy (using physical principles like the impossibility of perfectly distinguishing nonorthogonal quantum states and the impossibility of superluminal communication) while being loss-resistant and implementable with commercial QKD devices (due to the use of the Scarani-Acin-Ribordy-Gisin 2004 protocol). However, their quantum oblivious key distribution (QOKD) protocol requires a communication complexity of O(NlogN)O(N\mathrm{log}N)O(NlogN). Since modern databases can be extremely large, it is important to reduce this communication as much as possible. In this paper, we first suggest a modification of their protocol wherein the number of qubits that need to be exchanged is reduced to O(N)O(N)O(N). A subsequent generalization reduces the quantum communication complexity even further in such a way that only a few hundred qubits are needed to be transferred even for very large databases.