Symmetric blind information reconciliation and hash-function-based verification for quantum key distribution

TL;DR

This paper introduces a symmetric blind information reconciliation protocol using LDPC codes and a hash-based verification method to improve error correction and key verification in quantum key distribution.

Contribution

It proposes a novel symmetric blind reconciliation method combined with an $$-universal hash verification for enhanced QKD security and efficiency.

Findings

Improved error correction in QKD through symmetric blind reconciliation.

Effective key verification using $$-universal hash functions.

Potential for increased security and reliability in quantum communication.

Abstract

We consider an information reconciliation protocol for quantum key distribution (QKD). In order to correct down the error rate, we suggest a method, which is based on symmetric blind information reconciliation for the low-density parity-check (LDPC) codes. We develop a subsequent verification protocol with the use of $\epsilon$-universal hash functions, which allows verifying the identity between the keys with a certain probability.

Equations

$$\mathcal{R}=\{0.9,0.85,\dots ,0.5\},$$

$$n_{\mathrm{sb}}:=0.95n_{\mathrm{fr}}$$

$$\Delta n_{\mathrm{ext}}:=0.05n_{\mathrm{fr}}$$

$$\begin{array}{rl}& h_k(X):=\text{inttostr}\left[\sum _{i=1}^n\text{strtoint}(x_i)k^{i-1}\text{leavevmode}\mathrm{mod}\text{leavevmode}p\right],\end{array}$$

$$\begin{array}{rl}{ϵ}_{\mathrm{ver}}& \le ϵ(n_{\mathrm{b}})+\left[1-ϵ(n_{\mathrm{b}})\right]\left[1-(1-ϵ(n_{\mathrm{sb}}){)}^{N_{\mathrm{sb}}}\right].\end{array}$$

$$\begin{gathered} {\mathrm{leak}}_{\mathrm{ec}}^{\mathrm{ver}}=(1-F{)}^{N_{\mathrm{sb}}}{l}_{\mathrm{ht}}+ \\ +\left[1-(1-F{)}^{N_{\mathrm{sb}}}\right](N_{\mathrm{sb}}+1)l_{\mathrm{ht}}, \end{gathered}$$

$$l_{\mathrm{ht}}=\lceil {\log }_{2}p\rceil$$

Full text

††preprint: APS/123-QED

I Introduction

A paradigmatic problem of cryptography is the problem of key distribution Schneier . Widely used tools for key distribution, based on so-called public key cryptography, use an assumption of the complexity of several mathematical problems such as integer factorization RSA and discrete logarithm DH . However, a large-scale quantum computer would allow solving such tasks in a more efficient manner in compare with their classical counterparts using Shor’s algorithm Shor . Therefore, most of information protection tools are vulnerable to attacks with the use of quantum algorithms. It should be also noted that absence of efficient non-quantum algorithms breaking public key tools remains unproved.

In the view of appearance of large-scale quantum computers, the crucial task is to develop a quantum-safe infrastructure for communications. Crucial components of such an infrastructure are information-theoretically secure schemes, which make no computational assumptions Schneier . Examples of these schemes are the one-time-pad encryption Shannon ; Vernam ; Kotelnikov and Wegman-Carter authentication WegmanCarter1981 . Nevertheless, the need for establishing shared secret symmetric keys between communicating parties invites the challenge of how to securely distribute keys.

Quantum key distribution (QKD) offers an elegant method for key establishment between distant users (Alice and Bob), without relying on insecure public key algorithms Gisin2002 . During last decades, remarkable progress in theory, experimental study, and technology of QKD has been performed Lo2016 . However, realistic error rates in the sifted key using current technologies are of the order of a few percent, which is high for direct applications Gisin2002 ; Lo2016 ; Kiktenko2016 . Practical QKD then include a post-processing procedure, which is based on the framework of the classical information theory.

