Encryption Scheme Based on Expanded Reed-Solomon Codes

TL;DR

This paper introduces a new code-based public-key cryptosystem utilizing expanded Reed-Solomon codes, offering enhanced security against certain attacks and significantly reducing key size compared to traditional systems.

Contribution

It proposes a novel encryption scheme based on shortened expanded Reed-Solomon codes that improves security and reduces key size without relying on cyclic structures.

Findings

Provides security against Schur product-based distinguishers

Achieves approximately 45% key size reduction

Demonstrates practical viability of the scheme

Abstract

We present a code-based public-key cryptosystem, in which we use Reed-Solomon codes over an extension field as secret codes and disguise it by considering its shortened expanded code over the base field. Considering shortened expanded codes provides a safeguard against distinguisher attacks based on the Schur product. Moreover, without using a cyclic or a quasi-cyclic structure we obtain a key size reduction of nearly $45 \%$ compared to the classic McEliece cryptosystem proposed by Bernstein et al.

Tables

Table 1. Table 1. Comparing key sizes of the proposed cryptosystem with m = 3 𝑚 3 m=3 and λ = 2 𝜆 2 \lambda=2 reaching a 256 256 256 -bit security level against the modified ISD algorithm.

Rate	$q$	$n$	$k$	$t$	Key Size (bits)
0.60	13	1382	829	277	6783627
0.65	13	1270	825	223	5952804
0.70	13	1207	844	182	5339456
0.75	13	1192	894	149	4929077
0.80	13	1230	984	123	4702652
0.82	13	1258	1031	114	4624198
0.85	13	1340	1139	101	4634545
0.87	13	1420	1235	93	4692805
0.90	13	1602	1441	81	4863276

Table 2. Table 2. Comparing key sizes of the proposed cryptosystem with m = 4 𝑚 4 m=4 and λ = 2 𝜆 2 \lambda=2 reaching a 256 256 256 -bit security level against the modified ISD algorithm.

Rate	$q$	$n$	$k$	$t$	Key Size (bits)
0.65	7	2360	1534	413	13134108
0.70	7	1945	1361	292	10191102
0.75	7	1738	1303	218	8480009
0.80	7	1662	1329	167	7448878
0.85	7	1700	1445	128	6815134
0.87	7	1770	1539	116	6785893
0.89	7	1872	1666	103	6754721
0.91	7	2024	1841	92	6814326

Table 3. Table 3. Comparing the key sizes of the proposed parameters against different cryptosystems.

		$q$	$m$	$n$	$k$	Key Size (in bits)
Proposed system	Type I	13	3	1258	1031	4624198
	Type II	7	4	1872	1666	6754721
classical McEliece		2	13	6960	5413	8373911
BBCRS based schemes	$w=1.708$ and $z=1$	1423	1	1422	786	5113520
	$w=1.2$ and $z=10$	1163	1	1162	928	2274160
	$w=2$ and $z=0$	1993	1	1992	1593	6966714

Equations

$$\varphi :{\mathbb{F}}_{q^m}$$

$$a_0+a_1\gamma +\cdots +a_{m-1}{\gamma }^{m-1}$$

$${\varphi }_n:{\mathbb{F}}_{q^m}^n$$

$$({\alpha }_0,{\alpha }_1,\dots ,{\alpha }_{n-1})$$

$$\hat{\mathcal{C}}:=\{{\varphi }_n(c):c\in \mathcal{C}\},$$

$$\hat{G}:=[{\varphi }_n(g_1),{\varphi }_n(\gamma g_1),\dots ,{\varphi }_n({\gamma }^{m-1}{g}_1),$$

$${\varphi }_n(g_k),{\varphi }_n(\gamma g_k)\dots ,{\varphi }_n({\gamma }^{m-1}{g}_k){]}^{⊺}.$$

$$\hat{H}:=[$$

$$\dots ,{\varphi }_{n-k}({\gamma }^{m-1}{h}_2{)}^{⊺},\dots ,{\varphi }_{n-k}(h_n{)}^{⊺},{\varphi }_{n-k}(\gamma h_n{)}^{⊺}\dots ,{\varphi }_{n-k}({\gamma }^{m-1}{h}_n{)}^{⊺}].$$

