Code-based Key Encapsulation from McEliece's Cryptosystem

TL;DR

This paper introduces a new code-based key encapsulation mechanism (KEM) derived from McEliece's cryptosystem, expanding the application of coding theory in cryptography with enhanced flexibility.

Contribution

It extends Persichetti's framework to develop a secure KEM based on McEliece, offering a novel approach in code-based cryptography.

Findings

A new secure KEM based on McEliece is proposed.

The framework allows greater flexibility in coding theory applications.

Potential for improved cryptographic schemes using code-based methods.

Abstract

In this paper we show that it is possible to extend the framework of Persichetti's code-based framework and create a secure KEM based on the McEliece protocol. This provides greater flexibility in the application of coding theory as a basis for cryptographic purposes.

Tables

Table 1. Table 1: The McEliece KEM.

Setup	Fix public system parameters $q,n,k,w\in \mathbb{N}$, then choose a family $ℱ$ of $w$-error-correcting $[n,k]$ linear codes over ${𝔽}_q$.
KeyGen	Choose a code $𝒞\in ℱ$ with code description $\Delta$ and compute a generator matrix $G$. Generate a random $s\stackrel{\$}{\leftarrow }{𝔽}_q^k$. Public key is $G$ and private key is $(\Delta ,s)$.
Enc	On input a public key $G$ choose random words $x\in {𝔽}_q^k$ and $e\in {𝕎}_{q,n,w}$, then compute $K=\text{KDF}\left(x\right||e,{\ell }_K)$, ${\psi }_0=xG+e$ and return the key/ciphertext pair $(K,{\psi }_0)$.
Dec	On input a private key $\Delta$ and a ciphertext ${\psi }_0$, compute ${\text{Decode}}_{\Delta }\left({\psi }_0\right)$. If the decoding succeeds, use its output $(x,e)$ to compute $K=\text{KDF}\left(x\right||e,{\ell }_K)$. Otherwise, set $K=\text{KDF}\left(s\right||{\psi }_0,{\ell }_K)$. Return $K$.

Table 2. Table 2: The McEliece cryptosystem.

Setup	Fix public system parameters $q,n,k,w\in \mathbb{N}$, then choose a family $ℱ$ of $w$-error-correcting $[n,k]$ linear codes over ${𝔽}_q$.
K	${\text{K}}_{\text{publ}}$ the set of $k\times n$ matrices over ${𝔽}_q$.
	${\text{K}}_{\text{priv}}$ the set of code descriptions for $ℱ$.
P	The vector space ${𝔽}_q^k$.
C	The vector space ${𝔽}_q^n$.
KeyGen	Generate at random a code $𝒞\in ℱ$ given by its code description $\Delta$ and compute a public111While the original version proposes to use scrambling matrices $S$ and $P$ (see [9] for details), this is not necessary and alternative methods can be used, depending on the chosen code family. generator matrix $G$. Publish the public key $G\in {\text{K}}_{\text{publ}}$ and store the private key $\Delta \in {\text{K}}_{\text{priv}}$.
Enc	On input a public key $G\in {\text{K}}_{\text{publ}}$ and a plaintext $\varphi =x\in \text{P}$, choose a random error vector $e\in {𝕎}_{q,n,w}$, then compute $y=xG+e$ and return the ciphertext $\psi =y\in \text{C}$.
Dec	On input the private key $\Delta \in {\text{K}}_{\text{priv}}$ and a ciphertext $\psi \in \text{C}$, compute ${\text{Decode}}_{\Delta }\left(\psi \right)$. If the decoding succeeds, return its output $\varphi =x$. Otherwise, output $\perp$.

Equations

$$\textsf{Adv}_{\textsf{KEM}}(\mathcal{A},\lambda)=\Big{|}\textsf{Pr}[b^{*}=b]-\frac{1}{2}\Big{|}.$$

Full text

1 Introduction

A Hybrid Encryption scheme is a cryptographic protocol that uses public-key encryption as means to securely exchange a key, while delegating the task of encrypting the body of the message to a symmetric scheme. The public-key component is known as Key Encapsulation Mechanism (KEM). The first code-based KEM, utilizing the Niederreiter framework [9], was presented by Persichetti in [11] and successively implemented in [3]. In this paper, we expand on Persichetti’s work and prove that if we use the McEliece approach [7] we are still able to obtain a secure KEM. This is a novel construction, with a great potential impact, especially considering NIST’s recent call for papers for secure post-quantum primitives [1].