In this work, we focus on an information reconciliation task in QKD. We consider a method for error correction based on symmetric blind information reconciliation Kiktenko2017 with low-density parity-check (LDPC) codes LDPC ; LDPC2 . In order to check the identity between the keys after the error correction step, we develop a subsequent verification protocol with the use of $\epsilon$-universal hash functions Krovetz . We note that the additional procedures (privacy amplification and authentication) are necessary to obtain secure keys shared only by Alice and Bob Kiktenko2016 ; Kiktenko2017 ; KiktenkoAnufriev2016 ; KiktenkoTrushechkin2016 .

The present paper is organized as follows. In Sec. II, we describe the symmetric blind information reconciliation technique for the low-density parity-check (LDPC) codes. In Sec. III, we suggest a subsequent verification protocol with the use of $\epsilon$-universal hash functions, which allows one to verify the identity between the keys with a certain probability. In Sec. IV, we give estimations for the information leakage in the suggested information reconciliation protocol. We summarize the main results of our work in Sec. V

II Symmetric blind error correction

We suggest the protocol for information reconciliation which has two essential steps: the symmetric blind error correction (SBEC) procedure and the subsequent verification protocol. For the SBEC technique, a block of the sifted key is divided into $N_{\rm sb}$ sub-blocks of length $n_{\rm sb}$, and all sub-blocks are treated in parallel. All the resulting sub-blocks from SBEC are input data for the subsequent verification procedure. If it is necessary during the verification protocol the keys are divided into the same sub-blocks once again for determining the sub-blocks which contain an error (for details, see Fig. 1).

Let us consider the SBEC procedure for the particular sub-blocks of the sifted key $k_{\rm sift}^{A}$ and $k_{\rm sift}^{B}$ of length $n_{\mathrm{sb}}$ owned by Alice and Bob. For details of the SBEC procedure we refer the reader to Ref. Kiktenko2017 , and here we confine ourself with explanation of the main steps.

For the implementation of the SBEC procedure we consider a set (“pool”) of nine LDPC codes LDPC ; LDPC2 with the following rates:

[TABLE]

and the frame length $n_{\rm fr}$. The parity-check matrices of these codes can be generated with the use of the improved progressive edge growing algorithm MartnezMateo2010 according to generating polynomials from Ref. Elkouss2009 .

The implementation of the SBEC procedure consists of following steps.

This initial step of the SBEC procedure realizes the preliminary initialization. The parties initialize zero strings $e$ of length $n_{\rm fr}$.

• 1)

Parties implement the rate adaptation. Alice (Bob) extend their sub-blocks of the sifted key $k_{\rm sift}^{A(B)}$ of length

[TABLE]

with $n_{\rm shrt}$ shortened and $n_{\rm pnct}$ punctured symbols, where $n_{\mathrm{shrt}}:=\lceil h(q_{\mathrm{est}})n_{\mathrm{fr}}-n_{\mathrm{sb}}(1-R)\rceil$, $n_{\mathrm{pnct}}:=\Delta n_{\mathrm{ext}}-n_{\mathrm{shrt}}$. Here, $\lceil\cdot\rceil$ stands for ceiling operation, $h(\cdot)$ is the binary entropy function,

[TABLE]

is the total number of shortened and punctured symbols, and the code rate $R$ is chosen among $\mathcal{R}$ in such a way that both $n_{\mathrm{shrt}}$ and $n_{\mathrm{pnct}}$ are non-negative for current estimation of the QBER $q_{\rm est}$.

The positions for punctured symbols are chosen according untainted puncturing technique Elkouss2012 , while the positions for shortened symbols are chosen pseudo-randomly. We denote the list of positions with sifted key bits as $\Omega$.

• 2)

This step is the realization of the syndromes exchange. Alice and Bob exchange with syndromes $s_{A(B)}:=k_{\rm ext}^{A(B)}\mathbf{H}_{R}^{\rm T}$, where $\mathbf{H}_{R}$ is the parity-check matrix corresponded to code rate $R$ ($k_{\rm ext}^{A(B)}$ and $s_{A(B)}$ are treated as row-vectors; ${\rm T}$ stands for transposition). All the summations in vector matrix multiplication are assumed to be performed by modulo 2.

• 3)