$${\varphi }_k(x)\hat{G}$$

$$=\sum _{i=1}^k{\varphi }_n\left(\sum _{j=0}^{m-1}{x}_{ij}{\gamma }^j{g}_i\right)$$

$$=\sum _{i=1}^k{\varphi }_n(x_i{g}_i)$$

$$={\varphi }_n\left(\sum _{i=1}^k{x}_i{g}_i\right)$$

$$={\varphi }_n(xG).$$

$$0$$

$$\text{support}(y)\subseteq \{\lambda$$

$$\dots ,\lambda (i_2),\dots ,\lambda (i_t-1)+1,\lambda (i_t-1)+2,\dots ,\lambda (i_t)\},$$

$$c=H^{\prime }{y}^{⊺}.$$

$${\varphi }_{n-k}^{-1}(c)$$

$${\varphi }_{n-k}^{-1}\left(\hat{H}{\bar{y}}^{⊺}\right)$$

$$x\star y=(x_1{y}_1,\dots ,x_n{y}_n).$$

$$\langle\mathcal{A}\star\mathcal{B}\rangle=\langle\{a\star b\bigm{|}a\in\mathcal{A},b\in\mathcal{B}\}\rangle.$$

$$s:\mathbb{N}$$

$$k$$

$$H=V_r(x,y):=\left(\begin{array}{cccc}{y}_1& y_2& \cdots & y_n\\ y_1{x}_1& y_2{x}_2& \cdots & y_n{x}_n\\ ⋮& ⋮& \ddots & ⋮\\ y_1{x}_1^{r-1}& y_2{x}_2^{r-1}& \cdots & y_n{x}_n^{r-1}\end{array}\right),$$

$$H^{\prime }=\left(\begin{array}{ccccccc}{V}_r(x,y)& \mid & V_r(x,\gamma y)& \mid & \cdots & \mid & V_r(x,{\gamma }^{m-1}y)\end{array}\right).$$

$$\left(\begin{array}{ccccc}{V}_k(x,y^{\prime })& 0& \dots & 0& 0\\ 0& V_k(x,{\gamma }^{-1}{y}^{\prime })& \dots & 0& 0\\ ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& \dots & V_k(x,{\gamma }^{-(m-2)}{y}^{\prime })& 0\\ 0& 0& \dots & 0& V_k(x,{\gamma }^{-(m-1)}{y}^{\prime })\\ & & & & \\ V_r(x,y^{\prime \prime })& 0& \dots & 0& -V_r(x,{\gamma }^{-(m-1)}{y}^{\prime \prime })\\ 0& V_r(x,{\gamma }^{-1}{y}^{\prime \prime })& \dots & 0& -V_r(x,{\gamma }^{1-(m-1)}{y}^{\prime \prime })\\ ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& \dots & V_r(x,{\gamma }^{-(m-2)}{y}^{\prime \prime })& -V_r(x,{\gamma }^{(m-2)-(m-1)}{y}^{\prime \prime })\end{array}\right),$$

$$\hat{G}=\left(\begin{array}{cccc}{G}_1& 0& \dots & 0\\ 0& G_2& \dots & 0\\ ⋮& ⋮& \ddots & ⋮\\ 0& 0& \dots & G_m\\ & & & \\ \text{lx@intercol}\text{hfil}{G}_{gv}\text{hfil}\text{lx@intercol}& & & \end{array}\right),$$

Full text

1. Introduction

In 1978 McEliece [31] presented the first code-based public key cryptosystem. It belongs to the family of very few public-key cryptosystems which are unbroken since decades. The hard problem the McEliece system relies on, is the difficulty of decoding a random (-like) linear code having no visible structure. McEliece proposed to use binary Goppa codes for the encryption scheme. Due to the low error-correcting capacity of Goppa codes, the cryptosystem results in large public key sizes. Several alternative families of codes have been proposed with the aim of reducing the key sizes. Some of the famous families of codes considered are: generalized Reed-Solomon codes [5, 6, 8, 10, 14, 25, 36], non-binary Goppa codes [12], algebraic geometric codes [24], LDPC and MDPC codes [7, 34], Reed-Muller codes [41] and convolutional codes [29]. Most of them were unsuccessful in hiding the structure of the private code [15, 16, 17, 18, 26, 33, 37, 42, 46].

