Prepare-and-Send Quantum Fully Homomorphic Encryption

From Quantum Protocol Zoo
Jump to: navigation, search

This example protocol achieves the functionality of Secure Client- Server Delegated Computation by a method which involves quantum offline and classical offline communication, called Quantum Fully Homomorphic Encryption (QFHE). Offline communication means there is exchange of information is not required throughout the protocol but only once at the start or end of the protocol. It allows the Client to encrypt quantum data in such a way that Server can carry out any arbitrary quantum computations on the encrypted data without having to interact with the encrypting party. It hides the output and input of the computation while Server is allowed to choose the unitary operation for required computation. Thus, the circuit is known to the Server while efforts can be made to hide it from the encrypting party i.e. Client. Based on the existence of classical Homomorphic Encryption (HE) scheme, it comes with properties of correctness, compactness and full homomorphism. QFHE can be used to keep the circuit private to the Server and hidden from the Client unlike UBQC where the circuit is private to the Client and hidden from the Server.

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


  • This protocol is secure against malicious adversary setting
  • One cannot decrypt the ciphertext without performing the Evaluation step
  • A one-time quantum channel from Client to Server
  • A one-time quantum channel from Server to Client
  • The circuit has a polynomial number of T-Gates.


Homomorphic Encryption (HE) schemes can be divided into four stages: Key Generation generates keys for encryption, decryption, and evaluation of the circuit, Encryption encodes the input into a ciphertext using encryption key, Homomorphic Evaluation performs operations (implements the circuit) on the encrypted input using evaluation key and Decryption transforms result of the ciphertext to actual outcome of the circuit using decryption key. This protocol requires Client to prepare and send the quantum states to Server, hence the name, Prepare and Send QFHE. A QFHE scheme is fundamentally different from classical FHE in the aspect that an evaluation key is allowed to be a quantum state in the former case. Also, in the last step decryption for FHE is carried out subsystem by subsystem. This cannot be correct for QFHE as quantum states can be entangled, hence decryption should be carried out on the system as a whole. The QFHE version of encryption is based on quantum one-time pad i.e. randomly applying a Pauli Gate (X, Y, Z, I) in order to hide the input. A Fully Homomorphic Encryption can implement Universal Gates (a set of gates which can implement any quantum circuit). Most of the gates in this set work well with QOTP while for T gates one needs an additional gadget, in order to implement any arbitrary circuit and make the scheme Fully Homomorphic. This adds an additional step called ”Gadget Construction” during Key Generation Stage in this protocol

  • Key Generation (QFHE.KeyGen())

This step generates homomorphic key sets consisting of the classical public key for encryption, a classical private key for decryption and a quantum evaluation key for operation on the encrypted input state. If the circuit involves L T gates, Client needs L+1 such key sets for L gadgets and one input state. The Client uses the classical HE Key Generation (HE.KeyGen) to get classical key sets. She stores all the public keys and secret keys in two separate sets (tuples). Quantum evaluation keys consist of the classical evaluation keys and L gadgets. Once constructed, the gadget is also encrypted using all public keys except the first one by the Client. As construction of gadgets takes secret keys (first L) as inputs, the public key used for its encryption should not belong to the same homomorphic key set used to construct the gadget. A classical description of the gadget, useful for evaluation is also encrypted and included in the gadget. Construction and encryption of gadgets is described in the last step.

    • Gadget Construction This step involves the construction of gadgets to correct any additional phase gate error on the input due to T gates in the circuit. If there are L T gates in the Circuit, one needs L Gadgets constructed using L private keys and then encrypted using L public keys. The public key used for encryption should not belong to the same homomorphic key set of the private key used for construction. A gadget consists of 2m EPR pairs (maximally entangled qubits). The client starts with 4m such pairs. Performs pairwise Bell measurement on one-half of the EPR pairs. Pairs for Bell measurement are chosen according to the private decryption key used for the particular gadget. This leaves the other half of the EPR pairs entangled in the same pairs as chosen by Client to perform bell measurement. E.g. if (a,b) and (c,d) denote two EPR pairs and one performs bell measurement on a and c, then b and d become maximally entangled with some extra Pauli X, Z corrections due to measurement. These corrections are determined by Client’s measurement outcomes according to one pad key. The resulting gadget thus has 2m EPR pairs, some of which have an inverse phase gate. Classical information of a gadget includes private key used, Client’s measurement outcomes and locations of inverse phase gates. This data is encrypted with the public key. Hence, L such gadgets consisting of encrypted classical information and 2m EPR pairs quantum one-time padded by the Pauli X, Z gates, are sent to the server.