Alice and Bob use belief propagation decoding. The parties apply syndrome decodings based on the belief propagation algorithm with log-likelihood ratio (LLR) Kiktenko2017 . As the input both the parties use the “relative syndrome” $\Delta s=s_{A}\oplus s_{B}$, current information about error pattern $e$ (note, that it was initialized as zero string in the beginning if the procedure), parity-check matrix ${\bf H}_{R}$, the estimated QBER $q_{\rm est}$, and current positions of shortened and punctured symbols ($\oplus$ stands for modulo 2 summation). If the algorithm converges, it returns the new value of the error pattern $e$, and then Alice calculates the corrected key as follows: $k_{\rm cor}^{A}:=k_{\rm ext}^{A}[\Omega]\oplus e[\Omega]$, where $\Omega$ is the list of positions of sifted key symbols in the extended key. Bob assumes his corrected key has the following form: $k_{\rm cor}^{B}:=k_{\rm sift}^{B}$. The SBEC is finished.

• 4)

If the belief propagation algorithm does not converge, the this step is applied. It is based on disclosing additional information as follows. The parties take $d:=\lceil 56-40R\rceil$ positions in the extended key, which has the minimal magnitudes of LLR values to the end of belief propagation algorithm, disclose the values of their extended keys in these positions, and mark these positions as shortened. Then the parties update their error patterns $e$ in the newborn shortened positions, and go to the Step 3.

There is still a certain probability that uncorrected errors remain after the SBEC procedure. In order to detect remaining errors, we implement the subsequent verification protocol, which is described below.

III Verification

Here we suggest the verification protocol based on using the following $\epsilon$-universal family of hash functions Krovetz :

[TABLE]

where $k\in\mathbb{F}\equiv\{0,1,2,\ldots,p-1\}$ is a randomly chosen key for the universal hashing, $p$ is the prime number, $X$ is a binary string of an arbitrary length, $(x_{1}\|x_{2}\|\ldots\|x_{n}):=X$ is a partition of the string into substrings $x_{i}$ of length $l_{p}=\lfloor\log_{2}p\rfloor$ ($\lfloor\cdot\rfloor$ stands for floor operation), inttostr and strtoint are functions performing conversion between integer values an binary strings.

It can be shown Krovetz that the collision probability of the hash function (4) (i.e. the probability that $h_{k}(X)=h_{k}(Y)$ for some $X\neq Y$ and random $k$) is given by following expression: $\epsilon(l)\leq(\lceil l/l_{p}\rceil-1)/p$, where $l$ is length of $X$. Below the verification protocol based on the considered family of universal hash functions is considered.

Consider blocks of the corrected keys $K_{\rm cor}^{A(B)}$ owned by Alice (Bob), which consist of $n_{\rm b}=N_{\rm sb}\times n_{\rm sb}$ bits. The implementation of the suggested verification protocol consists of following steps.

On the initial step of the verification protocol, the parties use generation of the key for universal hashing. Alice generate a random number $k\in\mathbb{{F}}$ using a true random generator (TRNG).

• 2)

Further, the calculation of the hash for the whole block on the Alice side is realized. Alice computes $h_{k}(K_{\rm cor}^{A})$ and sends it Bob together with $k$.

• 3)

This step is comparing the hashes for the whole block Bob computes $h_{k}(K_{\rm cor}^{B})$ and compares it with $h_{k}(K_{\rm cor}^{A})$. If the hashes are identical, then Bob sends the acknowledgement message to Alice. The parties then assume $K_{\rm ver}^{A(B)}:=K_{\rm cor}^{A(B)}$, and the protocol finishes. Here $K_{\rm sift}^{A(B)}$ are blocks owned by Alice (Bob). If the hashes are different, then Bob sends the negative-acknowledgement message, and the protocol continues.

• 4)

Computing the hashes for all the sub-blocks on the Alice side is Step 4. Alice splits the corrected key $K^{A}_{\rm cor}$ in $N_{\rm sb}$ sub-blocks $\{k^{A}_{{\rm cor},i}\}$ of length $n_{\rm sb}$, generates $N_{\rm sb}$ random keys $\{k_{i}\}$ belonging to $\mathbb{F}$, calculates $\{h_{k_{i}}(k^{A}_{{\rm cor},i})\}$, and sends both these sets to Bob.