The motivation to quest for better code-based cryptosystems is mainly due to the advent of quantum computers. In 1994 Peter Shor [40] developed a polynomial time quantum algorithm for factoring integers and solving discrete logarithm problems. This means that most of the currently popular cryptosystems, such as RSA and ECC, will be broken in an era of quantum computers. In the ongoing process of the standardization of quantum-resistant public-key cryptographic algorithms by the National Institute of Standards and Technology (NIST), code-based cryptosystems are one of the most promising candidates. At the time of this writing there are seven code-based cryptosystems included in NIST’s standardization process: BIKE [3] based on quasi-cyclic MDPC codes, classic McEliece [11] based on binary Goppa codes, ROLLO [32] based on quasi-cyclic LRPC codes, RQC [1] based on rank metric quasi-cyclic codes, HQC [1] based on Hamming metric quasi-cyclic codes, LEDAcrypt [4] based on quasi-cyclic LDPC codes and NTS-KEM [2] based on binary Goppa codes.

In this paper we present a new variant of the McEliece scheme using expanded Reed-Solomon codes. A linear $[n,k]$ code defined over an extension field $\mathbb{F}_{q^{m}}$ can be expanded, over the base field $\mathbb{F}_{q}$, to a $[mn,mk]$ linear code by expanding each codeword with respect to a fixed $\mathbb{F}_{q}$-linear isomorphism from $\mathbb{F}_{q^{m}}$ to $\mathbb{F}_{q}^{m}$. In the proposed cryptosystem we hide the structure of an expanded GRS code by puncturing and permuting the columns of its parity check matrix and multiplying by an invertible block diagonal matrix. In order to decode a large number of non-codewords, we use a burst of errors during the encryption step, i.e. we consider error vectors having support in sub-vectors of size $\lambda$. This error pattern comes with a disadvantage: it can be used to speed up the information set decoding (ISD) algorithms. However, for a small degree of extension $m$, the key sizes turn out to be remarkably competitive.

The paper is organized as follows. In Section 2, we give the preliminaries regarding the expanded codes. In Section 3, we describe the proposed cryptosystem which is based on the shortening of an expanded generalized Reed-Solomon code. In Section 4, we provide security arguments for the proposed cryptosystem against the known structural and non-structural attacks. In Section 5, we provide parameters of the proposed cryptosystem that achieve a security level of 256-bits against the ISD algorithm.

2. Background

2.1. Expanded Codes

Let $q$ be a prime power and let $m$ be an integer. Let $\gamma$ be a primitive element of the field $\mathbb{F}_{q^{m}}$, i.e. $\mathbb{F}_{q^{m}}\cong\mathbb{F}_{q}(\gamma)$. The field $\mathbb{F}_{q^{m}}$ can also be seen as an $\mathbb{F}_{q}$- vector space of dimension $m$ via the following $\mathbb{F}_{q}$-linear isomorphism

[TABLE]

We extend this isomorphism for vectors over $\mathbb{F}_{q^{m}}$ in the following way:

[TABLE]

This is clearly an $\mathbb{F}_{q}$-linear isomorphism. Hence this gives us a way to obtain a linear code over $\mathbb{F}_{q}$ from a linear code over $\mathbb{F}_{q^{m}}$.

Definition 2.1** (Expanded Codes).**

Let $n,k$ be positive integers with $k\leq n$, let $q$ be a prime power and $m$ be an integer. Let $\mathcal{C}$ be a linear code of length $n$ and dimension $k$ over $\mathbb{F}_{q^{m}}$. The expanded code of $\mathcal{C}$ with respect to a primitive element $\gamma\in\mathbb{F}_{q^{m}}$ is a linear code over the base field $\mathbb{F}_{q}$ defined as

[TABLE]

where $\phi_{n}$ is the $\mathbb{F}_{q}$-linear isomorphism defined by $\gamma$ as above.

Remark 1**.**

It is easy to see that the expanded code $\widehat{\mathcal{C}}$ is a linear code of length $mn$ and dimension $mk$, because $\phi_{n}$ is an $\mathbb{F}_{q}$-linear isomorphism and

