Prepare-and-Send Verifiable Quantum Fully Homomorphic Encryption

In this example protocol, Quantum Fully Homomorphic Encryption (link) protocol is implemented with the additional property of verification, where it is checked if the final ciphertext produces by the server matches the results of a particular computation. QFHE is a protocol where any arbitrary computations can be carried out by the server on the client's encrypted data while hiding all inputs and outputs of the client. In the classical version of this protocol, the verification was carried by creating copies at every stage, which is not possible in the quantum version due to the no-cloning theorem. Hence in this protocol, verification is carried out by a technique where the server generates classical computational logs through which the underlying encryptions becomes authenticated.

Tags: Two Party,Universal Task, Secure Delegated Quantum Computation, Quantum Offline Communication, Classical Offline Communication, Quantum Gadgets, Prepare and Send Quantum Fully Homomorphic Encryption, Classical Fully Homomorphic Encryption for Quantum Circuits.

Outline

This protocol consists mainly of four stages: Key Generation, Encryption, Homomorphic evaluation and Verified decryption. For verification, the major changes from the standard Prepare and Send Quantum Fully Homomorphic Encryption is in stage 2, evaluation where a computational log is provided as an extra output and in stage 4, Verified decryption which accepts computational log and performs the verification. The verification performed in this protocol is mainly classical in nature

• Key Generation and Encryption
  • This procedure requires the generation of single-qubit and two-qubit states from a small fixed set, performing Bell measurements and Pauli gates, and executing the encoding procedure of a quantum error-correcting code on which the trap code is based.
  • In this step, using the classical fully homomorphic encryption scheme, public key, the secret keys and the evaluation function key for the encryption are generated. A message authenticating system (MAC) is used to authenticate this process. Using MAC, a key is also generated.
  • Majority of the single-qubit and two qubit quantum states are encrypted using the global permutation $\pi$, but all the qubits in the error correcting gadget are encrypted using independent permutation. The encryption occurs through CSS where equal amounts of traps gates ($|0\rangle$ and $|+\rangle$) are added and permuted using the global permutation, after which the overall state is encrypted by using Quantum one time pad. The final state formed of the single-qubit or two qubit quantum used initially is known as the magic state.
  • The keys for the quantum one-time pad are selected during the encryption stage, For the $T$ gate, error correcting gadgets are prepared from garden-hose gadgets(Link here).
  • Then the evaluation key is formed, using the auxiliary states mentioned, which includes the magic states too.

• Evaluation: Evaluation of a circuit is done gate by gate. Throughout this procedure, apart from the outputs, a complete computational log is made of all randomness used, all computation steps, all intermediate results and all the classical FHE computations. To measure a qubit, we measure all ciphertext qubits and place the outcomes in the log.
  • Measurements: In computational basis measurement, logical measurement is performed by measurement of all physical qubits of the ciphertext and also checks the traps. This is followed by using the encryption function of classical homomorphic encryption on the result. In Hadamard basis measurement, because of the Hadamard gate property of $H|0\rangle =|+\rangle$ and $H|+\rangle =|0\rangle$, all computational traps are swapped with the Hadamard traps. . A transversal application of $H$ to all relevant physical qubits precedes the evaluation procedure for the computational basis measurement.
  • Pauli gates: Applying a logical Pauli is done by applying the same Pauli to all physical qubits. The application of Pauli gates ($X$ and/or $Z$) to a state encrypted with a quantum one-time pad can be achieved without touching the actual state, by updating the keys to QOTP in the appropriate way. The logical Pauli-X is performed by (homomorphically) flipping the X-key bits of the QOTP and Pauli-Y works in the same manner for Z-key bits. Hence, this is a classical task.
  • CNOT gate: The effect of applying CNOT to the encrypted qubits, without the quantum one-time padding is that logical CNOT is applied to the physical data qubits in the permutation and the remaining traps are unchanged due to its action. Hence in the quantum one-time pad, the secret key bits are homomorphically updated during evaluation while applying CNOT.
  • Phase gates: Performing this gate requires homomorphic evaluation of all the above gates: (classically controlled) Paulis, CNOTs, and measurements. Here the corresponding encrypted magic state is also used. The below circuit is used to apply this gate
  • Hadamard gate: The Hadamard gate can be applied using the same method used in the Phase gate.
  • T gate: Applying T requires a magic state and an encrypted garden-hose gadget (because the T-gate magic state circuit applies a P-gate conditioned on a measurement outcome). The evaluation of that circuit is complicated and hence that specific error correcting gadget is used.

• Verified decryption
  • Here the correctness and consistency of the classical FHE transcript, the measurement outcomes, and the claimed circuit are checked. The result of this computation is a set of keys for the trap code, which are correct provided that Eval was performed honestly. In this step, decryption takes place using these keys and the output is either plaintext or reject. In terms of quantum capabilities, decryption requires executing the decoding procedure of the error-correcting code, computational-basis and Hadamard-basis measurements, and Paulis.
  • This procedure consists of two parts. Several classical checks are performed at first, where MAC-verification of all classically authenticated messages takes places. It also includes checking if the gates listing in the computational log match the circuit description. The portion of the log which specifies the purely classical, FHE steps taking during classical homomorphic encryption are also checked. Next, all the unmeasured traps are checked and the remaining qubits are decoded. If the logs don't match or if any of the traps are triggered, then the entire process is rejected.

Pseudo Code

Stage 1: Key generation and encryption

Function 1: TrapTP.KeyGen($1^{\kappa },1^{t},1^{p},1^{h}$)

• $k \xleftarrow[]{} MAC.KeyGen(1^\kappa)$
• $\pi \xleftarrow[r]{} S_{3m}$
• for $i = 0, ..., t:$
  • $(sk_i, pk_i, ev_i) \xleftarrow[]{} HE.KeyGen(1^\kappa)$
• $sk \xleftarrow[]{} (\pi, k, sk_0, ..., sk_t, pk_0)$
• for $i = 0, ..., p:$
  • $\mu_i^{P} \xleftarrow[]{} TrapTP.ENC(sk, P|+\rangle)$
• for $i = 0, ..., t:$
  • $\mu_i^{T} \xleftarrow[]{} TrapTP.ENC(sk, T|+\rangle)$
• for $i = 0, ..., h:$
  • $\mu_i^{H} \xleftarrow[]{} TrapTP.ENC(sk, \frac{1}{\sqrt{2}}(H\otimes I)(|00\rangle + |11\rangle))$
• for $i = 0, ..., t:$
  • $\pi_i \xleftarrow[r]{r} S_{3m}$
  • $(g_i, \gamma_i^{in}, \gamma_i^{mid}, \gamma_i^{out}) \xleftarrow[]{} TrapTP.GadgetGen(sk_{i-1})$
  • $\Gamma_i \xleftarrow[]{} MAC.Sign(HE.ENC_{pk_i}(g_i, \pi_i)) \otimes TrapTP.ENC((\pi_i, k, sk_0, ..., sk_t, pk_i), \gamma^{mid}_i \otimes TrapTP.Enc(sk, \gamma^{in}_i, \gamma^{out}_i$
• $keys \xleftarrow[]{} MAC.Sign(evk_0, ..., evk_t, pk_0, ..., pk_t, HE.Enc_{pk_0}(\pi))$
• $\rho_{evk} \xleftarrow[]{} (keys, \mu^{P}_0, ..., \mu^{P}_p, \mu^{T}_0, ..., \mu^{T}_t, \mu^{H}_0, ..., \mu^{H}_h, \Gamma_1, ..., \Gamma_t)$
• return $(sk, \rho_{evk})$

Further Information

*contributed by Rhea Parekh