2 Preliminaries

2.1 The McEliece Cryptosystem

We consider here a more “modern” version compared to R. J. McEliece’s original cryptosystem [7]. In the description that we use (Table 2, Appendix 0.A), we consider families of codes to which is possible to associate an efficient decoding algorithm; we denote this with $\textsf{Decode}_{\Delta}$, where $\Delta$ is a description of the selected code that depends on the specific family considered. For instance, in the case of binary Goppa codes, the associated algorithm is Patterson’s algorithm [10] and $\Delta$ is given by a Goppa polynomial $g(x)$ and its support $(\alpha_{1},\dots,\alpha_{n})$. For MDPC codes [8], decoding is given by Gallager’s bit-flipping algorithm [6] and $\Delta$ is a sparse parity-check matrix $H$ for the code. Also, we denote with $\mathbb{W}_{q,n,w}$ the set of words of $\mathbb{F}_{q}^{n}$ with Hamming weight $w$.

The security of the scheme follows from the two following computational assumptions.

Assumption 1** **(Indistinguishability)

The $k\times n$ matrix $G$ output by KeyGen is computationally indistinguishable from a same-size uniformly chosen matrix.

Assumption 2** **(Decoding Hardness)

Let $G$ be a generator matrix for an $[n,k]$ linear code $\mathcal{C}$ over $\mathbb{F}_{q}$ and $y$ a word of $\mathbb{F}_{q}^{n}$. It is hard to find a codeword $c\in\mathcal{C}$ with $d(c,y)\leq w$.

Assumption 2 is also known as the General Decoding Problem (GDP), which was proved to be NP-complete in [2], and it is believed to be hard on average, and not just on the worst-case instances (see for example Sendrier [12]).

2.2 Encapsulation Mechanisms and the Hybrid Framework

A Key Encapsulation Mechanism (KEM) is essentially a Public-Key Encryption scheme (PKE), with the exception that the encryption algorithm takes no input apart from the public key, and returns a pair $(K,\psi_{0})$. The string $K$ has fixed length $\ell_{K}$, specified by the KEM, and $\psi_{0}$ is an “encryption” of $K$ in the sense that $\textsf{Dec}_{\textsf{sk}}(\psi_{0})=K$. The key $K$ produced by the KEM is then passed on to a Data Encapsulation Mechanism (DEM), which is in charge of encrypting the actual message. The formulation of a DEM, that normally comprises additional tools for security such as Message Authentication Codes (MAC), is outside the scope of this paper, and we refer the reader to [5] for more details.

A KEM is required to be sound for at least all but a negligible portion of public key/private key pairs, that is, if $\textsf{Enc}_{\textsf{pk}}(\ )=(K,\psi_{0})$ then $\textsf{Dec}_{\textsf{sk}}(\psi_{0})=K$ with overwhelming probability.

The security notions for a KEM are similar to the corresponding ones for PKE schemes. The one we are mainly interested in (representing the highest level of security) is IND-CCA, which we describe below.

Definition 1

The adaptive Chosen-Ciphertext Attack game for a KEM proceeds as follows:

Query a key generation oracle to obtain a public key pk. 2. 2.

Make a sequence of calls to a decryption oracle, submitting any string $\psi_{0}$ of the proper length. The oracle will respond with $\textsf{Dec}^{\textsf{KEM}}_{\textsf{sk}}(\psi_{0})$. 3. 3.

Query an encryption oracle. The oracle runs $\textsf{Enc}^{\textsf{KEM}}_{\textsf{pk}}$ to generate a pair $(\tilde{K},\tilde{\psi_{0}})$, then chooses a random $b\in\{0,1\}$ and replies with the “challenge” ciphertext $(K^{*},\tilde{\psi_{0}})$ where $K^{*}=\tilde{K}$ if $b=1$ or $K^{*}$ is a random string of length $\ell_{K}$ otherwise. 4. 4.

Keep performing decryption queries. If the submitted ciphertext is $\psi^{*}_{0}$, the oracle will return $\bot$. 5. 5.

Output $b^{*}\in\{0,1\}$.

The adversary succeeds if $b^{*}=b$. More precisely, we define the advantage of $\mathcal{A}$ against KEM as

[TABLE]

We say that a KEM is secure if the advantage $\textsf{Adv}_{\textsf{KEM}}$ of any polynomial-time adversary $\mathcal{A}$ in the above CCA attack model is negligible.