$|\widehat{\mathcal{C}}|=|\mathcal{C}|=(q^{m})^{k}=q^{mk}$.

Given a code $\mathcal{C}$ with its generator matrix and parity check matrix, the following lemma gives a way to construct a generator matrix and a parity check matrix of the expanded code $\widehat{\mathcal{C}}$.

Lemma 2.2**.**

Let $\mathcal{C}$ be a linear code in $\mathbb{F}_{q^{m}}^{n}$.

1. (1)

Let $\mathcal{C}$ have a generator matrix $G=[g_{1},g_{2},\ldots,g_{k}]^{\intercal}$, where $g_{1},g_{2},\ldots,g_{k}$ are vectors in $\mathbb{F}_{q^{m}}^{n}$. Then the expanded code of $\mathcal{C}$ over $\mathbb{F}_{q}$ with respect to a primitive element $\gamma\in\mathbb{F}_{q^{m}}$ has the expanded generator matrix

[TABLE] 2. (2)

Let $\mathcal{C}$ have a parity check matrix $H=[h_{1}^{\intercal},h_{2}^{\intercal},\ldots,h_{n}^{\intercal}]$, where $h_{1},h_{2},\ldots,h_{n}$ are vectors in $\mathbb{F}_{q^{m}}^{n-k}$. Then the expanded code of $\mathcal{C}$ over $\mathbb{F}_{q}$ with respect to a primitive element $\gamma\in\mathbb{F}_{q^{m}}$ has the expanded parity check matrix

[TABLE]

Proof.

See [47, Theorem 1]. ∎

Proposition 1**.**

Let $\mathcal{C}$ be a linear code in $\mathbb{F}_{q^{m}}^{n}$ having a generator matrix $G=[g_{1},g_{2},\ldots,g_{k}]^{\intercal}$ and a parity check matrix $H=[h_{1}^{\intercal},h_{2}^{\intercal},\ldots,h_{n}^{\intercal}]$. Let $\widehat{G}$ and $\widehat{H}$ be the expanded generator matrix and expanded parity check matrix of $\widehat{\mathcal{C}}$, respectively. Then

1. (1)

$\phi_{n}(xG)=\phi_{k}(x)\widehat{G}$* for all $x\in\mathbb{F}_{q^{m}}^{k}$,* 2. (2)

$\phi_{n-k}(Hy^{\intercal})=\widehat{H}(\phi_{n}(y))^{\intercal}$* for all $y\in\mathbb{F}_{q^{m}}^{n}$.*

Proof.

Let $x=(x_{1},x_{2},\ldots,x_{k})\in\mathbb{F}_{q^{m}}^{k}$ and let $x_{i}=\sum_{j=0}^{m-1}x_{ij}\gamma^{j}$ for all

$i\in\{1,2,\ldots,k\}$. Then

[TABLE]

Similarly, $\phi_{n-k}(Hy^{\intercal})=\widehat{H}(\phi_{n}(y))^{\intercal}$ for all $y\in\mathbb{F}_{q^{m}}^{n}$. ∎

Remark 2**.**

$\widehat{\mathcal{C}}$ can also be determined by the commutativity of the following diagram (as $\mathbb{F}_{q}$-linear maps):

[TABLE]

3. The Cryptosystem

In this section we will present the proposed cryptosystem in the Niederreiter version. We consider an expanded GRS code whose parity check matrix can be viewed as $n$ blocks, where each block is of size $m$. In order to destroy the algebraic structure of the code, we choose $2\leq\lambda\leq m-1$ and shorten it on randomly chosen $m-\lambda$ columns in each block. We then hide the shortened code by multiplying it with an invertible matrix, which preserves the weight of a vector over the extension field $\mathbb{F}_{q^{m}}$.

Key generation:

Let $q$ be a prime power, $2\leq\lambda<m$ be positive integers and $k<n\leq q^{m}$ be positive integers, satisfying $R:=k/n>(1-\lambda/m)$. Consider a GRS code $\mathcal{C}=\text{GRS}_{n,k}(\alpha,\beta)$ of dimension $k$ and length $n$ over the finite field $\mathbb{F}_{q^{m}}$ and choose a parity check matrix $H$ of $\mathcal{C}$. Let $t$ be the error correction capacity of $\mathcal{C}$.

