Skip to main content
Springer logoLink to Springer
. 2025 May 20;93(9):3481–3505. doi: 10.1007/s10623-025-01649-1

Information-set decoding for convolutional codes

Niklas Gassner 1, Julia Lieb 2, Abhinaba Mazumder 1,✉, Michael Schaller 1
PMCID: PMC12436584  PMID: 40964001

Abstract

In this paper, we present a framework for generic decoding of convolutional codes, which allows us to do cryptanalysis of code-based systems that use convolutional codes as public keys. We then apply this framework to information set decoding, study success probabilities and give tools to choose variables. Finally, we use this to attack two cryptosystems based on convolutional codes. In the case of Bolkema et al. (Variations of the McEliece cryptosystem. In: Algebraic geometry for coding theory and cryptography: IPAM, Los Angeles, CA, Feb 2016. Springer, Cham, pp 129-150, 2017. https://doi.org/10.1007/978-3-319-63931-4_5), our code recovered about 74% of errors in less than 10 h each, and in the case of Almeida et al. (Smaller keys for code-based cryptography: McEliece cryptosystems with convolutional encoders. CoRR abs/2104.06809, 2021. arXiv: https://arxiv.org/abs/2104.06809v1), we give experimental evidence that 80% of the errors can be recovered in times corresponding to about 70 bits of operational security, with some instances being significantly lower.

Keywords: Cryptography, Coding theory, Information-set decoding, Convolutional codes

Introduction

Current cryptographic systems rely on the hardness of integer factorisation or the discrete logarithm problem. These problems can be solved efficiently with Shor’s algorithm on a quantum computer [27]. This led to a new interest in post-quantum cryptography, a part of which is cryptography based on linear codes. The first code-based cryptosystem was proposed in 1978 by McEliece [22] and uses binary Goppa-codes. The proposal is still fundamentally intact and the proposal Classic McEliece [3] is based on it. Round 4 of the currently ongoing post-quantum competition of the National Institute of Standards and Technology (NIST) features three code-based public-key submissions, the already mentioned Classic McEliece, BIKE [9], and HQC [1], which was recently selected for standardisation [2].

There have been proposals not featured in the NIST post-quantum competition based on convolutional codes, such as [20] (attacked in [17]), [6], or [23]. The rationale behind this is that the key size is linear in the memory of the convolutional code, while security levels are reliant on the size of the sliding generator or parity-check matrix, leading to an expected exponential increase in time for generic decoding methods and thus, increased security. For example, in the Viterbi algorithm [30] the decoding complexity is exponential in the degree. Additionally for the receiver of the ciphertext, decoding a convolutional code can be done sequentially.

In this paper, we provide a framework for generic decoding of convolutional codes (which are not tail-biting) which is similar to sliding window decoding and apply it to information-set decoding. The framework resembles the idea of sequential decoding, which was introduced in [31]. We study success probabilities of several aspects of the algorithm and give tools to choose parameters in the framework. Finally, we use it to attack the system proposed in [12] and a set of parameters of the system proposed in [5] which is based on the system from [4]. Note that there exist updated versions [6, 7] of [5] with tail-biting convolutional codes, where our attack does not apply.

The paper is organised as follows.

In Sect. 2, we give an overview of linear codes and especially convolutional codes, where we introduce all the notions and notations necessary for understanding our work.

In Sect. 3, we cover the basics of information-set decoding, a class of generic decoding methods for linear codes, where we mainly talk about Prange’s algorithm.

The remaining sections cover our own contribution. In Sect. 4, we discuss information-set decoding for convolutional codes. We first give a general framework for generic decoding of convolutional codes that reduces the problem to decoding a smaller block code multiple times and then discuss how we apply it to information-set decoding. We justify our choice of a depth-first algorithm, then discuss the issues posed by low weight codewords and how we adapt the algorithm to address these issues. Many of the components of our algorithm are probability based, so we provide tools that allow us to compute success probabilities for given parameters and thus help us to choose parameters.

Finally, in Sect. 5 we describe how we can apply our framework to McEliece type cryptosystems whose public key is a convolutional code. In addition, we describe our implementation of the attack and the results of attacking the cryptosystem proposed in [12] and a parameter set of the cryptosystem proposed in [5]. Since computation times were in most cases infeasible for the latter, we only provide an estimate of the computation time necessary for recovering errors for most random seeds. We also ran the algorithm in full for two cases, where the estimates of the computation time were low enough, and managed to recover the correct error in both cases.

Notation and conventions

For the convenience of the reader, we summarize some notation that we will use throughout the paper.

  • Fq the finite field with q elements,

  • C⊂Fq[z]n a convolutional code, where n is its length and k its rank as an Fq[z]-submodule of Fq[z]n,

  • C⊆FqN a block code of length N and dimension K,

  • matrices and vectors are denoted with bold capital respectively small letters (e.g. G and v),

  • G(z) and H(z) for a generator matrix and parity-check matrix, respectively, of a convolutional code C,

  • I an information set.

Basics of linear codes and convolutional codes

In this section we present definitions and results for linear block and convolutional codes that will be important in later sections of this paper.

Definition 1

Let K,N∈N with K≤N. A linear [N, K]-block code C is a K-dimensional subspace of FqN. Hence, there is a full rank matrix G∈FqK×N such that

C={c∈FqN|c=mGform∈FqK}.

G is called generator matrix, N length and K/N rate of C.

While the generator matrix is used for the encoding of a message, for the decoding of a received word one usually uses another matrix, called parity-check matrix, as defined in the following.

Definition 2

Let C be a linear [N, K]-block code. A full rank matrix H∈Fq(N-K)×N such that

C={c∈FqN|Hc⊤=0}

is called parity-check matrix of C.

Lemma 3

Let G∈FqK×N be a generator matrix of a linear block code C. A matrix H∈Fq(N-K)×N is a parity-check matrix for C if and only if HG⊤=0 and H is full rank.

Definition 4

The support of c=(c1,…,cN)∈FqN is defined as

supp(c):={i∈{1,…,N}:ci≠0}.

The (Hamming) weight of c=(c1,…,cN)∈FqN, denoted by wt(c), is defined as |supp(c)|, i.e. as the number of nonzero components of the vector c.

Definition 5

The minimum distance of a linear block code C is defined as

d:=min{wt(c)|c∈C\{0}}.

In the following, we introduce the basics of convolutional codes, which can be understood as a generalization of linear block codes. More details about convolutional codes can be found in [19].

Definition 6

A convolutional code C of length n is defined as an Fq[z]-submodule of Fq[z]n. Let k be the rank of C. Then, k/n is the rate of C and we call C an (n, k) convolutional code.

Remark 7

Note that Fq[z] is a Principal Ideal Domain, and thus all submodules of Fq[z]n are free. Then, it makes sense to speak of the rank k of the submodule.

Definition 8

There exists a polynomial matrix G(z)∈Fq[z]k×n such that

C={c(z)=m(z)G(z)|m(z)∈Fq[z]k}.

G(z) is called generator matrix of C. If we write G(z)=∑i=0μGizi with Gμ≠0, then μ is called memory of G(z). The maximal degree of the full size (i.e. k×k) minors of G(z) is called is called degree δ of C.

Note that a generator matrix is not unique and the memory μ depends on G(z), however the degree δ of C does not depend on the choice of the generator matrix.

Definition 9

A polynomial matrix U(z)∈Fq[z]k×k is called unimodular if there exists V(z)∈Fq[z]k×k such that V(z)U(z)=U(z)V(z)=Ik.

Unimodular matrices are used to determine whether two matrices generate the same code.

Remark 10

Two full rank matrices G(z),G~(z)∈Fq[z]k×n are generator matrices of the same code if and only if there exists a unimodular matrix U(z)∈Fq[z]k×k such that

G~(z)=U(z)G(z).

G(z) and G~(z) are then called equivalent.

In the next part of this section, we want to consider parity-check matrices for convolutional codes. In contrast to linear block codes, not every convolutional code admits a parity-check matrix.

Definition 11

Let C be an (n, k) convolutional code. A full row rank polynomial matrix H(z)∈Fq[z](n-k)×n is called parity-check matrix of C, if

C={c(z)∈Fq[z]n|H(z)c(z)⊤=0}.

If such a parity-check matrix exists for the code C, then C is called non-catastrophic.

In the following, we will describe how to decide whether a convolutional code possesses a parity-check matrix and how to calculate it if it exists.

Definition 12

For k≤n, G(z)∈Fq[z]k×n is called left prime if in all factorisations G(z)=L(z)G^(z), with L(z)∈Fq[z]k×k and G^(z)∈Fq[z]k×n, the left factor L(z) is unimodular.

Definition 13

Let G(z)∈Fq[z]k×n with k≤n be full (row) rank. Then, there exists a unimodular matrix U(z)∈Fq[z]n×n such that

GrH(z)=G(z)U(z)=h11(z)0…00…0⋮⋱⋱⋮⋮⋮⋮⋱0⋮⋮hk1(z)⋯…hkk(z)0…0, 1

where hii(z) are monic for i=1,⋯,k and deg(hii)>deg(hij) for each j<i. The matrix GrH(z) is called row Hermite form of G(z).

Theorem 14

[19] Consider G(z)∈Fq[z]k×n with k≤n. The following statements are equivalent:

  1. G(z) is left prime.

  2. The row Hermite form of G(z) is Ik0.

  3. There exists M(z)∈Fq[z]n×k such that G(z)M(z)=Ik.

  4. G(z) can be completed to a unimodular matrix, i.e. there exists E(z)∈Fq[z](n-k)×n such that G(z)E(z) is unimodular.

  5. rk(G(λ))=k for all λ∈F¯q, where F¯q denotes the algebraic closure of the field Fq.

Definition 15

A polynomial matrix G(z)∈Fq[z]k×n is said to be delay-free if G(0) is full row rank. A convolutional code C⊂Fq[z]n is called delay-free if its generator matrices are delay-free.

It is easy to see that if one generator matrix of a convolutional code is delay-free, then all its generator matrices are delay-free and hence it makes sense to speak of delay-free convolutional codes. Moreover, note that by Theorem 14 all non-catastrophic convolutional codes are delay-free.

Theorem 16

[19] Let C be an (n, k) convolutional code. Then, C admits a parity-check matrix H(z)∈Fq[z](n-k)×n if and only if any of the generator matrices of C is left prime.

Corollary 17

Let G(z)∈Fq[z]k×n be a left-prime generator matrix of a convolutional code C. A matrix H(z)∈Fq[z](n-k)×n is a parity-check matrix for C if and only if H(z)G(z)⊤=0 and H(z) is full rank.

Next we describe, how a parity-check matrix for a convolutional code can be calculated if it exists.

First the row Hermite form GrH(z) of G(z)∈Fq[z]k×n is computed. According to Theorem 14 there exists a parity-check matrix if and only if GrH(z)=Ik0. If this is true, calculate V(z)∈Fq[z]n×n such that G(z)V(z)=Ik0. Then, the last n-k rows of V(z)⊤ form a parity-check matrix for the convolutional code with generator matrix G(z).

If G(z)∈Fq[z]k×n is not left prime, the corresponding convolutional code C does not posses a parity-check matrix. However, it is still possible to find a left prime polynomial matrix H(z)∈Fq[z](n-k)×n that plays the role of a parity check matrix for C in the sense that

C⫋kerH(z).

Since G(z) is not left prime, one has

G(z)=L(z)0U(z),

where L(z)0 is the row Hermite form of G(z) and U(z)∈Fq[z]n×n unimodular and L(z)∈Fq[z]k×k is not the identity matrix. It follows that G(z)=L(z)U1(z), where U1(z) consists of the first k rows of U(z), i.e. U1(z) is left prime by Theorem 14. Hence, the convolutional code C~ with generator matrix U1(z)∈Fq[z]k×n is non-catastrophic and has a parity-check matrix H(z). Finally, one has

C⫋C~=kerH(z).

In the following we introduce distance measures for convolutional codes.

Definition 18

The weight of a polynomial vector c(z)=∑i∈Z≥0cizi∈Fq[z]n is defined as

wt(c(z))=∑i∈Z≥0wt(ci).

Definition 19

Let C be an (n, k) convolutional code. The free distance of C is defined as

dfree(C)=min{wt(c(z)):c(z)∈C\{0}}.

The free distance is a measure for the total number of errors a convolutional code can correct. However, we will carry out the decoding of a convolutional code by splitting the received word and codeword into parts, so-called windows, and decode one window after the other. To this end, we need to introduce so-called sliding matrices.

Let

G(z)=∑i∈Z≥0Gizi∈Fq[z]k×n

be a generator matrix of a non-catastrophic (n, k) convolutional code C and

H(z)=∑i∈Z≥0Hizi∈Fq[z](n-k)×n

be a parity-check matrix, where Gi=0 if i>deg(G(z)) and Hi=0 if i>deg(H(z)). For γ∈Z≥0, consider the sliding generator-matrix

G~0γ:=G0G1⋯GγG0⋯Gγ-1⋱⋮G0

and the sliding parity-check matrix

H~0γ:=H0⋮⋱Hγ⋯H0.

Furthermore, for i>0 we define

G~iγ:=Gi(γ+1)Gi(γ+1)+1⋯Gi(γ+1)+γGi(γ+1)-1Gi(γ+1)⋯Gi(γ+1)+(γ-1)⋮⋮⋱⋮Gi(γ+1)-γGi(γ+1)-(γ-1)…Gi(γ+1),

where Gj=0 if j>deg(G(z)).

Definition 20

Let C be an (n, k) convolutional code. For γ∈Z≥0, the γth column distance of C is defined as

dγc(C):=min∑t=0γwt(ct)|c(z)∈Candc0≠0.

If C is delay-free with generator matrix G(z)=∑i∈Z≥0Gizi∈Fq[z]k×n, it follows

dγc(C)=min{wt((m0,…,mγ)G~0γ):m(z)∈Fq[z]kwithm0≠0}.

If C is non-catastrophic with parity-check matrix

H(z)=∑i∈Z≥0Hizi∈Fq[z](n-k)×n,

one obtains

dγc(C)=min∑t=0γwt(ct)|H~0γc0⋮cγ=0andc0≠0.

One has that

d0c(C)≤d1c(C)≤⋯≤limγ→∞dγc(C)≤dfree(C),

reflecting the fact that the larger we choose the decoding window, the more errors can be corrected inside this window.

We now write the equation m(z)G(z)=c(z) with ℓ:=deg(m(z)) as

(m0,…,mℓ)G0⋯GμG0⋯Gμ⋱⋱G0⋯Gμ=(c0,…,cℓ+μ). 2

Assume we decoded the messages up to a time instant t-1, then we can use the following equation:

(m0,⋯,mt-1|mt,⋯,mt+γ)G0⋯Gt-1Gt⋯Gt+γ⋱⋮⋮⋮G0G1⋯Gγ+1G0⋯Gγ⋱⋮G0=(c0,…,ct+γ)

and rewrite it as

(mt,⋯,mt+γ)G0⋯Gγ⋱⋮G0=(ct,…,ct+γ)-(m0,⋯,mt-1)Gt⋯Gt+γ⋮⋮G1⋯Gγ+1.

Denote the received word after transmission by r(z)=∑i∈Z≥0rizi∈Fq[z]n.

Then, (mt,⋯,mt+γ) can be recovered by decoding

(rt,…,rt+γ)-(m0,⋯,mt-1)Gt⋯Gt+γ⋮⋮G1⋯Gγ+1

in the block code with generator matrix G~0γ.

This process can be iterated by sliding the decoding window by γ+1 time steps to (rt+γ+1,…,rt+2γ+1) and in this way the whole message m(z) can be recovered with several decoding steps in the block code with generator matrix G~0γ.

Basics of information-set decoding

Information-set decoding (ISD) is a generic decoding technique for linear codes. In this section we introduce the simplest form of ISD, the Prange algorithm [26]. Several improvements exist, such as [11, 15, 18, 21, 25, 28], and [10].

Definition 21

Let C be an [N, K] linear block code and G be a generator matrix of C. For any subset I⊆{1,…,N} we define GI to be the submatrix of G with columns indexed by I. Then any subset I⊆{1,…,N} of size K such that GI is invertible is called an information set.

The general idea is as follows. Given an erroneous codeword c+e, we wish to find an information set I⊂{1,…,N} such that I∩supp(e)=∅. This implies that c is uniquely determined by the positions indexed by I. If we have done so, we can easily recover the codeword c with linear algebra, hence also the error. In order to find such a set, we try random information sets, do the procedure described above and check if the weight of the recovered error is within specified bounds. We continue until we have found an error of small enough weight.

More formally, we do the following in the Prange algorithm. Let t be an upper bound for the number of errors, G be a generator matrix of the code, r the received word, GI the submatrix of G with columns indexed by I and rI the vector consisting of the entries of r indexed by I. The algorithm is as follows.

  1. Pick a random information set I.

  2. Solve the equation mGI=rI for m.

  3. Set e=r-mG.

  4. If wt(e)≤t, output e, else go back to step 1.

If t is within the unique decoding radius, the algorithm succeeds if an information set I is found such that I has no intersection with the support of the error e.

Assuming that every subset of size K is an information set (which is only true if the code is maximum distance separable, i.e. the minimum distance is d=N-K+1) and that there is a unique solution, we get for each time we do steps (1), (2) and (3), a probability of N-Kt/Nt that I∩supp(e)=∅. The expected number of iterations, which we call the workfactor, is the reciprocal of this, denoted by

WFt=NtN-Kt.

ISD for delay-free convolutional codes

In this section, we study ISD for delay-free convolutional codes (i.e. G(0) has full rank). For this, we rewrite a sliding generator matrix of G(z)=∑i=0μGizi as

G~=G~0γG~1γ⋯G~lγ⋱⋱⋮⋱G~0γG~1γ⋯G~lγG~0γ⋱⋮⋱G~1γG~0γ, 3

where G~iγ has size k(γ+1)×n(γ+1). The parameter γ will be chosen in Sect. 4.2.4 to optimize the running time. Note that when γ=0, we have G~iγ=Gi, but G~iγ can consist of several of the Gj’s, for example, for γ=2, we have

G~02=G0G1G2G0G1G0,

and

G~12=G3G4G5G2G3G4G1G2G3.

We will also write the error vector as e=(e~0,e~1,…,e~s-1), where e~i is of size n(γ+1).

Generic decoding of convolutional codes

Given the encrypted message r(z)=m(z)G(z)+e(z), we aim to find m(z)G(z) and consequently m(z).

As before, we turn a polynomial vector v(z)=∑i=0dvizi∈Fq[z]n into v=(v0,v1,…,vd)∈Fqnd. Let v~i be the concatenation of several consecutive vi’s. We get v=(v~0,v~1,…,v~s-1).

The idea is to iteratively decode the convolutional code with the matrix G~ as follows:

  1. Step 0: Use generic decoding to recover e~0 from r~0=m~0G~0γ+e~0 and recover m~0 from m~0G~0γ with linear algebra.

  2. Step j for j=1,..., s-1:
    1. Compute m~jG~0γ+e~j=r~j-∑i=0j-1m~iG~j-iγ.
    2. Recover e~j and m~j with generic decoding for the code generated by G~0γ.

For cryptographic purposes there exists only one error e(z) with at most a certain Hamming weight such that r(z) can be written as codeword plus error. However, we might not find a unique solution e~j in each block. So at each step, we produce a list of possible error vectors (e~j,1,…,e~j,nj) where e~j,ρ∈FqN for ρ∈{1,…,nj} are the errors that we recovered using ISD in Step j. We also get from the list of possible errors a list of possible messages (m~j,1,…,m~j,nj). This gives us a tree, and we aim to find a branch that goes to the bottom of the tree. To find such a branch, we use a depth-first algorithm. In Sect. 4.2.1, we will first describe this procedure and then justify the choice of a depth-first algorithm over a breadth-first algorithm. As a generic decoding method, we use information set decoding, but in principle, any generic decoding method can be used.

Note further that one can also use overlapping parts of the received word for decoding and use a consistency check on the recovered messages to limit the number of possibilities in the search. For our experiments this did not give huge speedups, but it might be useful if one uses different codes.

Using ISD for convolutional codes

We want to use information set decoding (ISD) as a generic method of decoding. Let t be the expected weight of an error block e~i, rounded up to the next integer. While we expect t errors in each block, the chance of each block having at most t errors can be very small. So we introduce a variable ε and allow up to t+ε errors in each block. Note that ε can be chosen so that an arbitrarily high percentage of the errors satisfies this condition, but increasing ε increases the number of solutions we obtain at each step and thus increases computational time. We will discuss how to choose ε in Sect. 4.3.1.

Note that the first solution we find might not be the correct one, or, if the algorithm is currently running on a “wrong” branch, no solution may be found. So, aborting the ISD search after an error is found is not an option. Our solution to this issue is to simply run the algorithm for a fixed amount of iterations and collect all solutions. The number of iterations can be chosen such that it is almost guaranteed that the correct error will be in the list of outputs at every step as we will explain later. Thus, if no solutions are found, we expect to be on a wrong branch.

The choice of a depth-first algorithm

Depth-first algorithms, in general, have lower memory usage than breadth-first algorithms. However, our main reason for choosing a depth-first algorithm is that for our purposes, we expect a depth-first algorithm to run faster than a breadth-first algorithm. The reasons for this we shall explain in this subsection.

Depth-first search works as follows. We start with a tree and always move down the left-most possible branch. Once we cannot move down any further we backtrack and then move down the left-most branch we have not explored yet. Note that we do not have to store what we have explored already if we store in an appropriate way which branches we have yet to explore.

In Fig. 1, we labeled the nodes in the tree according to the sequence in which we encounter them in a depth first search. To be precise we go from 1 to 2, 3, 4. Then we backtrack to 3, from which we go to 5. After this we backtrack all the way to 1 from where we go to 6 and traverse the remaining graph.

Fig. 1.

Fig. 1

Depth-first search

We only worked with the most basic instance of ISD, the Prange algorithm. Recall from Sect. 3 that, after a choice of an information set I, Prange succeeds in recovering an error if the support of the error is contained in the complement of I. This is more likely to happen for errors of smaller weight, so errors of smaller weight have a higher probability of getting found first by the algorithm than errors of higher weight.

We allow up to t+ε errors in each window. However, in most cases, the correct error vector will have a smaller weight. Indeed, the average weight in each block is t, and the probability of the weight exceeding t by a significant amount is low, as explained in Sect. 4.3. This means that the correct error has a tendency to appear at one of the first positions of the output lists of the ISD search at each step. So in most steps, the depth-first algorithm will immediately proceed with the correct error.

Furthermore we heuristically expect a kind of avalanche effect or diffusion, meaning that if we have several wrong messages the error will spread and there will be no close codewords to the received word. Hence the algorithm should not go too deep in the depth first search for wrong errors and messages.

Our observations from the experiments are in line with these expectations.

Low weight codewords

Let G(z)=∑Gizi∈Fq[z]k×n and H(z)=∑Hizi∈Fq[z](n-k)×n, with H0 full rank, be a generator matrix and a parity-check matrix, respectively, of the same non-catastrophic convolutional code C. Note that each non-catastrophic convolutional code possesses a left-prime parity-check matrix H(z), and hence, in particular a parity-check matrix H(z) such that H0 is full rank. Then, for γ∈Z≥0, it is an easy consequence of Lemma 3 that H~0γ is a parity-check matrix for the block code with generator matrix G~0γ.

Note that the block code with generator matrix G~0γ (like each block code) always possesses a parity-check even if the corresponding convolutional code is catastrophic. Moreover, it is important to note that, due to the restriction v0≠0, respectively u0≠0, in the definition of column distances, the distance of the block code with generator matrix G~0γ is upper bounded by dγc but can be much smaller. While a convolutional code C with generator matrix G(z) may have a large minimum distance, the linear code generated by the matrix

G~0γ=G0G1⋯GγG0⋱⋮⋱G1G0

can have codewords of small weight. Note that the code generated by G~0γ contains codewords of the form (0,…,0,c), where c lies in rowspan(G0). Note further that if C is delay-free (that is, G0 has full rank), every non-zero codeword of rowspan(G~0γ) is of the form

(0,…,0,c,r1,…,ri)

for a non-zero c∈rowspan(G0). So the minimum distance of the code generated by G~0γ equals the one of the code generated by G0.

Actually, if one has a message of the form m=(m0,…,mγ) where i∈{0,…,γ} is minimal such that mi≠0, then the weight of c=(c0,…,cγ)=mG~0 is lower bounded by dγ-ic(C) and c0=⋯=ci-1=0, ci≠0.

Undetectable errors

Since we are working with Prange’s algorithm, errors can’t be detected if the support of a codeword is contained in the support of the error. This is formalized in the following proposition, which states that an information set I of a a linear code C over Fq must intersect the support of each codeword.

Proposition 22

Let I be an information set for an [N, K]-code C and c∈C\{0}. Then supp(c)∩I≠∅.

Proof

Let c be in C\{0} and I⊂{1,…,N} a set of size K that has trivial intersection with the support of c. Pick a basis of C that contains c and arrange them in a generator matrix G such that the last row is c. The last row of the matrix GI, consisting of the columns indexed by I, is a zero row, so GI is not invertible. This means that I is not an information set. □

Note that in these cases, the error e can be written as e=e′+c, where c is a codeword whose support is contained in the support of e and e′ is an error which can be recovered by the Prange algorithm. So we can ensure that e is in our list of outputs by pre-computing a list of low-weight codewords (for our experiments codewords of weight up to 2 were sufficient for most cases) and then, for all possible errors e′ in the output of the Prange algorithm and low-weight codewords c, appending e′+c at the end of the list of outputs if wt(e′+c)≤t+ε. It is important that the new solutions get appended at the end of the list when working in a setting where it is unlikely to happen that the support of an error contains the support of a codeword.

The choice of γ

Recall that γ+1 is the number of distinct Gi’s in our matrix G~0γ which we use for iterative decoding (see beginning of Sect. 4). Note that the choice of γ can heavily impact the decoding complexity: choosing a large γ will increase the ISD cost in each step, while choosing a small γ increases the number of steps. This could potentially substantially increase the nodes the algorithm will transverse in the depth-first search. Thus, γ needs to be carefully chosen depending on the parameters of the cryptosystem. In fact, if we choose γ to be the maximum of the memory of the generator matrix and the degree of the error vector e(z), then we are in the setting of decoding a single block code. On the other hand, a small γ might also not be suitable for decoding. Consider the case

G(z)=(g1(z),g2(z)),

where g1(z),g2(z)∈F2[z] are of large degree. If we choose γ=0, that is, G~0γ consists of the constant terms of g1(z) and g2(z), then only a small percentage of errors will have at most 1 error in each block. But if we decode with at most 2 errors per block, then we get 4 solutions in each step, at which point we are essentially just brute-forcing all solutions.

We have not found a rigorous way of choosing γ optimally and have resorted to experimentation.

ISD for a fixed amount of errors uniformly distributed over the error vector

Our goal in this section is to reduce the information-set decoding of a convolutional code to the ISD of equations of the form

miG0γ~+ei~,

or equivalently

H~0γe~iT=si.

The analysis consists of several steps. We first want to compute the probability that blocks of the error contain at most t+ε non-zero entries for a given ε.

We will assume the following: C is a delay-free convolutional code, and the error vector e of length sN is such that the errors are uniformly distributed over its length.

Exceedance probability for the error distributions

Let te be the total error weight, N the length of the code generated by G~0γ, s the number of blocks of size N we need for decoding, t=⌈te/s⌉, the (rounded) expected number of errors in each size N window, and ε the tolerance for the error weights.

To give the exact probability of an error having at most weight t+ε in each window of size N, we consider the polynomial

p(z)=1+(q-1)N1z+(q-1)2N2z2+⋯+(q-1)t+εNt+εzt+ε.

We compute

q(z)=p(z)s

and recover the te’th coefficient of q(z),  which gives us the number of error vectors of weight te with at most t+ε errors in each block of size N. Dividing by the total number of weight te error vectors, which is

(q-1)tesNte,

yields the probability of having at most t+ε errors in each block. One can reformulate this in terms of a multivariate hypergeometric distribution. More information about multivariate hypergeometric distributions can be found in [16]. Note that in each block we get a hypergeometric distribution, which we use for an estimate of the tails in the next section.

Estimates, hypergeometric distribution

The hypergeometric distribution has an exponentially decaying tail; see [14]. Let us consider the tail of a hypergeometric distribution given by

H(A,B,b,l)=Bb-1∑i=lbAiB-Ab-i.

Define α through the equation

l=AB+αb,

where α should be greater than 0. One can show as in [14] that we get for the tail

H(A,B,b,l)≤e-2α2b.

In the setting above we have A=N,B=Ns,b=ts. Hence

AB=1s,

and

l=t+αts.

Thus, if ε=αts, then we get that the probability of having at least t+ε errors in a block is at most

e-2α2ts=e-2αε.

For the error weight of the block to exceed t+ε, we set l=t+ε+1, getting α=(ε+1)/st. Then the probability of the block having error weight more than t+ε is at most

e-2α2ts=e-2α(ε+1).

By the Union bound, we have:

P[max{wt(e~j),j=0,…,s-1}>t+ε]≤sH(N,Ns,ts,t+ε+1)≤se-2α2ts=se-2α(ε+1),

where e~j is the jth error coefficient.

Estimates on the number of solutions when the amount of errors exceeds the unique decoding radius

Given a (random) full-rank matrix H∈Fq(N-K)×N, an error vector e∈FqN of weight t and s∈FqN-K we want to compute the expected amount of solutions of the equation

HeT=s 4

of weight at most t+ε. We care about the conditional expectation

E[#solutions with at mostt+εerrors|at least one such solution exists]≈1+E[#solutions with at mostt+εerrors]. 5

Note that every solution to Eq. (4) lives in

S:=e+ker(H),

which has qK elements. Notice that if H is “random”, then we expect this set to be uniformly distributed in FqN. So we expect the number of vectors of weight t~ in S to be

(q-1)t~qN-KNt~.

Summing over all t~≤t+ε yields the estimate for (5).

Choosing maximum number of iterations

The work factor of the Prange algorithm for an [N, K]-code with an error vector of weight t is given by

WFt=NtN-Kt.

Similarly, if we allow t+ε errors with ε≥1 the work factor changes to

WFt+ε=Nt+εN-Kt+ε.

The quotient of the two work factors simplifies to

WFt+εWFt=∏j=0ε-1N-t-jN-K-t-j≈N-tN-K-tε.

Note furthermore that while WFt+ε is the expected number of iterations to find a solution of weight t+ε, it is unlikely that we will find the correct error at each step with this number of iterations. To ensure that the correct error is in the list of outputs of our ISD algorithm, we run it for a fixed number of iterations, chosen to ensure this. To make this choice, note that the chance of finding a fixed detectable error of weight t+ε in one iteration of Prange’s algorithm is given by

WFt+ε-1=N-Kt+εNt+ε.

So, the probability of finding a given error of weight t+ε at all s steps with W ISD iterations at each step is given by

1-1-N-Kt+εNt+εWs.

Note that this is a lower bound for the success probability of recovering an error vector e=(e~0,e~1,…,e~s-1) with wt(e~i)≤t+ε for all i=1,…,s-1 since the weight of an e~i can be smaller than t+ε, which increases the probability of it getting recovered.

Choice of ε

In this subsection we summarize the impact of the choice of ε. Increasing ε makes it more likely that errors satisfy the weight condition on each block and thus allows to recover more errors and messages. However, it also increases the work factor for ISD and the number of solutions found in each step, which can heavily increase the computational time.

All of these factors need to be carefully considered when choosing ε.

For example, for the attack on [12] that we will discuss in Sect. 5.2, we have the parameters q=2, te=140, s=167, K=36 and N=60. This gives us t=1, and we get the plot in Fig. 2, which helps us to choose the value of ε. We chose ε=3, as about 78% of errors should have block-weight at most 4, as can be seen in Fig. 2, and the work factor is still comparatively small as discussed in Sect. 4.4.1, and as can be seen in Fig. 3. We use this value of ε for our experiments, as described in Sect. 5.2.

Fig. 2.

Fig. 2

Calculating a suitable value of ε for [12, Example 5.11]

Fig. 3.

Fig. 3

WFt+ε/WFt for Prange on the [60, 36]-code, as we vary ε

Attacks on McEliece type cryptosystems based on convolutional codes

In this section we describe how to attack two McEliece type cryptosystems and what modifications of the procedures described above are necessary in order to attack them in practice. The systems we attack are from [12, Sect. 5] and [5] (note that the latter one is not the authors’ current version). Next, we will describe the McEliece system and the philosophy of how the cryptosystems use convolutional codes in this setting. The last two subsections are concerned with the practical aspects of the attack on the specific schemes.

The McEliece cryptosystem and variants based on convolutional codes

The first code-based cryptosystem was introduced by McEliece in his seminal paper [22]. It can be described as follows. The parameters k, n, q, t are fixed and all computations are over the finite field Fq.

  • Key Generation: the secret key is given by a code in the form of a k×n generator matrix G together with an efficient decoding algorithm ϕ and a random invertible k×k matrix U as well as a random n×n permutation matrix P. The public key is given as G′=UGP.

  • Encryption: to encrypt a message m of length k the sender computes r=mG′+e, where e∈Fqn is a random error vector of Hamming weight t.

  • Decryption: the receiver computes ϕ(rP-1) to recover mU and then the original message m.

In the cryptosystems in [5, 12], the general principle is the same, but the matrices and vectors are not necessarily over Fq but over Fq[z]. In particular, the public key G′(z) is a k×n matrix with entries in Fq[z]. Therefore, it generates a convolutional code. Furthermore, P might not be a permutation in their schemes. For the encryption, the authors fix not just the weight, but also the degree of the message m(z) and the degree of the error vector e(z), which now also have entries in Fq[z]. We use the methods we have developed in the previous sections to recover e(z) from r(z)=m(z)G′(z)+e(z) applying our ISD framework for convolutional codes with the generator matrix G′(z). Since we only need the public key, we do not describe the full details of the key generation and decryption with the private key of the schemes in [5, 12].

The first challenge in applying our framework is that the codes constructed in both papers are not delay-free. This does not pose a major challenge though since we can construct non-catastrophic convolutional codes that contain these codes, see Sect. 2. Then we use ISD with a fixed amount of iterations with respect to these non-catastrophic codes.

A second problem that we encounter with both systems is the existence of low weight codewords. To account for this we find codewords of weight 1 or 2 with a brute-force search. Then we add these to all the solutions ISD found and keep only the results that have the weight within specified bounds. Note that ISD might find several solutions since we are outside of the unique decoding radius.

With these modifications we use a depth first search after each round of ISD as described below.

Let L0,M0 be the outputs of the first stage of ISD, i.e. L0=(e~0,1,…,e~0,n0), M0=(m~0,1,…,m~0,n0). Furthermore, let te be the total error weight and G~iγ the matrices we construct from G as above. Moreover let Clow,Mlow be the sets of the low weight codewords and corresponding messages, respectively, and let mx′ correspond to the message for error x∈Lj, and mc′ to the message for c∈Clow, respectively.

Algorithm 1.

Algorithm 1

Depth-first sequential ISD

Next we describe the experimental results we get for both of the schemes we attack. We ran our experiments mainly on SageMath 9.4 [29]. Some calculations for the attack in Sect. 5.3 were done with Magma v2.27/7 [13]. The code which contains implementations and the attacks can be found under https://git.math.uzh.ch/projects/2640.

Attack on “A Variation Based on Spatially Coupled MDPC Codes”

We attacked the scheme proposed in [12]. We took the generator matrix in Example 5.11 for which the authors claim that it gives 80 bits security against generic decoding attacks. The authors propose a (5, 3) binary convolutional code. The generator matrix has a memory of 94. The error is of degree up to 1999 and has a total weight of 140.

When we attacked the system, we took γ=11, so ISD is done with a 36×60 generator matrix. The choice of γ was motivated by the desire of having, on average, approximately one error in each decoding window. This seems to be a good compromise as for lower γ’s, the algorithm tends to get lost more often, and for higher γ’s, the algorithm is slower. At each step, Prange was run 430 times, which guarantees a total success rate of more than 98% according to the formula in Sect. 4.4.1. We chose ε=3 as discussed in Sect. 4.4.2. Several seeds for error generation were used and the ones for which the error was outside the range t+ε were discarded. From the probability calculations we expect to discard about 22% of the seeds. In the experiment we discarded 7 out of 27 errors, which is about 26%. For the remaining ones we ran 20 experiments, the results of which can be seen in Fig. 4.

Fig. 4.

Fig. 4

Running time of the experiments for the scheme proposed in [12]

All the experiments correctly recovered the error in less than 10 h. This translates to a bit security of at most 56 bits. For how we translate between bits and running time, please consult Sect. 5.3.2. Note that we think that our code could be optimized quite a bit and therefore this is an overestimate. We also ran our experiment with another generator matrix with the key generation as described in [12, Sect. 5.5], for the same parameters to verify our results. It also finished successfully.

Attack on “Smaller Keys for Code-Based Cryptography: McEliece Cryptosystems with Convolutional Encoders” 2021

We implemented the scheme proposed in [5] for the parameters for 128 bit security as given in Example 17 of that paper. We used several generator matrices and errors to estimate the security of the scheme. For this scheme we know more about the errors, namely in their example for the 128 bit security level, the authors use an error with 50 blocks where the total error weight is 133 and the sum of the weights of 3 consecutive blocks is 8. This tells us that the blocks have weights a,b,3,a,b,3,…,a,b where a+b=5. Therefore, we take t=2,ε=3, which would also be a good choice based on the probability calculations. Of course in this case this ε always works. For the experiments, we took γ=0, so G0γ=G0. This means that the size of our block code generated by G0γ has size N=n=62 and dimension K=k=30. At each step, the ISD runs for 700 iterations, ensuring a total success rate of more than 99%.

To give estimates for the running time, we “cheated” and checked at each step at which position of the output of the ISD the correct error is. Since the algorithm usually does not run further on a wrong branch than a single node, we expect that adding up the positions of the correct error in the output of the ISD gives us a relatively precise estimate of the total number of ISD iterations needed to recover the correct error. For the estimates which indicated that we could recover the error quickly, we ran the actual experiments without cheating to verify our estimates. This was the case for seeds 1 and 10. In both cases, the actual time required was below the estimate. The results can be seen in Fig. 5. For how we translate between bits and running time, see Sect. 5.3.2.

Fig. 5.

Fig. 5

Estimated bit security for [5]. For seeds 1 and 10 we also gave the actual running time

In total we ran 20 experiments, of which 16 successfully finished. In the other cases, the correct error was not found at some step. In these cases we got only partial recovery due to low weight codewords of weight 3 and 4. We did not include the seeds corresponding to those experiments in the figure above.

Probability of getting lost

We will justify that, in the attack on [5], our algorithm is very unlikely to proceed further than one layer on a wrong branch. Assume the algorithm is correct up to degree j, and then, for a given wrong error e~j+1 at degree j+1, finds a solution e~j+2 for degree j+2 as well. Let ej+1 and ej+2 be the correct solutions at the respective degrees. Define cj+1:=ej+1-e~j+1 and cj+2:=ej+2-e~j+2. Then:

  • cj+1 is non-zero,

  • (cj+1,cj+2)∈rowspanG0G10G0,

  • wt(e~j+1)=wt(ej+1) and wt(e~j+2)=wt(ej+2).

Thus, let e∈FqN be fixed of weight te and c∈FqN of weight tc. We will assume that N≫te,tc, which also holds in practice. We are interested in the probability of wt(e+c)=wt(e). Let z be the number of elements of e that become zero after adding c (the number of “cancellations”). Notice that to preserve weight we then need to have z non-overlaps, i.e. z elements of the support of c are outside of the support of e. Notice that if wt(e+c)=wt(e), then z≤⌊tc/2⌋. Furthermore, it is also necessary that z≥tc-te since if tc>te, we have at least tc-te entries of c outside of the support of e, so we also need to cancel at least tc-te positions of e. Now, for a fixed number of cancellations, we have a probability of

tezN-tez(q-1)zte-ztc-2z(q-2)tc-2zNtc(q-1)tc

that the weight stays the same. Indeed, we have tez choices for entries of c that cancel entries of e. For entries of c outside of the support of e, we choose z from N-te positions, and can have q-1 entries in each position, which gives us N-tez(q-1)z possibilities. Finally, we need to choose tc-2z positions in the remaining support of e and have q-2 choices for the entries of c since the entries must be non-zero and also cannot be minus the corresponding entry of e, which is non-zero, giving us te-ztc-2z(q-2)tc-2z possibilities. Let Ete,tc be the conditional event that wt(e+c)=wt(e) for an e and c such that wt(e)=te and wt(c)=tc. Summing over all possible numbers of cancellations z, we get a probability

P(Ete,tc)=∑z=0tc2tezN-tezte-zt-2z(q-2)tc-2zNtc(q-1)tc-z.

We sum z from 0, as the summands for z<tc-te (when tc>te) will be zero anyways.

Thus, given a vector

(cj+1,cj+2)∈rowspanG0G10G0,

where wt(cj+1)=tcj+1 and wt(cj+2)=tcj+2, and an error vector (ej+1,ej+2), where wt(ej+1)=tej+1 and wt(ej+2)=tej+2, we get that the probability of wt(ej+1+cj+1)=wt(ej+1) and wt(ej+2+cj+2)=wt(ej+2) is

P(Etej+1,tcj+1)·P(Etej+2,tcj+2).

In Table 1, we have listed P(Ete,tc) for various values of te and tc for the parameters in Example 17 of [5].

Table 1.

P(Ete,tc) for some values of te and tc

te
tc 1 2 3 4 5
1 1.58×10-2 3.17×10-2 4.76×10-2 6.35×10-2 7.94×10-2
2 5.12×10-4 1.52×10-3 3.02×10-3 5.02×10-3 7.51×10-3
3 0 4.96×10-5 1.71×10-4 3.88×10-4 7.23×10-3

Technical remarks

Each of our experiments was run on two UZH I-Math servers. One of them has a 1 x AMD EPYC™ 7742 2.25GHz CPU with maximum speed of 3.4 GHz, while the other one has a 1 x AMD EPYC™ 7502P 2.5GHz CPU that scales up to 3.35 GHz. Note that both are AMD EPYC™ 7002 Series CPUS, and specifications for them can be found in [8, 24].

Since the AMD EPYC™ 7742 2, 25 GHz CPU has four integer ALUs and two 256-bit AVX2 we get a maximum throughput of 8. Each instance used one core, and we did not parallelise our algorithm. We calculate the upper bound of bit operations per cycle a CPU can handle by taking into account the CPU autoscaling feature (also called turbo) and two 256-bit AVX2 hardware units. Thus, we can translate running time to an upper bound of bits of security. To do this, we first calculate the total number of cycles by multiplying the measured time with the maximum CPU frequency. AVX2 can perform up to 8 integer operations per cycle and an integer operation can consist of up to 64 bit operations. Multiplying all these values and taking the logarithm with base 2 thus gives us an upper bound for the bits of security. For example, a running time of 10 h translates to a bit security of at most

log2(3.4×109Hz×10h×3600s/h×8×64)≈55.8

on a 3.4 GHz CPU.

Also note that though we have not implemented our algorithm for multiple cores, it is well-suited for parallelisation, as for the j+1th round of ISD, we only need the values of e, m up to the jth block. That is to say, each round is only influenced by the nodes above it, not the nodes on the side. Thus, if we had nc number of cores, each core could traverse the tree with one of the initial choices for e0. If any core reaches the end of the tree, we could stop there, and if any core goes all the way back to the starting node, having not found the solution in that branch, it could aid any core still actively traversing the tree. This could hypothetically cut down the running time by a factor of at-most nc. We expect parallelisation to be more effective on the attack on [12], rather than on [5], as in the latter, our algorithm does not seem to get lost as discussed in Sect. 5.3.

Conclusion

We have developed a framework to iteratively decode convolutional codes with generic decoding methods. We used this framework with information-set decoding to attack two McEliece type cryptosystems where the public key is a convolutional code. We do not have a theoretical estimate for the running time of our attacks, but experiments suggest that the running time is significantly lower than what the authors estimated for generic decoding methods. In light of our results, we suggest that convolutional code cryptosystems are designed with some defensive adaption such as tail-biting.

There are several challenging open problems for further research. We do not have theoretical guarantees for how far the algorithm can get lost in the depth first search. Furthermore the number of low weight codewords that we have to consider in each step of our framework needs further consideration. Another open point is the choice of the parameter γ. While it is clear that a smaller choice gives an exponential speedup on the ISD cost on the block code, the behaviour under depth first search and the number of low weight codewords make a general analysis complicated. We would like to point out that it seems unlikely that one gets a satisfactory answer to all of these problems considering that for decoding algorithms of convolutional codes it often is hard to get complexity estimates. For the Viterbi algorithm [30] the complexity grows exponentially in the memory and we are not aware of exact complexity estimates for sequential decoding which do not rely on random coding techniques. A first step to gain some intuition on how the complexity scales could be to run further experiments with our framework.

This also leaves the status of convolutional code-based cryptosystems to some extent open. While most of these systems could be broken with considerably less effort than claimed, a full theoretical analysis is difficult. It is clear that choosing a large enough generator matrix such that ISD for block codes already becomes infeasible thwarts the attack. On the other hand that would also lead to worse key sizes than for schemes based on linear block codes.

Another open problem, which is more accessible, is to extend our framework to time-varying convolutional codes. In this case the same principles should apply as long as the diagonal matrices are full rank.

Acknowledgements

The authors would like to thank Daniela Portillo del Valle and Joachim Rosenthal for fruitful discussions. The authors would also like to thank Diego Napp and Miguel Beltrá Vidal for answering our questions about their system. The authors would further like to thank Yazhuo Zhang for her help with translating experiment time to bit security. The authors would like to thank Violetta Weger and Anna-Lena Horlemann for their encouragement and Carsten Rose and the IT-Team at I-Math UZH for their practical help and infinite patience while we tormented the math servers with our experiments. Finally, the authors would like to thank the referees for their constructive feedback and suggested improvements.

Author contributions

All authors contributed equally to the work.

Funding

Open access funding provided by University of Zurich. This work has been supported in part by Armasuisse Science and Technology (Project Number CYD-C-2020010), by the Swiss National Science Foundation under SNSF Grant Number 212865, and by the German Research Foundation, Project Number 513811367.

Data availability

No datasets were generated or analysed during the current study.

Declarations

Conflict of interest

The authors have no relevant financial or non-financial interests to disclose.

Footnotes

Publisher's Note

Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

References

  • 1.Aguilar Melchor C., Aragon N., Bettaieb S., Bidoux L., Blazy O., Bos J., Deneuville J., Dion A., Gaborit P., Lacan J., Persichetti E., Robert J., Véron P., Zémor G.: Hamming Quasi-Cyclic (HQC). Round 4 Submission (2022).
  • 2.Alagic G., Bros M., Ciadoux P., Cooper D., Dang Q., Dang T., Kelsey J., Lichtinger J., Liu Y., Miller C., Moody D., Peralta R., Perlner R., Robinson A., Silberg H., Smith-Tone D., Waller N.: Status Report on the Fourth Round of the NIST Post-quantum Cryptography Standardization Process. National Institute of Standards and Technology, Gaithersburg (2025) 10.6028/NIST.IR.8545. [Google Scholar]
  • 3.Albrecht, M. R., Bernstein, D. J., Chou, T., Cid, C., Gilcher, J., Lange, T., Maram, V., von Maurich, I., Misoczki, R., Niederhagen, R., Paterson, K. G., Persichetti, E., Peters, C., Schwabe, P., Sendrier, N., Szefer, J., Tjhai, C. J., Tomlinson, M., Wang, W.: "Classic McEliece: Conservative Code-Based Cryptography". Round 4 Submission. (2022).
  • 4.Almeida P.J.F., Napp D.: A McEliece-type cryptosystem based on Convolutional Codes. In: Proceedings of the 23rd International Symposium on Mathematical Theory of Networks and Systems, 2018, pp. 323–326 (2018). https://mtns2018.hkust.edu.hk/media/files/0111.pdf.
  • 5.Almeida P.J.F., Beltrá M., Napp D., Sebastião C.: Smaller keys for code-based cryptography: McEliece cryptosystems with convolutional encoders. CoRR abs/2104.06809 (2021). arXiv:2104.06809v1.
  • 6.Almeida P.J.F., Beltrá M., Napp D., Sebastião C.: Smaller keys for the McEliece cryptosystem: a convolutional variant with GRS codes. CoRR abs/2104.06809 (2023). 10.48550/arXiv.2104.06809.
  • 7.Almeida P.J.F., Beltrá M., Napp D., Sebastião C.: A convolutional variant of the Niederreiter cryptosystem with GRS codes. In: 2024 IEEE International Symposium on Information Theory (ISIT), 2024, pp. 1818–1823 (2024). 10.1109/ISIT57864.2024.10619550.
  • 8.AMD: AMD EPYC™ 7002 Series Processors. AMD (2020). https://www.amd.com/en/products/processors/server/epyc/7002-series.html.
  • 9.Aragon, N., Barreto, P. S., Bettaieb, S., Bidoux, L., Blazy, O., Deneuville, J., Gaborit, P., Ghosh, S., Gueron, S., Güneysu, T., Melchor, C. A., Misoczki, R., Persichetti, E., Sendrier, N., Tillich, J., Vasseur, V., Zémor, G.: "BIKE: Bit Flipping Key Encapsulation". Round 4 Submission. (2022).
  • 10.Becker A., Joux A., May A., Meurer A.: Decoding random binary linear codes in Inline graphic: how 1 + 1 = 0 improves information set decoding. In: Pointcheval D., Johansson T. (eds.) Advances in Cryptology—EUROCRYPT 2012—31st Annual International Conference on the Theory and Applications of Cryptographic Techniques, Proceedings. Lecture Notes in Computer Science, Cambridge, UK, 15–19 April 2012, vol. 7237, pp. 520–536. Springer, Berlin (2012). 10.1007/978-3-642-29011-4_31.
  • 11.Bernstein D.J., Lange T., Peters C.: Smaller decoding exponents: ball-collision decoding. In: Rogaway P. (ed) Advances in Cryptology—CRYPTO 2011—31st Annual Cryptology Conference, Proceedings. Lecture Notes in Computer Science, Santa Barbara, CA, USA, 14–18 August 2011, vol. 6841, pp. 743–760. Springer, Berlin (2011).10.1007/978-3-642-22792-9_42.
  • 12.Bolkema J., Gluesing-Luerssen H., Kelley C.A., Lauter K.E., Malmskog B., Rosenthal J.: Variations of the McEliece cryptosystem. In: Algebraic Geometry for Coding Theory and Cryptography: IPAM, Los Angeles, CA, February 2016, pp. 129–150. Springer, Cham (2017). 10.1007/978-3-319-63931-4_5.
  • 13.Bosma, W., Cannon, J., Playoust, C.: The Magma algebra system I The user language. J. Symbolic Comput 24.3-4, pp. 235–265 (1997). Computational algebra and number theory (London, 1993).10.1006/jsco.1996.0125.
  • 14.Chvátal V.: The tail of the hypergeometric distribution. Discret. Math. 25(3), 285–287 (1979). 10.1016/0012-365X(79)90084-0. [Google Scholar]
  • 15.Dumer I.: On minimum distance decoding of linear codes. In: Proceedings of the 5th Joint Soviet–Swedish International Workshop on Information Theory. 1991, pp. 50–52 (1991).
  • 16.Johnson N.L., Kotz S., Balakrishnan N.: Discrete Multivariate Distributions. Wiley, New York (1997). [Google Scholar]
  • 17.Landais G., Tillich J.: An efficient attack of a McEliece cryptosystem variant based on convolutional codes. In: Cryptology ePrint Archive, Paper 2013/080 (2013). https://eprint.iacr.org/2013/080.
  • 18.Lee P.J., Brickell E.F.: An observation on the security of McEliece’s public-key cryptosystem. In: Günther C.G. (ed.) Advances in Cryptology—EUROCRYPT ’88, Workshop on the Theory and Application of of Cryptographic Techniques, Proceedings. Lecture Notes in Computer Science, Davos, Switzerland, 25–27 May 1988, vol. 330, pp. 275–280. Springer, Berlin (1988). 10.1007/3-540-45961-8_25.
  • 19.Lieb J., Pinto R., Rosenthal J.: Convolutional codes. In: Concise Encyclopedia of Coding Theory. CRC Press, New York (2021). 10.1201/9781315147901.
  • 20.Löndahl C., Johansson T.: A new version of McEliece PKC based on convolutional codes. In: Information and Communications Security: 14th International Conference, ICICS 2012, Proceedings 14, Hong Kong, China, 29–31 October 2012, pp. 461–470. Springer, Berlin (2012). 10.1007/978-3-642-34129-8_45.
  • 21.May A., Meurer A., Thomae E.: Decoding random linear codes in Inline graphic. In: Lee D.H., Wang X. (eds.) Advances in Cryptology—ASIACRYPT 2011—17th International Conference on the Theory and Application of Cryptology and Information Security, Proceedings. Lecture Notes in Computer Science, Seoul, South Korea, 4–8 December 2011, vol. 7073, pp. 107–124. Springer, Berlin (2011).10.1007/978-3-642-25385-0_6.
  • 22.McEliece R.J.: A public-key cryptosystem based on algebraic coding theory. In: Deep Space Network Progress Report, vol. 44. pp. 114–116 (1978). https://ipnpr.jpl.nasa.gov/progress_report2/42-44/44title.htm.
  • 23.Moufek H., Guenda K.: A New variant of the McEliece cryptosystem based on the Smith form of convolutional codes. Cryptologia 42(3), 227–239 (2018). 10.1080/01611194.2017.1362061. [Google Scholar]
  • 24.NASA NAS: AMD Rome Processors. NASA (2022). https://www.nas.nasa.gov/hecc/support/kb/amd-rome-processors_658.html.
  • 25.Peters C.: Information-set decoding for linear codes over Inline graphic. In: Sendrier N. (ed.), Post-quantum Cryptography, Third International Workshop, PQCrypto 2010, Proceedings. Lecture Notes in Computer Science, Darmstadt, Germany, 25–28 May 2010, vol. 6061, pp. 81–94. Springer, Berlin (2010). 10.1007/978-3-642-12929-2_7.
  • 26.Prange E.: The use of information sets in decoding cyclic codes. RE Trans. Inf. Theory 8(2), 5–9 (1962). 10.1109/TIT.1962.1057777. [Google Scholar]
  • 27.Shor P.: Algorithms for quantum computation: discrete logarithms and factoring. In: Proceedings of the 35th Annual Symposium on Foundations of Computer Science, 1994, pp. 124–134 (1994). 10.1109/SFCS.1994.365700.
  • 28.Stern J.: A method for finding codewords of small weight. In: Cohen G.D., Wolfmann J. (eds.), Coding Theory and Applications, 3rd International Colloquium, Proceedings. Lecture Notes in Computer Science, Toulon, France, 2–4 November 1988, vol. 388, pp. 106–113. Springer, Berlin (1988). 10.1007/BFb0019850.
  • 29.The SAGE Developers: SageMath, the Sage Mathematics Software System (Version 9.4). The SAGE Developers (2021). https://www.sagemath.org.
  • 30.Viterbi A.: Error bounds for convolutional codes and an asymptotically optimum decoding algorithm. IEEE Trans. Inf. Theory 13(2), 260–269 (1967). 10.1109/TIT.1967.1054010. [Google Scholar]
  • 31.Wozencraft J.M.: Sequential decoding for reliable communication. In: IRE National Convention Record, vol. 5, pp. 11–25 (1957). https://dspace.mit.edu/handle/1721.1/4758.

Associated Data

This section collects any data citations, data availability statements, or supplementary materials included in this article.

Data Availability Statement

No datasets were generated or analysed during the current study.


Articles from Designs, Codes, and Cryptography are provided here courtesy of Springer

RESOURCES