It has then been proved that, given a CCA adversary $\mathcal{A}$ for the hybrid scheme (HY), there exist an adversary $\mathcal{A}_{1}$ for KEM and an adversary $\mathcal{A}_{2}$ for DEM running in roughly the same time as $\mathcal{A}$, such that for any choice of the security parameter $\lambda$ we have $\textsf{Adv}_{\textsf{HY}}(\mathcal{A},\lambda)\leq\textsf{Adv}^{\prime}_{\textsf{KEM}}(\mathcal{A}_{1},\lambda)+\textsf{Adv}_{\textsf{DEM}}(\mathcal{A}_{2},\lambda)$. See Cramer and Shoup [5, Th. 5] for a complete proof.

3 The New KEM Construction

The KEM we present here follows closely the McEliece framework, and is thus based on the hardness of GDP. Note that, compared to the original PKE, a slight modification is introduced in the decryption process. As we will see later, this is necessary for the proof of security. The ephemeral key $K$ is obtained via a Key Derivation Function KDF (see Appendix 0.B).

If the ciphertext is correctly formed, decoding will always succeed, hence the KEM is perfectly sound. Furthermore, it is possible to show that, even if with this formulation $\textsf{Dec}^{\textsf{KEM}}$ never fails, there is no integrity loss in the hybrid encryption scheme thanks to the check given by the MAC.

We prove the security of the KEM in the following theorem.

Theorem 3.1

Let $\mathcal{A}$ be an adversary in the random oracle model for the Niederreiter KEM as in Definition 1. Let $\theta$ be the running time of $\mathcal{A}$, $n_{\textsf{KDF}}$ and $n_{\textsf{Dec}}$ be two bounds on, respectively, the total number of random oracle queries and the total number of decryption queries performed by $\mathcal{A}$, and set $N=q^{k}\cdot|\mathbb{W}_{q,n,w}|$. Then there exists an adversary $\mathcal{A}^{\prime}$ for GDP such that $\textsf{Adv}_{\textsf{KEM}}(\mathcal{A},\lambda)\leq\textsf{Adv}_{\textsf{GDP}}(\mathcal{A}^{\prime},\lambda)+n_{\textsf{Dec}}/N$. The running time of $\mathcal{A}^{\prime}$ will be approximately equal to $\theta$ plus the cost of $n_{\textsf{KDF}}$ matrix-vector multiplications and some table lookups.

Proof.

We replace KDF with a random oracle $\mathcal{H}$ mapping elements of the form $(x,e)\in\mathbb{F}_{q}^{k}\times\mathbb{W}_{q,n,w}$ to bit strings of length $\ell_{K}$. To prove our claim, we proceed as follows. Let’s call $\textsf{G}_{0}$ the original attack game played by $\mathcal{A}$, and $\textsf{S}_{0}$ the event that $\mathcal{A}$ succeeds in game $\textsf{G}_{0}$. We define a new game $\textsf{G}_{1}$ which is identical to $\textsf{G}_{0}$ except that the game is halted if the challenge ciphertext $\psi^{*}_{0}=x^{*}G+e^{*}$ obtained when querying the encryption oracle had been previously submitted to the decryption oracle: we call this event $\textsf{F}_{1}$. Since the number of valid ciphertexts is $N$, we have $\textsf{Pr}[\textsf{F}_{1}]\leq n_{\textsf{Dec}}/N$. It follows that \Big{|}\textsf{Pr}[\textsf{S}_{0}]-\textsf{Pr}[\textsf{S}_{1}]\Big{|}\leq n_{\textsf{Dec}}/N, where $\textsf{S}_{1}$ is the event that $\mathcal{A}$ succeeds in game $\textsf{G}_{1}$. Next, we define game $\textsf{G}_{2}$ which is identical to $\textsf{G}_{1}$ except that we generate the challenge ciphertext $\psi^{*}_{0}$ at the beginning of the game, and we halt if $\mathcal{A}$ ever queries $\mathcal{H}$ at $(x^{*}||e^{*})$: we call this event $\textsf{F}_{2}$. By construction, since $\mathcal{H}(x^{*}||e^{*})$ is undefined, it is not possible to tell whether $K^{*}=K$, thus we have $\textsf{Pr}[\textsf{S}_{2}]=1/2$, where $\textsf{S}_{2}$ is the event that $\mathcal{A}$ succeeds in game $\textsf{G}_{2}$. We obtain that \Big{|}\textsf{Pr}[\textsf{S}_{1}]-\textsf{Pr}[\textsf{S}_{2}]\Big{|}\leq\textsf{Pr}[\textsf{F}_{2}] and we just need to bound $\textsf{Pr}[\textsf{F}_{2}]$.