Let $\widehat{H}$ be the expanded parity check matrix of the expanded code $\widehat{\mathcal{C}}$ of $\mathcal{C}$ with respect to a primitive element $\gamma\in\mathbb{F}_{q^{m}}$. $\widehat{H}$ is an $m(n-k)\times mn$ matrix over $\mathbb{F}_{q}$.

Shortening $\widehat{\mathcal{C}}$

• •

For each $1\leq i\leq n$, let $S_{i}$ be a randomly chosen subset of

$\{(i-1)m+1,(i-1)m+2,\ldots,im\}$ of size $m-\lambda$ and define $S=\bigcup\limits_{i=1}^{n}S_{i}$.

• •

We puncture $\widehat{H}$ on columns indexed by $S$. Let $\widehat{H}_{S}$ be the resulting

$m(n-k)\times\lambda n$ parity check matrix and let $\widehat{\mathcal{C}}_{S}$ be the shortened code.

Hiding $\widehat{\mathcal{C}}_{S}$

• •

Choose $n$ random $\lambda\times\lambda$ invertible matrices $T_{1},T_{2},\ldots,T_{n}$ over $\mathbb{F}_{q}$. Define $T$ to be the block diagonal matrix having $T_{1},T_{2},\ldots,T_{n}$ as diagonal blocks.

• •

Now choose a random permutation $\sigma$ of length $n$ and define $P_{\sigma}$ to be the block permutation matrix of size $\lambda n\times\lambda n$. It can also be seen as Kronecker product of the $n\times n$ permutation matrix corresponding to $\sigma$ and the identity matrix of size $\lambda$.

• •

Define $Q:=TP_{\sigma}$ and compute $H^{\prime}=\widehat{H}_{S}Q$.

The private key is then $(H,Q,\gamma)$ and the public key is $(H^{\prime},t,\lambda)$.

Encryption:

Let $y\in\mathbb{F}_{q}^{\lambda n}$ be a message having support in $t$ sub-vectors each of length $\lambda$, in particular

[TABLE]

for some distinct $i_{1},i_{2},\ldots,i_{t}\in\{1,2,\ldots,n\}$. Then compute the cipher text

[TABLE]

Decryption:

For the decryption we apply $\phi_{n-k}^{-1}$ on $c$, i.e.

[TABLE]

Observe that $\widehat{H}_{S}Qy^{\intercal}=\widehat{H}\bar{y}^{\intercal}$, where $\bar{y}$ is the embedding of $yQ^{\intercal}$ to $\mathbb{F}_{q^{m}}$, by introducing zeros on the positions indexed by $S$. From Proposition 1 we get

[TABLE]

Due to the block structure of the matrix $Q$, the vector of $Qy^{\intercal}$ has support in $t$ sub-vectors each of length $\lambda$, thus $\bar{y}$ has support in $t$ sub-vectors each of length $m$. Henceforth $\text{wt}(\phi_{n}^{-1}(\bar{y}))\leq t$, and we can decode $\phi_{n-k}^{-1}(c)$ to get $\phi_{n}^{-1}(\bar{y})$. By applying $\phi_{n}$ we get $\bar{y}$ and by projecting on positions not indexed by $S$, we get $Qy^{\intercal}$ and therefore after multiplying by $Q^{-1}$, we recover the message $y$.

Choice of parameters

For low key sizes it is desirable to use a small degree of extension $m$ and small $\lambda$.

In the case of quadratic extension and in the case of $\lambda=1$, puncturing all but one column from each block results in an alternant code (subfield subcode of a GRS code). Alternant codes are known to be vulnerable to square code attacks [17, 19]. Hence, we do not propose to use quadratic extensions or $\lambda=1$.

We therefore propose to use $m=3$ and $m=4$ with $\lambda=2$.

4. Security

In this section we discuss the security of the proposed cryptosystem. We focus on the three main attacks on cryptosystems based on GRS codes. Two of them are structural (or key recovery) attacks, namely the Sidelnikov-Shestakov attack and the distinguisher attack based on the Schur product of the public code. The third one is the best known non-structural attack called information set decoding (ISD).

