Copy Protection of Compute and Compare Programs

The example protocol achieves the functionality of Copy Protection allowing a Vendor to send a program to a Client such that the Client cannot duplicate it. This protocol, in particular, achieves copy-protection for 'compute-and-compare' programs.

Tags: Two Party Protocols, Quantum Functionality, Universal Task, Computational Security

Assumptions

• Vendor and Client are connected by quantum and classical channels
• Vendor can create and transmit BB84 states
• Client has the capability to perform universal quantum computation

Outline

Any Copy Protection protocol consists of two algorithms: Protect and Eval. For the family of compute-and-compare programs, these algorithms are described as follows:

• Protect: The Vendor encodes the required qubits into BB84 states using the program description. The Vendor then calculates the output of some hash function on the program description as input. The encoded qubits and the hashed description are sent to the Client as output.
• Eval: The Client decrypts the received qubits using the input on which they wish to evaluate the program. Using these qubits as inputs, the Client computes the same hash function (on ancillary qubits) and coherently compares it with the hashed description received from the vendor. The Client finally measures and outputs the result of the comparison.

Notation

• $P_{y}$ : The point function to be copy-protected in Protocol 1. $P_{y}$ is completely specified by a string of $n$ bits, $y$. $P_{y}(x)=1$ if $x=y$ and $0$ otherwise
• $CC[f,y]$ : The compute-and-compare program to be copy-protected in Protocol 2. It is completely specified by an efficiently computable function $f:\{0,1\}^{n}\rightarrow \{0,1\}^{m}$ and a string of $m$ bits, $y$. $CC[f,y](x)$ is $1$ if $f(x)=y$ and $0$ otherwise.
• $n$ : Size of input string $x$
• $\lambda$: Security parameter
• $G:\{0,1\}^{n}\rightarrow \{0,1\}^{m(\lambda )}$ (Hash function)
• $H:\{0,1\}^{m(\lambda )}\rightarrow \{0,1\}^{\lambda }$ (Hash function)
• $|x^{\theta }\rangle =H^{\theta }|x\rangle =H^{\theta _{1}}\otimes ...\otimes H^{\theta _{\lambda }}|x\rangle$, where $\theta$ is a $\lambda$-bit string $\theta _{1},...,\theta _{\lambda }$

Protocol Description

First, we define a protocol for copy-protection of point functions. This protocol can then be extended to a protocol for compute-and-compare programs.

Protocol 1 - Copy protection of point functions

PF-Protect($\lambda ,y$)

Inputs: $\lambda$ - security parameter; $y$ - description of point function $P_{y}$

• Set $\theta =G(y)$
• Sample $v\leftarrow \{0,1\}^{m(\lambda )}$ uniformly at random
• Let $z=H(v)$
• Output ($|v^{\theta }\rangle ,z$)

PF-Eval($\lambda ,(\rho ,z),x$)

Inputs: $\lambda$ - security parameter; $(\rho ,z)$ - Alleged copy-protected program; $x$ - Input on which the program is to be evaluated

• Set $\theta ^{\prime }=G(x)$
• Apply the Hadamard operator $H^{\theta ^{\prime }}$ to $\rho$
• Append $n+1$ ancillary qubits to $\rho$, all in state $|0\rangle$
• Compute the hash function $H$ onto the first $n$ ancillary qubits with $\rho$ as input
• Coherently measure whether the first $n$ ancilla qubits are in state $|z\rangle$, recording the result in the last ancilla qubit
• Uncompute the hash function $H$ and undo the Hadamards $H^{\theta ^{\prime }}$
• Measure the last ancilla qubit to obtain a bit $b$ as output

Protocol 2 - Copy protection of compute-and-compare programs

CC-Protect($\lambda ,(f,y)$)

Inputs: $\lambda$ - security parameter; $(f,y)$ - description of compute-and-compare program $CC[f,y]$

• Let $\rho =$ PF-Protect($\lambda ,y$)
• Output ($f,\rho$)

CC-Eval($\lambda ,(f,\rho ),x$)

Inputs: $\lambda$ - security parameter; $(f,\rho )$ - Alleged copy protected program; $x$ - Input on which the program is to be evaluated

• Compute $y^{\prime }=f(x)$
• Let $b\leftarrow$ PF-Eval($\lambda ,\rho ,y^{\prime }$). Output $b$.

Properties

• Protocol 2 has provable non-trivial security in the quantum random oracle model. Informally, a query bounded adversary fails at pirating with at least some constant probability.
• The Client should be able to perform universal quantum computation in order to compute the hash function $H$
• The protected programs obtained in both protocols allow polynomially-many evaluations (as we evaluate the copy-protected programs reversibly).
• Protocol 1 also satisfies the primitive of Virtual Black Box Obfuscation
• By adding a verification step, Protocol 2 can be extended to the weaker primitive of Secure Software Leasing. This protocol for Secure Software Leasing does however provide a standard level of security, i.e. the adversarial success probability is negligible in the security parameter.

Further Information

For the security proof and extension of the protocols to other functionalities, refer to the same paper by Coladangelo et al. (2020)

*contributed by Chirag Wadhwa