We now construct an adversary $\mathcal{A}^{\prime}$ against GDP. $\mathcal{A}^{\prime}$ interacts with $\mathcal{A}$ and is able to simulate the random oracle and the decryption oracle with the help of two tables $\textsf{T}_{1}$ and $\textsf{T}_{2}$, initially empty, as described below.

Key Generation: On input the instance $(G,y^{*},w)$ of GDP, return the public key $\textsf{pk}=G$.

Challenge queries: When $\mathcal{A}$ asks for the challenge ciphertext:

Generate a random string $K^{*}$ of length $\ell_{K}$. 2. 2.

Set $\psi^{*}_{0}=y^{*}$. 3. 3.

Return the pair $(K^{*},\psi^{*}_{0})$.

Random oracle queries: Upon $\mathcal{A}$’s random oracle query $(x,e)\in\mathbb{F}_{q}^{k}\times\mathbb{W}_{q,n,w}$:

Look up $(x,e)$ in $\textsf{T}_{1}$. If $(x,e,y,K)$ is in $\textsf{T}_{1}$ for some $y$ and $K$, return $K$. 2. 2.

Compute $y=xG+e$. 3. 3.

If $y=y^{*}$ then $\mathcal{A}^{\prime}$ outputs $c=xG$ and the game ends. 4. 4.

Look up $y$ in $\textsf{T}_{2}$. If $(y,K)$ is in $\textsf{T}_{2}$ for some $K$ (i.e. the decryption oracle has been evaluated at $y$), return $K$. 5. 5.

Set $K$ to be a random string of length $\ell_{K}$ and place $(x,e,y,K)$ in table $\textsf{T}_{1}$. 6. 6.

Return $K$.

Decryption queries: Upon $\mathcal{A}$’s decryption query $y\in\mathbb{F}_{q}^{n}$:

Look up $y$ in $\textsf{T}_{2}$. If $(y,K)$ is in $\textsf{T}_{2}$ for some $K$, return $K$. 2. 2.

Look up $y$ in $\textsf{T}_{1}$. If $(x,e,y,K)$ is in $\textsf{T}_{1}$ for some $x,e$ and $K$ (i.e. the random oracle has been evaluated at $(x,e)$ such that $y=xG+e$), return $K$. 3. 3.

Generate a random string $K$ of length $\ell_{K}$ and place the pair $(y,K)$ in $\textsf{T}_{2}$. 4. 4.

Return $K$.

Note that, in both random oracle and decryption queries, we added the initial steps to guarantee the integrity of the simulation, that is, if the same value is queried more than once, the same output is returned. A fundamental issue is that it is impossible for the simulator to determine if a word is decodable or not. If the decryption algorithm returned $\bot$ if and only if a word was not decodable, then it would be impossible to simulate decryption properly. We have resolved this problem by insisting that the KEM decryption algorithm always outputs a hash value. With this formulation, the simulation is flawless and $\mathcal{A}^{\prime}$ outputs a solution to the GDP instance with probability equal to $\textsf{Pr}[\textsf{F}_{2}]$.∎∎

4 Conclusions

In this paper, we have introduced a key encapsulation method based on the McEliece cryptosystem. This novel approach enjoys a simple construction and a tight security proof as for the case of the Niederreiter KEM presented in  [11]. We believe that our new construction will offer an important alternative while designing quantum-secure cryptographic primitives.

Appendix 0.A The McEliece Cryptosystem

Appendix 0.B Other Cryptographic Tools

In this section we introduce another cryptographic tool that we need for our construction.

Definition 2

A Key Derivation Function (KDF) is a function that takes as input a string $x$ of arbitrary length and an integer $\ell\geq 0$ and outputs a bit string of length $\ell$.

A KDF is modelled as a random oracle, and it satisfies the entropy smoothing property, that is, if $x$ is chosen at random from a high entropy distribution, the output of KDF should be computationally indistinguishable from a random length-$\ell$ bit string.

Intuitively, a good choice for a KDF could be a hash function with a variable (arbitrary) length output, such as the new SHA-3, Keccak [4].