4.1. Sidelnikov and Shestakov attack

The first code-based cryptosystem using GRS codes as secret codes was proposed by Niederreiter in the same article [36] as the famous Niederreiter cryptosystem. This proposal was then attacked by Sidelnikov and Shestakov in [43], where they used the fact, that the public matrix is still a generator matrix of a GRS code and they were able to recover the evaluation points and hence the GRS structure of the public matrix.

In the cryptosystem proposed in Section 3, the secret GRS parity check matrix $H$ over $\mathbb{F}_{q^{m}}$ is hidden in two ways: first by puncturing its expanded parity check matrix $\widehat{H}$ over $\mathbb{F}_{q}$ and then by scrambling the columns of the punctured matrix $\widehat{H}_{S}$. Due to multiplying $\widehat{H}_{S}$ with a block diagonal matrix it is clear that the resulting code is no more equivalent to an evaluation code (or an expanded evaluation code). Hence evaluations (or expanded evaluation column vectors) can not be exploited using the Sidelnikov-Shestakov attack.

4.2. Distinguisher attack based on the Schur product

For the attack based on the Schur product we need to introduce some definitions and notations.

Definition 4.1** (Schur product).**

Let $x,y\in\mathbb{F}_{q}^{n}$. We denote by the Schur product of $x$ and $y$ their component-wise product

[TABLE]

Remark 3**.**

The Schur product is symmetric and bilinear.

Definition 4.2** (Schur product of codes and square code).**

Let $\mathcal{A},\mathcal{B}$ be two codes of length $n$. The Schur product of two codes is the vector space spanned by all $a\star b$ with $a\in\mathcal{A}$ and $b\in\mathcal{B}$:

[TABLE]

If $\mathcal{A}=\mathcal{B}$, then we call $\langle\mathcal{A}\star\mathcal{A}\rangle$ the square code of $\mathcal{A}$ and denote it by $\langle\mathcal{A}^{2}\rangle$.

Definition 4.3** (Schur matrix).**

Let $G$ be a $k\times n$ matrix, with rows $(g_{i})_{1\leq i\leq k}$. The Schur matrix of $G$, denoted by $S(G)$, consists of the rows $g_{i}\star g_{j}$ for

$1\leq i\leq j\leq k.$

We observe by Remark 3, that if $G$ is a generator matrix of a code $\mathcal{C}$ then its Schur matrix $S(G)$ is a generator matrix of the square code of $\mathcal{C}$. Let $s$ be the following map

[TABLE]

For a $k\times n$ matrix $A$, we observe that $S(A)$ has the size $s(k)\times n$.

Various McEliece cryptosystems based on modifications of GRS codes have been proved to be insecure [15, 18, 20]. This is because the dimension of the square code of GRS codes is very low compared to a random linear code of the same dimension. Moreover, other families of codes have also been shown to be vulnerable against the attacks based on Schur products. In [16], Couvreur * et al.* presented a general attack against cryptosystems based on algebraic geometric codes and their subcodes. In [19] Faugère et al. showed that high rate binary Goppa codes can be distinguished from a random code. In [17], Couvreur et al. presented a polynomial time attack against cryptosystems based on non-binary Goppa codes defined over quadratic extensions.

The distinguisher attack is based on the low dimensional square code of the public code (or of the shortened public code). In the following, based on experimental observations, we infer that the public code of the proposed cryptosystem cannot be distinguished using square code techniques.

Let $\widehat{\mathcal{C}}_{S}$ be the public code of the proposed cryptosystem. Note that $\widehat{\mathcal{C}}_{S}$ is a shortening of an expanded GRS code $\widehat{\mathcal{C}}$.

1. (1)

Squares of expanded GRS codes: Like in the case of Reed-Solomon codes and their subfield subcodes, the expanded GRS codes also have low square code dimension. To see this, we visualize expanded GRS codes as subfield subcodes of GRS-like codes. Let $\mathcal{C}$ be a GRS code of length $n$ and dimension $k$ over $\mathbb{F}_{q^{m}}$ having the following parity check matrix

[TABLE]

