Logo
ScienceStack
Table of Contents
Fetching ...
Sign In

Secure Query Processing with Linear Complexity

Qiyao Luo, Yilei Wang, Wei Dong, Ke Yi

TL;DR

This paper targets efficient secure query processing when data resides with multiple mutually distrustful parties. It introduces LINQ, the first protocol achieving linear time and communication in the 3-party model for a broad class of queries called free-connex, closely matching plaintext performance for weighted joins and aggregations. The method hinges on a hash-based consistent sort, ranks, and a novel hash-sort-merge-join that enables linear two-way and multi-way joins while preserving privacy. A complete system implementation demonstrates substantial practical gains over prior MPC baselines in both relatio nal and graph workloads, signaling a path toward practical MPC-enabled analytics. The work also discusses extending to a three-server model and outlines open questions for 2PC linear-time possibilities.

Abstract

We present LINQ, the first join protocol with linear complexity (in both running time and communication) under the secure multi-party computation model (MPC). It can also be extended to support all free-connex queries, a large class of select-join-aggregate queries, still with linear complexity. This matches the plaintext result for the query processing problem, as free-connex queries are the largest class of queries known to be solvable in linear time in plaintext. We have then built a query processing system based on LINQ, and the experimental results show that LINQ significantly outperforms the state of the art. For example, it can finish a query on three relations with an output size of 1 million tuples in around 100s in the LAN setting, while existing protocols that support the query cannot finish in an hour. Thus LINQ brings MPC query processing closer to practicality.

Secure Query Processing with Linear Complexity

TL;DR

This paper targets efficient secure query processing when data resides with multiple mutually distrustful parties. It introduces LINQ, the first protocol achieving linear time and communication in the 3-party model for a broad class of queries called free-connex, closely matching plaintext performance for weighted joins and aggregations. The method hinges on a hash-based consistent sort, ranks, and a novel hash-sort-merge-join that enables linear two-way and multi-way joins while preserving privacy. A complete system implementation demonstrates substantial practical gains over prior MPC baselines in both relatio nal and graph workloads, signaling a path toward practical MPC-enabled analytics. The work also discusses extending to a three-server model and outlines open questions for 2PC linear-time possibilities.

Abstract

We present LINQ, the first join protocol with linear complexity (in both running time and communication) under the secure multi-party computation model (MPC). It can also be extended to support all free-connex queries, a large class of select-join-aggregate queries, still with linear complexity. This matches the plaintext result for the query processing problem, as free-connex queries are the largest class of queries known to be solvable in linear time in plaintext. We have then built a query processing system based on LINQ, and the experimental results show that LINQ significantly outperforms the state of the art. For example, it can finish a query on three relations with an output size of 1 million tuples in around 100s in the LAN setting, while existing protocols that support the query cannot finish in an hour. Thus LINQ brings MPC query processing closer to practicality.
Paper Structure (43 sections, 2 theorems, 6 equations, 5 figures, 4 tables, 4 algorithms)

This paper contains 43 sections, 2 theorems, 6 equations, 5 figures, 4 tables, 4 algorithms.

Table of Contents

  1. Introduction
  2. Our Contributions
  3. Related Work
  4. Preliminaries
  5. Secret-Sharing
  6. The Three-Party Model
  7. Cost model
  8. Dummy Tuples
  9. Three-Party Primitives
  10. Circuit-based computation
  11. Prefix sum
  12. Permutation
  13. Compaction
  14. Intersection
  15. Extended intersection
  16. ...and 28 more sections

Key Result

Lemma 3.1

The algorithm above takes $O(n)$ time in expectation to consistently sort a relation by $\bm{E}$.

Figures (5)

  • Figure 1: Extended intersection example
  • Figure 2: An example of join operator with $n=7$, $m=10$, $\bm{F_R}=\{A,B\}$, $\mathcal{E}_R=\{(A),(B)\}$, $\bm{F_S}=\{B,C\}$, and $\mathcal{E}_R=\{(B),(C)\}$
  • Figure 3: An example of Algorithm \ref{['alg:expansion_rank']} with $n=4$, $m=7$, $\bm{F}=\{A,B\}$, and $\mathcal{E}=\{(A),(B)\}$
  • Figure 4: Two valid join trees for the join-aggregate query $\mathcal{Q}=\pi_{\{A, B, C, D\}}^\oplus\left(\Join_{i\in[4]}^\otimes R_i\right)$ with the output attributes underlined. The left one is a free-connex join tree for $\mathcal{Q}$.
  • Figure 5: Examples of the reduce step of the Yannakakis algorithm

Theorems & Definitions (10)

  • Example 1
  • Definition 1
  • Example 2
  • Lemma 3.1
  • proof
  • Example 3
  • Theorem 4.1
  • Example 4
  • Example 5
  • Example 6