Finally, Client stores all the gadgets with the classical evaluation key of the corresponding secret key (generated from HE.KeyGen) used to construct the gadget, as the set of quantum evaluation keys. Note that, the gadgets are quantum states and classical evaluation keys are random numbers, the resulting quantum evaluation key is what we call a classical-quantum (CQ) state.

  • Encryption (QFHE.Enc()) This step is used to encrypt the quantum input into a quantum cipher-text (secret text) using the first public key which has not been used for gadget construction. Every input qubit state is quantum one time padded by the Client, using two classical random bits, one of which decided the operation of Pauli-X and the other operation of Pauli-Z gate on the qubit state. She also encrypts the classical random bits (called pad key) with the same public key using classical HE (HE.Enc) and hence stores it with the corresponding encrypted qubit state as a classical-quantum state. She then sends this CQ state, encrypted pad key, public key tuple, and evaluation key tuple to Server.
  • Circuit Evaluation (QFHE.Eval()) This step operates the circuit on the encrypted input state and updates the encrypted classical information using the evaluation key. As stated earlier, any circuit can be implemented using a set of Universal Gates. This set consists of Clifford Gates and T gates.

The Clifford group gates may affect a single qubit or multiple qubits but they follow a simple set of rules for updation of the encrypted classical information (pad key), given in the pseudocode. The server operates the circuit and with each gate in the circuit, it updates the encrypted classical description.
On the other hand, T gates affect only single qubits but one needs to make use of the gadgets constructed during key generation. The issue with T gates is that it adds an additional Phase gate (P) depending on the classical random bit used for QOTP in the previous step. As P gates do not commute like Pauli-X and Pauli-Z, so they need to be corrected before applying the next gate by the Server. This would reveal the pad key used for QOTP to the Server. Hence, to avoid this, the Client constructed gadgets, which apply an Inverse Phase operator or Identity on a qubit after every T-Gate, depending on the encrypted bit without leaking any information about the pad key. Thus, after applying a T gate on a qubit, P error is removed using a gadget as follows. Out of 2m EPR pairs, some qubits are measured pairwise including the input qubit with/without error and excluding one qubit entangled with one of the measured qubits. Input qubit is thus, transferred to this last unmeasured qubit, according to one-bit teleportation. Following are the steps to get the correct output qubit.

  • Generate Measurement (QFHE.GenMeasurement()) The encrypted one pad key bit which determines phase gate error and the classical information of the gadget is used to determine a measurement order. Private key tells which qubits are entangled, thus, using the location of inverse phase gates, the qubits needed to be measured are decided. If one-pad key bit indicates a phase error then the measurement order of qubits includes an EPR pair with a phase gate else not.
  • Gadget Correction (QFHE.Measurement()) Server performs the required measurements. The last unmeasured qubit is corrected input qubit. The qubit is one time padded with pad key determined by Client’s measurement outcomes, encrypted with the public key used for the gadget and Server’s measurement outcomes. Hence, it is still hidden from the Server.
  • Recryption (QFHE.Rec()) Server recrypts pad key of the qubit with the same public key that encrypts the corrected output state i.e. the one used for the corresponding gadget. Then, he updates the encrypted pad key according to the T Gate (similar to what is done for the Clifford Gate), Client’s encrypted measurement outcomes and Server’s (his) measurement outcomes.

The server performs all the Clifford and T gates in the circuit following the respective procedure given above. Finally, he is left with the one time padded quantum output of the computation together with the required classical pad key encrypted with the public key of the gadget used for the last T gate, the last public key in the set. The server sends both the quantum state and classical encryptions to the Client.

  • Decryption (QFHE.Dec()) The Client uses the last secret key in the set, which was not used to create any gadget (Gadgets used 0-(L-1) secret keys only) and decrypts sent encryptions to obtain the pad key. The pad key thus obtained determines the Pauli operations on the sent quantum state to obtain the final and correct outcome of the computation. The client performs the required operations on individual qubits of the quantum state and gets the output of his computation.


  • Network Stage: Quantum Memory
  • Required Network Parameters:
    • , which measures the error due to noisy operations.
    • Number of communication rounds
    • Circuit depth
    • Number of physical qubits used
  • Client should be able to generate and store entanglement in order to make quantum gadgets, perform Bell measurement, perform quantum one time pad, process and store classical quantum states.
  • Quantum offline channel
  • Classical offline channel
  • A classical HE scheme is required
  • Server should be able to store entangled states, perform all Clifford and T gates.

Knowledge Graph[edit]


  • Indistinguishability under Chosen Plaintext Attacks by an adversary with quantum computational powers(q-IND-CPA). If FHE is q-IND-CPA secure then this protocol is q-IND-CPA secure. It means that an adversary cannot distinguish between ciphertext from a message and a ciphertext from an arbitrary quantum state such as
  • Correctness. This protocol is perfectly correct such that,

, where is a negligible function.Note that, negligible function $\eta(n)$ is a function such that for every positive integer d, , for big enough n. This means that if the protocol is followed it results in the same output as when the circuit is operated on the input states directly with overwhelming probability.

  • Compactness. If HE is compact then this protocol is compact. The complexity of applying QFHE.Dec on the results of QFHE.Eval is at most p(k), where p(k) is a polynomial dependent only on the security parameter k. This implies that decryption is independent of the size of the quantum circuit for evaluation.
  • Circuit Privacy. This protocol is not circuit private as it does not guarantee that the client cannot gain information about the circuit evaluated i.e. the circuit is not private to one party and unknown to another. It can make the circuit private to the evaluator (Server) and hidden from the Client apart from the necessary leakage the output states gives if one uses circuit private HE for the protocol.