where $x=(x_{1},\ldots,x_{n})$ is a vector of distinct elements in $\mathbb{F}_{q^{m}}$, $y=(y_{1},\ldots,y_{n})$ is a vector over $\mathbb{F}_{q^{m}}^{\ast}$ and $r:=n-k$. Let $\gamma$ be a primitive element in $\mathbb{F}_{q^{m}}$. We define a new code $\mathcal{B}$ of length $mn$ over $\mathbb{F}_{q^{m}}$ given by the kernel of the following parity check matrix

[TABLE]

Using Lemma 2.2, it is easy to observe, that the expanded code $\widehat{\mathcal{C}}$ of $\mathcal{C}$ with respect to $\gamma$ is permutation equivalent to the $\mathbb{F}_{q}$-kernel of $H^{\prime}$. In other words $\widehat{\mathcal{C}}$ is permutation equivalent to the subfield subcode of $\mathcal{B}$ over $\mathbb{F}_{q}$. Observe that a generator matrix $G^{\prime}$ of $\mathcal{B}$ is given by

[TABLE]

where $y^{\prime}$ is such that $V_{k}(x,y^{\prime})V_{r}(x,y)^{\intercal}=0$, and $y^{\prime\prime}=(x_{1}^{k},x_{2}^{k},\ldots,x_{n}^{k})\star y^{\prime}$. One can verify that $G^{\prime}(H^{\prime})^{\intercal}=0$. Observe that a generator matrix of $\widehat{\mathcal{C}}$ is permutation equivalent to

[TABLE]

where $G_{i}$ is a generator matrix of the subfield subcode of $V_{k}(x,\gamma^{-(i-1)}y^{\prime})$ over $\mathbb{F}_{q}$, and $G_{gv}$ is a generator matrix of the $\mathbb{F}_{q}$-subfield subcode of the bottom $(m-1)r$ rows of $G^{\prime}$. The matrix $G_{gv}$ is also known as the glue-vector generator matrix, as in [45]. Due to the block structure of $\widehat{G}$ the Schur matrix of $\widehat{G}$ will have many zero rows. As a result the dimension of the square code is not full, given large enough $n$. This may lead to vulnerabilities when using expanded GRS codes directly in the cryptosystem. 2. (2)

Effect of Shortening: Consider the parity check matrix $\widehat{H}$ of an expanded GRS code as shown in Lemma 2.2. We partition the columns of $\widehat{H}$ into $n$ blocks, each of size $m$. By the definition of $\widehat{H}$, each of these blocks corresponds to a unique column vector of the parity check matrix of the parent GRS code. In order to weaken this correspondence, we puncture (randomly chosen) $m-\lambda$ of the columns from each block of $\widehat{H}$. As a result the correspondence of each block to the parent column vector is inconsistent. In addition we multiply the punctured parity check matrix by an invertible block diagonal matrix $T$. This further destroys the algebraic structure inherited from the parent GRS code. This was evident in our computations of the square code dimension of such shortened codes. Even in the case of $m=3$ we observed that puncturing one column from each block of $\widehat{H}$ results in a full square code dimension.

4.3. Information Set Decoding

Information set decoding (ISD) algorithms are the best known algorithms for decoding a general linear code. ISD algorithms were introduced by Prange [39] in 1962. Since then several improvements have been proposed for codes over the binary field by Lee-Brickel [27], Leon [28], Stern [44] and more recently by Bernstein et al. [13], Becker et al. [9], May-Ozerov [30]. Several of these algorithms have been generalized to the case of codes over general finite fields, see [21, 22, 23, 35, 38].

An ISD algorithm in its simplest form first chooses an information set $I$, which is a size $k$ subset of $\{1,2,\ldots,n\}$ such that the restriction of the parity check matrix on the columns indexed by the complement of $I$ is non-singular. Then Gaussian elimination brings the parity check matrix in a standard form and assuming that the errors are outside of the information set, these row operations on the syndrome will exploit the error vector, if the weight does not exceed the given error correction capacity.

ISD for the proposed cryptosystem:

In the proposed cryptosystem we introduce a burst pattern in the error vector, in particular the error vector has support in $t$ sub-vectors each of length $\lambda$. Henceforth, we modify Stern’s ISD algorithm to incorporate such pattern in the error vector.

