Patent Application
20170104590
Field of the Invention
The present invention relates to methods for public-key cryptography encryption schemes based on linear error correcting codes, and to corresponding encryption and decryption apparatus.
The present invention further relates to computerised methods and systems for encrypting and decrypting data using public key encryption techniques, and to computerised methods and systems for communications using such techniques, as well as other applications thereof. The basic types of things that the invention improves include two kinds of techniques. The first technique is a method and system to integrate randomness within linear error-correcting codes' generator matrices. The second technique is a method and system to use randomized generator matrices as public-keys for encryption schemes for secure communications.
Discussion of Prior Art
With rapid development for quantum computing techniques, our society is concerned with the security of current Public Key Infrastructures (PKI) which are fundamental for Internet services. The core components for current PKI infrastructures are based on public cryptographic techniques such as RSA and DSA. However, it has been shown that these public key cryptographic techniques could be broken by quantum computers. Thus it is urgent to develop public key cryptographic systems that are secure against quantum computing.
Since McEliece encryption scheme (1978) was introduced more than thirty years ago, it has withstood many attacks and still remains unbroken for general cases. It has been considered as one of the candidates for post-quantum cryptography since it is immune to existing quantum computer algorithm attacks. The original McEliece cryptographic system is based on binary Goppa codes. Several variants have been introduced to replace Goppa codes in the McEliece encryption scheme. For instance, Niederreiter (1986) proposed the use of generalized Reed-Solomon codes and later, Berger and Loidreau (2005) proposed the use of sub-codes of generalized Reed-Solomon codes, Sidelnikov (1994) proposed the use of Reed-Muller codes, Janwa and Moreno (1996) proposed the use of algebraic geometry codes, Baldi et al (2008) proposed the use of LDPC codes, Misoczki et al (2013) proposed the use of MDPC codes, and Löndahl and Johansson (2012) proposed the use of convolutional codes. Most of them have been broken though MDPC/LDPC code based McEliece encryption schemes and the original binary Goppa code based McEliece encryption scheme are still considered secure.
Goppa code based McEliece encryption scheme is hard to attack since Goppa codes share many characteristics with random codes. Motivated by Faugere et al's (2010) algebraic attacks against quasi-cyclic and dyadic structure based compact variants of McEliece encryption scheme, Faugere et al (2011) designed an efficient algorithm to distinguish a random code from a high rate Goppa code. Márquez-Corbella and Pellikaan (2012) simplified the distinguisher using Schur component-wise product of codes. The Schur product codes are used to define the square of a code which can be used to distinguish a high rate Goppa code from a random code.
We first briefly review Goppa codes and McEliece scheme. For given parameters q, n≦q, and t, let g(χ) be a polynomial of degree t over GF(q). Assume that g(χ) has no multiple zero roots and α0, . . . , αn−1εGF(q) be different non root elements for g(χ). The following subspace CGoppa(g) defines the code words of an [n, k, d] binary Goppa code where d≧2t+1. This binary Goppa code CGoppa(g) has dimension k≧n−tm and corrects t errors.
Furthermore, if g(χ) is irreducible, then CGoppa(g) is called an irreducible Goppa code. The parity check matrix H for the Goppa codes looks as follows:
The McEliece scheme (1978) is described as follows. For the given parameters n and t, choose a binary Goppa code based on an irreducible polynomial g(χ) of degree t. Let G be the k×n generator matrix for the Goppa code. Select a random dense k×k nonsingular matrix S and a random n×n permutation matrix P. Then the public key is G′=SGP which generates a linear code with the same rate and minimum distance as the code generated by G. The private key is G.
Encryption. For a k-bit message block m, choose a random row vector z of length n and weight t. Compute the cipher text χ=mG′+z
Decryption. For a received ciphertext χ, first compute χ′=χP−1. Next use an error-correction algorithm to recover m′=mS and compute the message m as m=m′S−1.
Sidelnikov and Shestakov (1992) show that for the generalized Reed-Solomon code based McEliece encryption scheme, one can efficiently recover the private parameters for the generalized Reed-Solomon code from the public key. Using component-wise product of codes and techniques, Wieschebrink (2010) shows that Berger and Loidreau's sub codes (2005) of Niederreiter's scheme could be broken efficiently also. Couvreur et al (2013) proposed a general distinguisher based filtration technique to recover keys for generalized Reed-Solomon code based McEliece scheme and Couvreur, Márquez-Corbella, and Pellikaan (2014) used filtration attacks to break Janwa and Moreno's (1996) algebraic geometry code based McEliece encryption scheme. The filtration attack was recently used by Couvreur et al (2014) to attack Bernstein et al's (2011) wild Goppa code based McEliece scheme.
General Goppa code based McEliece schemes are still immune from these attacks. However, based on the new development of cryptanalysis techniques against linear code based cryptographic systems in the recent years, it is important to systematically design random linear code based cryptographic systems defeating these attacks. Motivated by this observation, this invention presents a systematic approach of designing public key encryption schemes using any linear codes. For example, we can even use Reed-Solomon codes to design McEliece encryption scheme while it is insecure to use Reed-Solomon codes in the original McEliece scheme. Since our design of linear code based encryption scheme embeds randomness in each column of the generator matrix, it is expected that, without the corresponding private key, these codes are as hard as random linear codes for decoding.
The most powerful attacks on McEliece cryptosystem is the information-set decoding attack which was introduced by Prange (1962). In an information-set decoding approach, one finds a set of coordinates of a received ciphertext which are error-free and that the restriction of the code's generator matrix to these positions is invertible. The original message can then be computed by multiplying the ciphertext with the inverse of the sub-matrix. Improvements of the information-set decoding attack have been proposed by Lee-Brickell (1988), Leon (1988), Stern (1989), May-Meurer-Thomae (2011), Becker-Joux-May-Meurer (2012), and May-Ozerov (2015). Bernstein, Lange, and Peters (2008) presented an exact complexity analysis on information-set decoding attack against McEliece cryptosystem. These said attacks are against binary linear codes and are not applicable when the underlying field is GF(pm) for a prime p. Peters (2010) presented an exact complexity analysis on information-set decoding attack against McEliece cryptosystem over GF(pm). These information-set decoding techniques are used to select example parameters for this invention.
Several inventors have created several types of techniques to design McEliece type public key encryption schemes. U.S. Pat. No. 9,191,199 B2 to Baldi, Bianchi, Chiaraluce, Rosenthal, and Schipani (2015) discloses a method for designing McEliece cryptosystem based public key encryption schemes by defining n×n transformation matrices Q with form Q=R+T, where the matrix R is a rank-z matrix and the matrix T is some other matrix rendering Q non-singular. Using this family of Q matrices instead of McEliece scheme's permutation matrices, the inventors proposed a cryptosystem using Goppa codes and RS codes. The afore mentioned patent is related to constructing McEliece type encryption schemes by modifying the permutation matrix content instead of adding randomness to the generator matrices columns and is limited in adding sufficient randomness in the public keys to make the scheme secure. U.S. Pat. No. 8,958,553 B2 to Tomlinson and Tjhai (2015) discloses a method for providing additional features to the original McEliece system which enhance the bandwidth efficiency. This patent assumes the existence of a secure McEliece type encryption scheme and is limited in constructing secure McEliece type encryption schemes. This patent is also published as international patent WO2012066328 A1 (2012). The international patent WO2001050675 A2 to Kanter and Kanter (2001) discloses a method for randomly flipping some or all of the bits in a McEliece encryption public-key. This patent is limited in generating a sequence of public keys instead of one public keys. Thus it is not efficient in practice.
The goal of the present invention is to provide encryption and decryption methods of McEliece type which are capable of improving the security level of a cryptosystem. In this invention, the term “cryptosystem” is to be understood as relating to both a method of encryption and a corresponding method of decryption.
This object is achieved by following three methods: a method for creating a public key from a private linear code generator matrix, a method for encrypting a message to a ciphertext and a method for decrypting the ciphertext. The key generation and encryption methods of the present invention comprises the following steps:
The main difference between the proposed cryptosystem and known variants of the McEliece cryptosystem consists in the way the private generator matrix is disguised into the public one by inserting and mixing random columns within the private generator matrix.
For a more complete understanding of the invention, reference is made to the following description and accompanying drawings, in which:
In this invention, we will use q=2m or q=pm for a prime p and our discussion will be based on the field GF(q) through out this invention. Letters such as a, b, e, ƒ, g are used to denote row or column vectors over GF(q). It should be clear from the context whether a specific letter represents a row vector or a column vector.
The Random Linear Code based Encryption scheme RLCE of the present invention is described in the following paragraphs.
G
1
=[g
0
,C
0
,g
1
,C
1
,g
n−1
,C
n−1] (2)
to be a k×n(r+1) matrix by inserting random matrices C0, C1, . . . , Cn−1 into Gs. The second random matrix selection engine 140 chooses dense nonsingular (r+1)×(r+1) matrices A0, . . . , An−1εGF(q)(r+1)×(r+1) uniformly at random and defines
to be an n(r+1)×n(r+1) nonsingular matrix. The engine 140 also chooses a random dense k×k nonsingular matrix S and chooses a random n(r+1)×n(r+1) permutation matrix P. The public key 160 is the k×n(r+1) matrix G=SG1AP and the private key 150 is the tuple (S, Gs, P, A).
The receiver 310 holds the private key S, Gs, A, P and receives the ciphertext y. For the received cipher text y [y0, . . . , yn(r+1)−1], the decryption engine 320 computes
Let y′=[y′0, yr+1, . . . , y′(n−1)(r+1)] be a length n row vector selected from the length n(r+1) row vector yP−1 A−1. Then y′=mSGs+e′ for some error vector e′εGF(q)n. Let e″=eP−1=[e″0, . . . , e″n(r+1)−1] and e″i=[e″i(r+1), . . . , e″i(r+1)+r] be a sub-vector of e″ for i≦n−1. Then e′[i] is the first element of e″iAi−1. Thus e′ [i]≈0 only if e″i is non-zero. Since there are at most t non-zero sub-vectors e″, the Hamming weight of e′εGF(q)n is at most t. Using the efficient decoding algorithm, the receiver computes m′=mS and m=m′S−1. Finally, the receiver calculates the Hamming weight w=weight(y−mG). If w≦t then the decryption engine 320 outputs m as the decrypted plaintext. Otherwise, the decryption engine 320 outputs an error.
Comment 1. In the design of RLCE scheme, the permutation matrix P has two purposes. The first purpose is to hide the supports of the underlying encoding scheme generator matrix (this is necessary if the supports of the underlying encoding scheme are unknown). The second purpose is to hide the positions and combinations of the column vectors gi and Ci.
Comment 2. In the RLCE decryption process, the receiver checks whether the Hamming weight w=weight(y−mG) is smaller than t. This step is used to defeat chosen ciphertext attacks (CCA). In a CCA attack, an adversary gives a random vector y=[y0, . . . , yn(r+1)−1] (which is not a valid ciphertext) to the decryption oracle to learn a decrypted value. This decrypted value could be used to obtain certain information about the private generator matrix Gs. Alternatively, one may use an appropriate padding scheme to pad a message before encryption. For example, one may use the hash output (or a message authentication tag) as the error vector for the encryption process. Then it is sufficient for the decryption process to verify whether the decrypted message has the correct padding strings to defeat the CCA attacks.
We first use the following theorem to show that any single column of the underlying generator matrix G could be completely randomized in a RLCE public key G.
Theorem 0.0.1 Let Gs=[g0, . . . , gn−1]εGF(q)k×(n−1) be a linear code generator matrix. For any randomly chosen full rank k×(r+1) matrix R0εGF(g)k×(r+1), there exists a k×k nonsingular matrix S, a (r+1)×(r+1) matrix A0, and a k×r matrix C0εGF(g)k×r such that
R
0
=S[g
0
,C
0
]A
0 (5)
Proof.
By the fundamental properties of matrix equivalence, for two m×n matrices A, B of the same rank, there exist invertible m×m matrix P and n×n invertible matrix Q such that A=PBQ. The theorem could be proved using this property and the details are omitted here.
Let R=[R0, . . . , Rn−1]εGF(q)k×n(r+1) be a fixed random linear code generator matrix. Theorem 0.0.1 shows that for any generator matrix Gs (e.g., a Reed-Solomon code generator matrix), we can choose matrices S and A0 so that the first r+1 columns of the RLCE scheme public key G (constructed from Gs) are identical to R0. However, we cannot use Theorem 0.0.1 to continue the process of choosing A1, . . . , An−1 to obtain G=R since S is fixed after A0 is chosen. Indeed, it is straightforward to show that one can use Theorem 0.0.1 to continue the process of choosing A1, . . . , An−1 to obtain G=R if and only if there exists a k×k nonsingular matrix S such that, for each i≦n−1, the vector Sgi lies in the linear space generated by the column vectors of Ri. A corollary of this observation is that if Ri generates the full k dimensional space, then each linear code could have any random matrix as its RLCE public key.
Theorem 0.0.2 Let R=[R0, . . . , Rn−1]εGF(g)k×n (r+1) and Gs=[g0, . . . , gn−1] εGF(g)k×n be two fixed MDS linear code generator matrices. If r+1≧k, then there exist A0, . . . , An−1εGF(g)(r+1)×(r+1) and C0, . . . , Cn−1εGF(g)k×r such that R=[g0, C0, . . . , gn−1, Cn−1]A where A is in the format of (3).
Proof. Without loss of generality, we may assume that r=k−1. For each 0≦i≦n−1, choose a random matrix CiεGF(g)k×r such that Gi=[gi, Ci] is an k×k invertible matrix.
The above Theorem 0.0.2 shows that in the RLCE scheme, we must have r<k−1. Otherwise, for a given public key GεGF(g)k×n(r+1), the adversary can choose a Reed-Solomon code generator matrix GsεGF(g)k×n and compute A0, . . . , An−1εGF(q)r×r and C0, . . . , Cn−1εGF(g)k×r such that G=[g0, C0, . . . , gn−1, Cn−1]A. In other words, the adversary can use the decryption algorithm corresponding to the generator matrix Gs to break the RLCE scheme.
Theorem 0.0.2 also implies an efficient decryption algorithm for random [n, k] linear codes with sufficiently small t of errors. Specifically, for an [n, k] linear code with generator matrix RεGF(g)k×n, if
then one can divide R into m=2t+k blocks R=[R0, . . . , Rm−1]. Theorem 0.0.2 can then be applied to construct an equivalent [m, k] Reed-Solomon code with generator matrix GsεGF(g)k×m. Thus it is sufficient to decrypt the equivalent Reed-Solomon code instead of the original random linear code. For McEliece based encryption scheme, Bernstein, Lange, and Peters (2008) recommends the use of 0.75 (=k/n) as the code rate. Thus Theorem 0.0.2 has no threat on these schemes.
For
the adversary is guaranteed to succeed in breaking the system. Since multiple errors might be located within the same block Ri with certain probability. For a given t that is slightly larger than
the adversary still has a good chance to break the system using the above approach. It is recommended that t is significantly larger than
For the RLCE scheme, this means that r should be significantly smaller than k. This is normally true since k is very larger for secure RLCE schemes.
In following paragraphs, we list heuristic and experimental evidences that the RLCE public key G shares the properties of random linear codes. We believe that the security of the RLCE scheme is equivalent to decoding a random linear code.
We first show that certain information about the private generator matrix Gs is leaked if the decryption process does neither include padding scheme validation nor include ciphertext correctness validation. However, it is not clear whether this kind of information leakage would help the adversary to break the RLCE encryption scheme. We illustrate this using the parameter r=1.
Assume that G1=[g0, r0, g1, r1, . . . , gn−1, rn−1] and G=SG1AP. The adversary chooses a random vector y=[y0, . . . , y2n−1]εGF(q)2n−1 and gives it to the decryption oracle which outputs a vector χεGF(q)k. Let yP−1 A−1=[y′0, . . . , y′2n−1] and
Then we have
where e is a row vector of Hamming weight at most t. From the identity (6), one can calculate a list of potential values for ci=ai,10/ai,11. The size of this list is (2n2). For each value in this list, one obtains the corresponding two column vectors [ƒ0, ƒ1]=S[gi, ri]Ai from the public key G. Then one has
That is, ƒ0−ciƒ1=(ai,00−ciai,01)Sgi. Thus, for each candidate permutation matrix P, one can calculate a matrix SGsB where B=diag[a0,00−c0a0,01, . . . , an−1,00−cn−1an−1,01] is an n×n diagonal matrix with unknown diagonal elements a0,00−c0a0,01, and an−1,00−cn−1an−1,01.
On the other hand, for each ciphertext y=[y0, . . . , y2n−1]εGF(q)2n−1, let yP−1=[z0, z1, . . . , z2n−1]. The codeword corresponding to the secret generator matrix SGs is [y′0, y′2, . . . , y′2n−2] where yP−1 A−1=[y′0, . . . , y′2n−1]. By the fact that
one has
For each candidate permutation matrix P, one first chooses k independent messages χ0, . . . , χk−1 and calculates the corresponding k independent ciphertexts y0, . . . , yk−1. Using P and the above mentioned technique, one obtains a generator matrix
Thus in order to decode a ciphertext y, it is sufficient to decode the error correcting code given by the generator matrix Ga. This task becomes feasible for certain codes. For example, this task is equivalent to the problem of attacking a generalized Reed-Solomon code based McElience encryption scheme if Gs generates a generalized Reed-Solomon code.
In order for the attacks in the preceding paragraphs to work, the adversary needs to have the knowledge of the permutation matrix P. Since the number of candidate permutation matrices P is huge, this kind of attacks is still infeasible in practice.
Niederreiter's scheme and Sidelnikov-Shestakov's attack: Sidelnikov and Shestakov's cryptanalysis technique (1992) was used to analyze Niederreiter's scheme which is based on generalized Reed-Solomon codes. Let α=(α0, . . . , αn−1) be n distinct elements of GF(q) and let υ=(υ0, . . . , υn−1) be nonzero (not necessarily distinct) elements of GF(q). The generalized Reed-Solomon (GRS) code of dimension k, denoted by GRSk(α,υ), is defined by the following subspace.
GRS
k(α,υ)={(υ0ƒ(α0), . . . ,υn−1ƒ(αn−1)):ƒ(χ)εGF(q)[χ]k)}
where GF(q)[χ]k is the set of polynomials in GF(q)[χ] of degree less than k. Alternatively, we can interpret GF(q)[χ]k as a vector space of dimension k over GF(q). For each code word c=(υ0ƒ(α0), . . . , υn−1ƒ(αn−1)), ƒ(χ)=ƒ0+ƒ1χ+ . . . +ƒk−1χk−1 is called the associate polynomial of the code word c that encodes the message (ƒ0, . . . , ƒk−1). GRSk (α, υ) is an [n, k, d] MDS code where d=n−k+1.
Niederreiter's scheme (1986) replaces the binary Goppa codes in McEliece scheme using GRS codes as follows. For given security parameters n and k, one first chooses GRS code parameters α and υ. Let G be the k×n generator matrix for this GRS code. Choose a random k×k nonsingular matrix S over GF(q) and the public key is G′=SG and
G″ linear code with the same rate and minimum distance as the code generated by G. The encryption and decryption process are the same as in the original McEliece scheme.
The best attack on Niederreiter scheme is presented by Sidelnikov and Shestakov (1992). In Sidelnikov-Shestakov attack, one recovers an equivalent private key (α, υ) from a public key G′ for the code GRSk (α, υ) as follows. For the given public key G′, one first computes the systematic form E(G′)=[II G″] (also called echelon form) using Gaussian elimination. An equation system is then constructed from E(G′) to recover a decryption key.
For the ith row bi of E(G′), assume the associated polynomial is ƒb
Thus ƒb
for some cb
GRS
k(α,υ)=GRSk(aα+b,cυ) (11)
for all a, b, cεGF(q) with ab≠0, we may assume that α0=0 and α1=1. In the following, we try to recover α2, . . . , αn−1. Using equation (10), one can divide the row entries in (8) by the corresponding nonzero entries in another row to get several equations. For example, if we divide entries in row i0 by corresponding nonzero entries in row i1, we get
for j=k, . . . , n−1. First, by taking i0=0 and i1=1, equation (12) could be used to recover αk, . . . , αn−1 by guessing the value of
which is possible when q is small. By letting i0=0 and i1=2, . . . , k−1 respectively, equation (12) could be used to recover αi
Berger and Loidreau (2005) recommend the use of sub codes of Niederreiter's scheme to avoid Sidelnikov and Shestakov's attack. Specifically, in Berger and Loidreau's scheme, one uses a random (k−l)×k matrix S′ of rank k−l instead of the k×k matrix S to compute the public key G′=S′G.
For smaller values of l, Wieschebrink (2010) shows that a private key (α, υ) for Berger and Loidreau scheme (2005) could be recovered using Sidelnikov-Shestakov algorithm. For larger values of l, Wieschebrink used product code to recover the secret values for Berger-Loidreau scheme. Let G′=SG be the (k−l)×n public generator matrix for Berger-Loidreau scheme, r0, . . . , rk−l−1 be the rows of G′, and ƒ0, . . . , ƒk−l−1 be the associated polynomials to those rows. For two row vector a, bεGF(q)n, the component wise product a*bεGF(q)n is defined as
a*b=(a0b0, . . . ,an−1bn−1) (13)
By the definition in (13), it is straightforward to observe that
r
i
*r
j=(υ02ƒi(α0)ƒj(α0), . . . ,υn−12ƒi(αn−1)ƒj(αn−1)). (14)
For 2k−1≦n−2, if the code generated by ri*rj equals to GRS2k−1(α,υ′) for υ′=(υ02, . . . , υn−12) then the Sidelnikov-Shestakov algorithm could be used to recover the values α and υ. For 2k−1≦n−2, if the code generated by ri*rj does not equal to GRS2k−1(n,υ′), then the attack fails. Wieschebrink shows that the probability that the attack fails is very small. For the case of 2k−1>n−2, Wieschebrink applied Sidelnikov-Shestakov algorithm on the component wise product code of a shortened code of the original GRSk(α,υ).
The crucial step in Sidelnikov and Shestakov attack is to use the echelon form E(G)=[I|G′] of the public key to get minimum weight codewords that are co-related to each other supports. In the encryption scheme RLCE, each column of the public key G contains mixed randomness. Thus the echelon form E(G)=[I|G′] obtained from the public key G could not be used to build any useful equation system. In other words, it is expected that Sidelnikov and Shestakov attack does not work against the RLCE scheme.
Filtration attacks: Using distinguisher techniques, Couvreur et al. (2013) designed a filtration technique to attack GRS code based McEliece scheme. The filtration technique was further developed by Couvreur et al (2014) to attack wild Goppa code based McEliece scheme. In the following, we briefly review the filtration attack. For two codes C1 and C2 of length n, the star product code C1*C2 is the vector space spanned by a*b for all pairs (a, b)εC1×C2 where a*b is defined in (13). For C1=C2, C1*C1 is called the square code of C1. It is showed in Couvreur et al (2014) that
Furthermore, the equality in (15) is attained for most randomly selected codes C1 and C2 of a given length and dimension. Note that for C=C1=C2 and dim C=k, the equation (15) becomes
Couvreur et al (2014) showed that the square code of an alternant code of extension degree 2 may have an unusually low dimension when its dimension is larger than its designed rate. Specifically, this happens for wild Goppa codes over quadratic extensions. Using a shortening trick, Couvreur et al showed that the square of a shortened wild Goppa code of extension degree 2 is contained in an alternant code of non trivial dimension. Based on those observations, Couvreur et al designed the code filtration techniques. Specifically, create a family of nested codes defined for any a E {0, . . . , n−1} as follows.
C
α(0)⊃Cα(1)⊃. . . ⊃Cα(q+1) (16)
This family of nested codes is called a filtration. Roughly speaking, Cα(j) consists in the codewords of C which correspond to polynomials which have a zero of order j at position a. It is shown that the first two elements of this filtration are just punctured and shortened versions of C and the rest of them can be computed from C by computing star products and solving linear systems. Furthermore, the support values α0, . . . , αn−1 for the Goppa code could be recovered by this nested family of codes efficiently. Thus the private keys for wild Goppa code based McEliece scheme could be recovered from the public keys.
The crucial part of the filtration techniques is the efficient algorithm to compute the nested family of codes in (16). For our RLCE scheme, the public generator matrix G′ contains random columns. Thus linear equations constructed in Couvreur et al (2014) could not be solved and the nested family (16) could not be computed correctly. Furthermore, the important characteristics for a code C to be vulnerable is that one can find a related code C1 of dimension k such that the dimension of the square code of C1 has dimension significantly less than min
To get experimental evidence that RLCE codes share similarity with random linear codes with respect to the above mentioned filtration attacks, we carried out several experiments using Shoup's NTL library. In the experiments, we used Reed-Solomon codes over GF(210). The RLCE parameters are chosen as the 80-bit security parameter n=560, k=380, t=90, and r=1. For each given 380×560 generator matrix Gs of Reed-Solomon code, we selected another random 380×560 matrix CεGF(210)380×560 and selected 2×2 matrices A0, . . . , A559. Each column ci in C is inserted in Gs after the column gi. The extended generator matrix is multiplied by A=diag[A0, . . . , A559] from the right hand side to obtain the public key matrix GεGF(210)380×1120. For each i=0, . . . , 1119, the matrix Gi is used to compute the product code, where Gi is obtained from G by deleting the ith column vector. In our experiments, all of these product codes have dimension 1119. We repeated the above experiments 100 times for 100 distinct Reed-Solomon generator matrices and the results remained the same. Since min
the experimental results meet our expectation that RLCE behaves like a random linear code. We did the same experiments for the dual code of the above code. That is, for a 180×560 generator matrix Gs of the dual code, the same procedure has been taken. In this time, after deleting one column from the resulting public key matrix, the product code always had dimension 1119 which is the expected dimension for a random linear code.
Algebraic attacks: Faugere, Otmani, Perret, and Tillich (2010) developed an algebraic attack against quasi-cyclic and dyadic structure based compact variants of McEliece encryption scheme. In a high level, the algebraic attack tries to find χ*, y*εGF(q)n such that Vt (χ*,y*) is the parity check matrix for the underlying alternant codes of the compact variants of McEliece encryption scheme. Vt (χ*,y*) can then be used to break the McEliece scheme. Note that this Vt(χ*, y*) is generally different from the original parity check matrix Vt(χ, y) in (1). The parity check matrix Vt(χ*, y*) was obtained by solving an equation system constructed from
V
t(χ*,y*)GT=0, (17)
where G′ is the public key. Faugere, Otmani, Perret, and Tillich (2010) employed the special properties of quasi-cyclic and dyadic structures (which provide additional linear equations) to rewrite the equation system obtained from (17) and then calculate Vt(χ*, y*) efficiently.
Faugere, Gauthier-Umana, Otmani, Perret, and Tillich (2011) used the algebraic attack to design an efficient Goppa code distinguisher to distinguish a random matrix from the matrix of a Goppa code whose rate is close to 1. For instance, it was showed that the binary Goppa code obtained with m=13 and r=19 corresponding to a 90-bit security key is distinguishable.
It is challenging to mount the above mentioned algebraic attacks on the RLCE encryption scheme. Assume that the RLCE scheme is based on a Reed-Solomon code. Let G be the public key and (S, Gs, A, P) be the private key. The parity check matrix for a Reed-Solomon code is in the format of
The algebraic attack requires one to obtain a parity check matrix Vt(α*) for the underlying Reed-Solomon code from the public key G, where α* may be different from α. Assume that Vt(α*)=[υ0, . . . , υn−1]εGF(q)(t+1)×n is a parity check matrix for the underlying Reed-Solomon code. Let V′t(α*)εGF(q)(t+1)×n(r+1) be a (t+1)×n(r+1) matrix obtained from Vt(α*) by inserting r column vectors 0 after each column of Vt(α*). That is,
V′
t(α*)=[υ0,0,υ1,0, . . . ,υn−1,0]. (19)
Then we have
We cannot build an equation system for the unknown V′t(α*) from the public key G=SG1AP directly since the identity (20) only shows the relationship between V′t(α*) and G1. In other words, in order to build an equation system for V′t(α*), one also needs to use unknown variables for the non-singular matrix A and the permutation matrix P. That is, we have
V′
t(α*)(A−1)T(P−1)TGT=V′t(α*)(GP−1A−1)T=V′t(α*)G1TST=0. (21)
with an unknown α*, an unknown permutation matrix P, and an unknown matrix A=diag[A0, . . . , An−1] which consists of n dense nonsingular (r+1)×(r+1) matrices AiεGF(q)(r+1)×(r+1) as defined in (3). In order to find a solution α*, one first needs to take a potential permutation matrix P−1 to reorganize columns of the public key G. Then, using the identity V′t(α*)(A−1)T(P−1)TGT=0, one can build a degree (t+1)(n−1)+1 equation system of k(t+1) equations in n(r+1)2+1 unknowns. In case that k(t+1)≧n(r+1)2+1, one may use Buchberger's Gröbner basis algorithms to find a solution α*. However, this kind of algebraic attacks are infeasible due to the following two challenges. First the number of permutation matrices P is too large to be handled practically. Secondly, even if one can manage to handle the large number of permutation matrices P, the Gröbner basis (or the improved variants such as F4 or F5) are impractical for such kind of equation systems.
The Gröbner basis algorithm eliminates top order monomial (in a given order such as lexicographic order) by combining two equations with appropriate coefficients. This process continues until one obtains a univariate polynomial equation. The resulting univariate polynomial equation normally has a very high degree and Buchberger's algorithm runs in exponential time on average (the worst case complexity is double exponential time). Thus Buchberger's algorithm cannot solve nonlinear multivariate equation systems with more than 20 variables in practice. But it should also be noted that though the worst-case Gröbner basis algorithm is double exponential, the generic behavior is generally much better. In particular, if the algebraic system has only a finite number of common zeros at infinity, then Grobner basis algorithm for any ordering stops in a polynomial time in dn where d=max{di: di is the total degree of ƒi} and n is the number of variables.
Encoding messages within the error vector: In order to increase the RLCE encryption scheme bandwith, one may use the process in
Practical Considerations: In order to reduce the message expansion ratio which is defined as the rate of ciphertext size and corresponding plaintext size, it is preferred to use a smaller r for the RLCE encryption scheme. Indeed, the experimental results show that r=1 is sufficient for RLCE to behave like a random linear code. As mentioned in the introduction section, the most powerful message recovery attack (not private key recovery attack) on McEliece encryption schemes is the information-set decoding attack. For the RLCE encryption scheme, the information-set decoding attack is based on the number of columns in the public key G instead of the number of columns in the private key Gs. For the same error weight t, the probability to find error-free coordinates in (r+1)n coordinates is different from the probability to find error-free coordinates in n coordinates. Specifically, the cost of information-set decoding attacks on an [n,k,t;r]-RLCE scheme is equivalent to the cost of information-set decoding attacks on a standard [(r+1)n,k;t]-McEliece scheme.
Taking into account of the cost of recovering McEliece encryption scheme secret keys from the public keys and the cost of recovering McEliece encryption scheme plaintext messages from ciphertexts using the information-set decoding methods, we generated a recommended list of parameters for RLCE scheme in Table 1. For the recommended parameters, the default underlying linear code is taken as the Reed-Solomon code over GF(q) and the value of r is taken as 1. For the purpose of comparison, we also list the recommended parameters for the binary Goppa code based McEliece encryption scheme. It is recommended to use semantic secure message coding approach so that one can store the public key as a systematic generator matrix. For the binary Goppa code based McEliece encryption scheme, the systematic generator matrix public key is k(n−k) bits. For RLCE encryption scheme over GF(q), the systematic generator matrix public key is k(n(r+1)−k) log q bits. It is observed that RLCE scheme generally has larger but acceptable public key size. Specifically, for the same security level, the public key size for the RLCE scheme is approximately four to five times larger than the public key size for binary Goppa code based McEliece encryption scheme. For example, for the security level of 80 bits, the binary Goppa code based McEliece encryption scheme has a public key of size 56.2 KB, and the RLCE-MDS scheme has a public key of size 267≈5×56.2 KB.
This application is entitled to the benefit of Provisional Patent Application Ser. No. 62/240,182 filed on Oct. 12, 2015. Marco Baldi, Marco Bianchi, Franco Chiaraluce, Joachim Jakob Rosenthal, and Davide Mose' Schipani. Method and apparatus for public-key cryptography based on error correcting codes. U.S. Pat. No. 9,191,199 B2 (2015)Martin Tomlinson, Cen Jung Tjhai. Public key cryptosystem based on goppa codes and puf based random generation. U.S. Pat. No. 8,958,553 B2 (2015)
| Number | Date | Country | |
|---|---|---|---|
| 62240182 | Oct 2015 | US |
