Blind Delegation of Quantum Digital Signature

From Quantum Protocol Zoo
Jump to: navigation, search

This example protocol performs the task of Quantum Digital Signature such that the Signer does not get to know the content of the message being signed. It ensures that the owner cannot deny at a later stage having signed the message, a receiver cannot fake or alter the QDS and the verifier can use the above two properties to verify if the sent message is signed by the genuine sender, thus, satisfying properties of transferability, non-repudiation, and unforgeability.

Tags: Multi Party (three), Quantum Enhanced Classical Functionality, Specific Task, Quantum Digital Signature


  • Honest majority assumption: assumes that more than half the number of participating parties are honest. In the present case, at least two parties are honest.
  • It requires authenticated classical channel and insecure quantum channels.


The Blind QDS Protocol consists of 5 stages: setup, key distribution, message blinding, signing and verification. Each pair of participants share a unique key using Simon et al.'s QKD Algorithm.


There are 3 participants. The owner is the one who will transform the message into a matrix form and blind it. The signer will sign it. The verifier is the one who checks if a signature matches a message.

Key Distribution[edit]

All three pairs establish their pairwise quantum key matrices using the QKD protocol.

Message Blinding[edit]

The owner of the message now converts the message into matrix format. Then (s)he blinds the message matrix using the key shared with the verifier by multiplying the matrices. Now, (s)he encrypts the blind message with the key shared with the signer by multiplying the matrices. Finally, (s)he sends the encrypted matrix and the determinant of the blinded matrix to the signer and only the determinant of the message matrix to the verifier.


The signer creates a signature for the blinded message which means that he does not know the message matrix. He decrypts the encrypted message with his shared key to obtain the blinded message and checks its authenticity by comparing its determinant value with the received value. He then creates the signature using the blinded message and the key shared with the verifier and sends it to the verifier.


The verifier decrypts the signature using his key shared with the signer. Next, he un-blinds the blinded message using the key shared with the owner. He verifies the message matrix by comparing its determinant value with the received value.


  • : Set of quantum key matrices shared between Owner and Signer.
  • : Set of quantum key matrices shared between Signer and Verifier.
  • : Set of quantum key matrices shared between Owner and Verifier.
  • : Set of message matrices to be signed.
  • : Set of Blinded message matrices.
  • : Set of Blinded and Encrypted message matrices.
  • : Set of Signature matrices.
  • : Number of elements in every set.


  • Requires any QKD setup.
  • Insecure quantum and authenticated classical channels.

Knowledge Graph[edit]


  • The protocol provides security against both the forgery and repudiation attacks.
  • The protocol can sign long messages and is not restricted to binary ones.
  • The protocol has the ability to detect errors due to the usage of Fibonacci, Lucas and Fibonacci-Lucas matrices.
  • The protocol uses the setup of Simon et al.'s QKD algorithm to distribute quantum keys.

Protocol Description[edit]

Every pair of parties share different quantum key matrices , and respectively using Simon et al.’s QKD algorithm. The key matrices , and are either Fibonacci or Lucas or Fibonacci-Lucas matrices. The protocol consists of 5 stages:

  1. Setup
    1. The owner who transforms the message into an -square matrix and blinds the matrix.
    2. The signer who signs the blind message.
    3. The verifier who checks if a signature matches the message.
  2. Key Distribution
    1. Every pair uses Simon et al.'s QKD protocol to establish their pairwise key matrices between Owner and Signer; between Signer and Verifier; between Owner and Verifier.
  3. Message Blinding
    1. The Owner transforms the message into matrices where , .
    2. The Owner blinds the message matrix using
    3. The Owner now encrypts the message matrix using
    4. Finally, the Owner sends to the Signer, and to the Verifier.
  4. Signing
    1. The Signer decrypts with the key to obtain .

      where denotes the inverse matrix of .
    2. If the determinant of recovered by the Signer is not equal to the value of the determinant obtained from the Owner, the Signer aborts the protocol. Otherwise, he performs the next step.
    3. He signs the blind message using . The signature is
    4. He then sends the signature to the Verifier.
  5. Verification
    1. The Verifier decrypts the signature using to obtain the blind message .
    2. The Verifier then un-blinds the message using to obtain the message .
    3. He then checks if the determinant of obtained from the signature is the same as obtained from the Owner. If it holds, he verifies the following equations:

Further Information[edit]

*contributed by Natansh Mathur