We first recall the Stern’s algorithm. The algorithm partitions the information set $I$ into two equal-sized subsets $X$ and $Y$, and chooses uniformly at random a subset $Z$ of size $\ell$ outside of $I$. Then it looks for vectors having exactly weight $p$ among the columns indexed by $X$, exactly weight $p$ among the columns indexed by $Y$, and exactly weight 0 in columns indexed by $Z$ and the missing weight $t-2p$ in the remaining indices.

In the proposed cryptosystem we have been given a public code $\widehat{\mathcal{C}}_{S}$ of length $\lambda n$ and dimension $k^{\prime}:=mk-(m-\lambda)n$ over $\mathbb{F}_{q}$. We also know that the error vector has support in $t$ sub-vectors of length $\lambda$. Hence we use Stern’s algorithm on the blocks of size $\lambda$. We consider the information set $I$ to have $\left\lfloor k^{\prime}/\lambda\right\rfloor$ blocks. We partition $I$ into two equal-sized subsets $X$ and $Y$, and choose uniformly at random a subset $Z$ of $\ell$ blocks outside of $I$. Then we look for vectors having support in exactly $p$ blocks in $X$, exactly $p$ blocks in $Y$, and exactly 0 blocks in $Z$.

In Section 5 we compute the key sizes of the proposed cryptosystem having 256-bit security against this modified ISD algorithm.

5. Key size

In this section we compute the key sizes of the proposed cryptosystem having 256-bit security against the ISD algorithm discussed in Section 4.3. Later we compare these key sizes with the key sizes of the McEliece cryptosystem using binary Goppa codes [11] and some recently proposed cryptosystems that are using Reed-Solomon codes as secret codes. These are based on the idea of [5, 6] (BBCRS), where the authors proposed to hide the structure of the code using as transformation matrix the sum of a rank $z$ matrix and a weight $w$ matrix. The proposed parameters in [5, 6] with $z=1$ and $w\leq 1+R$ were broken by the square code attack [15, 18], where $R$ denotes the rate of the code. Two countermeasures were recently proposed in [8, 25]. In order to hide the structure of the Reed-Solomon code the authors of [8] use $w>1+R$ and $z=1$ or $w<1+R$ and $z>1$. Whereas in [25] the transformation matrix has weight $w=2$ and rank $z=0$.

In the proposed cryptosystem, the public key is a parity check matrix of a linear code over $\mathbb{F}_{q}$ having length $\lambda n$ and dimension $mk-(m-\lambda)n$. Hence the public key size is $(\lambda n-m(n-k))\cdot m(n-k)\cdot\log_{2}(q)$ bits. For a degree of extension $m$, let $\mathcal{C}_{m}$ be the public code.

In Table 1, we provide the key sizes for different rates of the public code $\mathcal{C}_{3}$ achieving a 256-bit security level against the modified ISD algorithm discussed in Section 4.3. Observe that the smallest key size is achieved at rate $0.82$.

In Table 2, we provide the key sizes for different rates of the public code $\mathcal{C}_{4}$ achieving a 256-bit security level against the modified ISD algorithm discussed in Section 4.3. In this case the smallest key size is achieved at rate $0.89$.

In conclusion, for a $256$ bit security level we propose to use the cryptosystem with the two sets of parameters $(q=13,m=3,\lambda=2,n=1258,k=1031)$ and $(q=7,m=4,\lambda=2,n=1872,k=1666)$, see Table 3.

The proposed parameters for the classic McEliece system using binary Goppa codes by Bernstein et al. in [11] are $q=2,m=13,n=6960,k=5413$, which gives a key size of $8373911$ bits. It achieves a security level of 260-bits with respect to the ball-collision algorithm [13].

In comparison to the classic McEliece system, the Type I set of parameters reduces the key size by $44.8\%$ and the Type II set of parameters reduces the key size by $19.3\%$.

6. Acknowledgement

The authors would like to thank Matthieu Lequesne and Jean-Pierre Tillich for pointing out the square code vulnerability in the case of quadratic extensions. This work has been supported by the Swiss National Science Foundation under grant no. 169510.