Full Homomorphism. This scheme is fully homomorphic for circuits with polynomial sized T gates


  • , security parameter
  • , number of T gates in the evaluation circuit
  • , dimension of input qubit
  • , homomorphic key set generated from HE.KeyGen(). Public key for encryption, secret key for decryption, evaluation function key, respectively for given k, the security parameter.
  • , Gadget using secret key () and encrypted by public key ()
  • , single qubit state
  • , here is the density matrix of quantum state
  • , n-qubit input state, where n is determined by the Client
  • (HE.Encpk(a)), a is encrypted with public key pk and is represented by density matrix ρ
  • p, location of inverse phase gate
  • x,z measurement outcome sets of Client for her Bell Pair measurements.
  • measurement outcome sets of Server for his Gadget measurement.
  • , resulting ciphertext one gets for an input element of array x or bit of key x after the Encrypting it with of public key string, pk.

Protocol Description[edit]

Stage 1 Client’s Preparation[edit]

Key Generation (QFHE.KeyGen(1k,1L))

  • Input: No. of T gates (L), Security Parameter (k),
  • Output: L+1 evaluation keys (encrypted Gadgets, classical HE evaluation key), L+1 public keys, L+1 secret keys
  1. For i = 0 to L
    1. Client executes to obtain independent classical homomorphic key sets.
  2. She sets the public key to be the tuple .
  3. She sets the secret key to be the tuple .
  4. For i = 0 to L-1
    1. Client runs the procedure to create the gadget .
  5. Client sets the evaluation key to be the set of all gadgets created in the previous step (including their encrypted classical information), plus the tuple . The resulting evaluation key is the classical-quantum (CQ) state


  • Input: Quantum Input state density matrix () (say composed of n single qubit states, )
  • Output: Encrypted pad keys:,; QOTP state:
  1. For i=1 to n
    1. Client chooses pad keys a,b
    2. She quantum one time pads the single qubit by applying $X^aZ^b$ on the single qubit state.
    3. She encrypts the pad keys using one bit for each of a and b from the public key string using HE.Enc. ()=(HE.Enc),HE.Enc (a,b)
    4. She apprehends encrypted pad keys to the one time padded quantum state to obtain CQ state,

  1. Client sends encryptions () and the quantum one time padded (QOTP) state, to the Server with the evaluation keys and public keys.

Gadget Construction ()

  1. Generate EPR pairs (,
  2. Choose pairs using sk
    1. If then
    2. If then
  3. For j=1 to 2m,
    1. Choose p[j]
    2. Perform Bell Measurement on pair with an extra operation, get outcomes (x[j],z[j])
    3. Thus, new EPR pairs are
      1. If then
      2. If then
    4. Denote the entangled pairs be denoted by , such that
    5. The classical information of gadget be g(sk).
    6. The quantum state of gadget can be written as
  4. Encrypt (x[j],z[j]), p[j] for all j and sk using . Resulting Gadget is the classical-quantum (CQ) state,

Stage 2 Server’s Computation[edit]

Circuit's Evaluation (QFHE.Eval())

  • Input: public key tuple , Evaluation key tuple, Encrypted Pad key (, ), QOTP Input State ()
  • Output: QOTP Circuit Output State (), Corresponding Encrypted Pad key ()=(HE.Eval),HE.Eval))

Let the Circuit be denoted by C and the gates be

  1. For all i, gate is applied on qubit m and the bits of pad key are updated to as follows.
    1. If , a Clifford gate then )
      1. if H then: (Hadamard tranforms X gate into Z and Z into X)
      2. if P then:
      3. if CNOT with m as target bit and n as control bit then:
    2. If gate then:
      1. Generate Measurement M QFHE.GenMeasurement(
      2. Gadget Correction QFHE.Measurement(M,
      3. Server gets measurement outcome x',z'
      4. Recryption Server recrypts one-pad key using pk ( QFHE.Rec
      5. Server updates the recrypted key using x,z and x',z'. ()
    3. Server sends the updated encryption and QOTP output state to Client.

Stage 3 Client’s Correction[edit]

Decryption (QFHE.Dec())

  • Input: QOTP Circuit Output State (), Corresponding Encrypted Pad key ()
  • Output: Final outcome of the computation CC
  1. Client uses to restore the pad key from sent encryption: ()=(HE.Dec),HE.Dec
  2. Client uses pad key and operates on single qubits i separately just like encryption.
    1. Let single qubit representation of the output state be , then operation of Pauli X,Z gates as above yields
  3. Client repeats this for all single qubits and hence gets the quantum state , final outcome of the computation.

Further Information[edit]

*contributed by Shraddha Singh