• 5)

Comparing the hashes for all the sub-block is used as the final step. Bob computes his versions of hashes $\{h_{k_{i}}(k^{B}_{{\rm cor},i})\}$, compares them with corresponding values from Alice, and discard the sub-blocks with mismatched hashes from his corrected key $K_{\rm cor}^{B}$, to obtain the verified key $K_{\rm ver}^{B}$. Then he sends Alice the indices of unverified block, and she perform the same operation and the protocol finishes.

To estimate a probability of the remaining error in the verified keys consider a worst case scenario where all of $N_{\mathrm{sb}}$ sub-blocks contain errors after SBEC procedure. In this case, the probability of at least hash collision is given by the following expression:

[TABLE]

Here the first term is a probability of collision for the whole block, and the second term is a probability of at least one collision in the verification of all the sub-blocks in the case of different hashes of the whole blocks . We note that the initial processing of the whole blocks $K_{\rm cor}^{A}$ and $K_{\rm cor}^{B}$ is performed to minimize the leakage of the information via public discussion. Let the frame error rate (FER), that is a probability of remaining error after SBEC in each of the sub-blocks, to be equal to $F$. Then the information leakage in the verification step, neglecting the hash collision event, is given by the following expression:

[TABLE]

where

[TABLE]

is a hash length. In Eq. (6) the first term corresponds to the case, where the whole blocks are identical and only one verification hash is transfered. The second term corresponds to the case of at least one error, where additional $N_{\rm sb}$ hashes are transfered.

IV Estimations

Let us consider our protocol based on a set of LDPC codes of frame length $n_{\rm fr}=4000$ and code rates given by Eq. (1). According to Eq. (3) and Eq. (2) the number of sifted key bit processed in each sub-block is $n_{\rm sb}=3800$. Taking the number of sub-blocks $N_{\rm sb}=256$ and the prime number for universal hashing $p=2^{50}-27$ with hash length $l_{\rm ht}=50$ bit, we obtain the following bound on a probability of the verification fail: $\epsilon_{\rm ver}\leq 2\times 10^{-11}$.

Let us then consider a question about information leakage in the verification step. Assuming that the FER of SBEC is $F=10^{-5}$, we obtain the following result: ${\rm leak}_{\rm ec}^{\rm ver}\approx 1.65l_{\rm ht}\approx 83\,{\rm bit}$.

In order to compare our approach with currently available post-processing tools, we calculate the information leakage for the setups described in Ref. Gisin3 . We note that in this case the hashes are added to each processed LDPC code block. Therefore, one has the following estimation: ${\rm leak}_{\rm ec}^{\rm ver,alt}\approx nl_{\rm ht}=12\,800\,{\rm bit}$.

It is thus clearly seen that the suggested approach has an advantage in ${\rm leak}_{\rm ec}^{\rm ver,alt}/{\rm leak}_{\rm ec}^{\rm ver}\approx{155}\mbox{ times}$. Thus, the suggested information reconciliation protocol allows one to decrease the information leakage in the verification protocol significantly.

V Conclusion

We have presented the information reconciliation protocol which combines two approaches: SBEC, based on LDPC codes, and verification, based on $\epsilon$-universal hashing. We have shown that applying SBEC for a number of sub-blocks in parallel and performing verification for the general block allows significant decreasing the information leakage in the verification stage.

The presented procedure allows one to obtain identical keys from sifted keys with a known bound of an error probability, which depends on the particular parameters of the protocol, such as hash length, block length, and number of sub-blocks.

The open source proof-of-principle realization of the presented algorithms are available KiktenkoAnufriev2016 ; KiktenkoTrushechkin2016 .

Acknowledgments. We thank Y.V. Kurochkin and N.O. Pozhar for useful discussions. The work of A.T. and E.K. was supported by the grant of the President of the Russian Federation (project MK-2815.2017.1). A.K.F. is supported by the RFBR grant (17-08-00742).