A simple and efficient attack on the Merkle-Hellman knapsack cryptosystem

TL;DR

This paper introduces a faster method to break the Merkle-Hellman knapsack cryptosystem by improving upon previous techniques.

Contribution

An improved algorithm is presented for attacking the Merkle-Hellman cryptosystem with significantly reduced time complexity.

Findings

A partial super-increasing sequence is recovered using the LLL algorithm on a low-dimensional lattice.

Most of the plaintext can be recovered from the tail using the super-increasing knapsack problem.

The improved method reduces the time complexity by a polynomial level compared to Shamir’s algorithm.

Abstract

The Merkle-Hellman knapsack cryptosystem was one of the two earliest public key cryptosystems, which was invented by Merkle and Hellman in 1978. One can recover the equivalent keys by using Shamir’s method. The most time-consuming part of Shamir’s attack is to recover the critical intermediate parameters by solving an integer programming problem with a fixed number of variables, whose worst-case complexity is exponential of the number of variables. In this paper, we present an improved algorithm to analyze the basic Merkle-Hellman public key cryptosystem. The main idea is to recover a partial super-increasing sequence as equivalent private key, which is the main difference from Shamir’s. More precisely, we first obtain a super-increasing sequence by invoking the LLL algorithm on a special lattice with a small dimension. We can recover most part of the plaintext from the tail by solving the super-increasing knapsack problem. Finally, we get the first part of plaintext by solving a size-reduced knapsack problem. Experimental data shows that one can recover the whole plaintext in less than 1 second on a laptop for the typical parameters of the Merkle-Hellman cryptosystem, whose time complexity is reduced by a polynomial level compared with Shamir’s algorithm.

Figures

Equations

Full text

1 Introduction

Merkle-Hellman cryptosystem, which is a kind of public key cryptosystem, was proposed by Merkle and Hellman in 1978 [1]. Its security was based on the hardness of the knapsack problem. This scheme used super-increasing sequences and modular multiplication to construct a trapdoor, making it easy to decrypt with the private key. Attacks on this cryptographic system can be divided into two main categories: one is to directly solve the knapsack problem, and the other is to find equivalent keys.

Many algorithms have been proposed to solve the knapsack problem. In 1985, Lagarias and Odlyzko proposed a direct way to use lattices to solve the subset sum problem [2]. This method does not rely on any properties of the subset sum instance and only works when the density is sufficiently small. In 1991, Coster, Joux, LaMacchia, Odlyzko, Schnorr and Stern [3]made a small adjustment to the original method, raising the upper limit of applicable density from 0.6463 to 0.9408. However, there are no efficient lattice-based methods for solving the knapsack problem with density close to 1. For this case, the state-of-the-art algorithm is proposed by Schroeppel and Shamir [4], which runs in $[eqn]$ $[eqn]$ 2^n/2^) time and uses $[eqn]$ $[eqn]$ 2^n/4^) bits of memory. This algorithm runs in the same time as the basic birthday-based algorithm for knapsack problem introduced by Horowitz and Sahni [5], but has much lower memory requirements. In 2010, Howgrave-Graham and Joux proposed two new algorithms that improve this bound [6], reducing the running time further with reasonable heuristics. Besides, intelligent algorithms such as genetic algorithm [7, 8] and ant colony algorithm [9] are also used to crack the Merkle-Hellman cryptosystem.

Another way to break the Merkle-Hellman cryptosystem is to solve the private key. In 1982, Shamir proposed an algorithm to break it in polynomial time [10]. Shamir noticed an "unusual" relationship between parameters, whose essence is that modular multiplication cannot perfectly hide the information of the private key. In 2019, Liu and Bi proposed an attack based on lattice [11]. They use orthogonal lattice technique as the main tool and obtain a $[eqn]$ speed-up compared with Shamir’s algorithm.

Currently, National Institute of Standards and Technology (NIST) is collecting post-quantum algorithms from all over the world, and knapsack ciphers are a promising class of candidate algorithms. The hardness of the knapsack problem is NP-complete and it can resist the attack of a quantum computer. Some improved knapsack algorithms have been proposed in recent years [12–15]. In this paper, we propose an improved method based on Shamir’s attack for cracking the Merkle-Hellman cryptosystem, which is helpful to the cryptanalysis of knapsack-based schemes.

1.1 Contributions

In this paper, we contribute to the body of knowledge on lattice-based attacks on the Merkle-Hellman cryptosystem by presenting an improved algorithm. Our approach differs from previous works in that we focus on recovering a partial super-increasing sequence as the equivalent private key, which is a novel way of utilizing the lattice reduction results. By invoking the LLL algorithm on a specially constructed small-dimensional lattice, we are able to bypass the most time-consuming integer programming step in Shamir’s attack, thereby achieving a significant reduction in time complexity.

Let n denote the number of the public key elements of the Merkle-Hellman cryptosystem and L is the length of input. l is the number of variables we use. In our improved method, the most time-consuming part is finding equivalent $[eqn]$ and $[eqn]$ by invoking the LLL algorithm [16]. Its complexity depends on the LLL algorithm, which is $[eqn]$ for classical LLL and can be further reduced using $[eqn]$ algorithm [17]. In our attack, we choose l = 20. Note that $[eqn]$ and $[eqn]$ , the time complexity of our attack is $[eqn]$ , and the complexity of Shamir’s attack is $[eqn]$ , which means we get a $[eqn]$ speed-up compared with Shamir’s algorithm.

Our work not only advances the understanding of how lattice theory can be applied to break the Merkle-Hellman cryptosystem but also provides new insights into the potential weaknesses of similar knapsack-based cryptographic schemes. The experimental results that demonstrate the efficiency of our attack further highlight the importance of considering lattice-based attacks when evaluating the security of cryptographic algorithms, especially in the context of post-quantum cryptography where the relevance of such attacks is expected to grow.

1.2 Organization

We organize the paper as follows. In Section 2, we recall the background on lattice theory, the Merkle-Hellman cryptosystem and Shamir’s attack algorithm. Section 3 shows our improved method that recovers the equivalent keys. Section 4 provides the experimental data of this method. Finally, we conclude the paper in Section 5.

2 Preliminary

2.1 Lattice

There exist n linearly independent vectors $[eqn]$ . A lattice generated by $[eqn]$ is the set of all the integer linear combinations of the basis vectors.

$$[eqn]$$

A classic problem related to lattice is SVP (shortest vector problem): find a non-zero vector with the shortest Euclidean norm in lattice. The length of the shortest non-zero vector in lattice $[eqn]$ is denoted by $[eqn]$ .

Definition 1 (SVP). Given a basis of a lattice $[eqn]$ , find a non-zero vector $[eqn]$ , such that $[eqn]$ for any vector $[eqn]$ .

The length of the shortest vector in the lattice is denoted by $[eqn]$ , and the Gaussian heuristic can be used to estimate its value. Gaussian heuristic says that in a random lattice, the length of the shortest vector is approximately:

$$[eqn]$$

where $[eqn]$ is the gamma function.

Given the basis $[eqn]$ of lattice $[eqn]$ , the LLL algorithm [16] can output a set of short vectors in polynomial time, which is called LLL-reduced basis. Let $[eqn]$ be an LLL-reduced basis of a lattice $[eqn]$ . Then:

$[eqn]$ . $[eqn]$ .

2.2 Knapsack problem

Definition 2 (Knapsack Problem). Given a set of non-negative integers $[eqn]$ , and a value sum s from a subset of the whole set, determine the subset to sum s.

Formally, the knapsack problem is given a set of non-negative integers $[eqn]$ and finds $[eqn]$ such that $[eqn]$ .

The knapsack problem is a well-known NP-complete problem. In recent years, new algorithms have been proposed to solve this problem, whose time complexity and the space complexity are all exponential of n [6, 18, 19]. However, there is one kind of easy knapsack problem we define below.

Definition 3 (Super-increasing Knapsack Problem). Given a set of non-negative integers $[eqn]$ , and a value sum s from a subset of the whole set, where $[eqn]$ , determine the subset to sum s.

It is easy to solve a super-increasing knapsack. Simply take the total weight of the knapsack s and compare it with the largest weight an in the sequence. If s<an, then it is not in the knapsack, i.e.xn = 0, otherwise, xn = 1. Subtract an from the total s, and compare with the next highest number. Keep working this way until the total reaches zero.

2.3 Basic Merkle-Hellman cryptosystem

Here we have a brief introduction to the basic Merkle-Hellman cryptosystem. Alice wants to send a message m to Bob by utilizing the Merkle-Hellman cryptosystem.

Key generation:

Bob selects a super-increasing sequence $[eqn]$ , which satisfies $[eqn]$ for any $[eqn]$ . Chooses integer M,W s.t. $[eqn]$ and $[eqn]$ . Calculate

$$[eqn]$$

Then Bob’s public key as $[eqn]$ , and Bob’s private key is $[eqn]$ .

Encryption:

Alice wants to send the plaintext message $[eqn]$ to Bob. Alice inquires about Bob’s public key and then encrypts the message m as follows.

$$[eqn]$$

The ciphertext is c.

Decryption:

Bob receives the ciphertext c, calculates $[eqn]$ .

Note that

$$[eqn]$$

Because that $[eqn]$ , then one have $[eqn]$ .

Bob can recover the plaintext message m by solving the super-increasing subset sum problem, which is easy.

2.4 Shamir’s attack

The core idea of the algorithm is to discover the "unusual" relationship between the parameters. Let us first consider the size of each parameter in the cryptosystem. ai is a dn bit number and typical values of d and n are 2 and 100, respectively, so ai is generally 200 bits. M’s size is 200 bits and bi is chosen as dn−n + i−1, which is n + i−1 bits in general situations.

Note that $[eqn]$ , so the size of U is also 200 bits. From $[eqn]$ , then there is a positive integer ki such that

$$[eqn]$$

Compared with aiU, the left side of the equation is a relatively small number, indicating that aiU and kiM are of the same order of magnitude, so ki is also 200 bits. It can be obtained by Eq 1:

$$[eqn]$$

We denote the number of ai we use by l, for 1<i<l, we have

$$[eqn]$$

This indicates that

$$[eqn]$$

We can observe from Eq 2 that the difference between two 4n bit numbers is a less than 2n bit number, which is a very unusual thing. Shamir pointed out that when l>d + 1, the integer programming problem can be used to find several sets of solutions in polynomial time. Once we get the value of k1, we can try to construct $[eqn]$ pairs such that

$$[eqn]$$

become a super-increasing sequence, thereby cracking the Merkle-Hellman cryptosystem. The time complexity of this attack is O(n^l + 10^LlogL) [20], where L is the length of the input.

3 Cryptanalysis

3.1 Observation of short vectors

Note that $[eqn]$ , we have $[eqn]$ . Let $[eqn]$ be the quotient such that $[eqn]$ . The equations imply that

$$[eqn]$$ $$[eqn]$$

Take n = 100. Consider the bit length of the first few integers of the sequence Si, which is less than $[eqn]$ , it is far less than the bit length of ai, which is about 200. We try to recover the first l–1 integers $[eqn]$ . By the right part of the above equations, we define $[eqn]$ , $[eqn]$ . Then we apply LLL algorithm on the lattice $[eqn]$ .

Define the following matrix:

$$[eqn]$$

Obviously, the rank of lattice $[eqn]$ is l–1, and $[eqn]$ is not a basis of the lattice. Therefore, the first short vector of the output of LLL algorithm is a zero vector. Besides, the norm of vector

$$[eqn]$$

in lattice $[eqn]$ is unusually small according to Eq 2 and Eq 4. It is the second shortest vector in the output, and the other l–2 vectors are much longer than the second one. The experiment data confirms our assumption.

Define

$$[eqn]$$

From Eq 3 and Eq 4, we have

$$[eqn]$$

then the vector $[eqn]$ is the shortest in lattice $[eqn]$ . Because that we choose l is small, sometimes choosing l = 10, the rank of lattice $[eqn]$ is l–1, one can recover $[eqn]$ very quickly.

Lemma 1. Let $[eqn]$ be the lattice generated by the basis matrix H. The target vector $[eqn]$ defined above is the shortest vector in the lattice $[eqn]$ , where $[eqn]$ ,provided l > 3.

Proof: The target vector $[eqn]$ is defined as $[eqn]$ for $[eqn]$ , where $[eqn]$ by Eq. (2). Its Euclidean norm satisfies:

$$[eqn]$$

According to the lattice basis H, the determinant of lattice $[eqn]$ is calculated as:

$$[eqn]$$

By the Gaussian heuristic, the expected shortest vector length in lattice $[eqn]$ is:

$$[eqn]$$

Obviously, when l>3, $[eqn]$ , and the ratio of the Gaussian heuristic-predicted shortest vector length to the target vector length exhibits a monotonic increase with growing parameter l, demonstrating asymptotic divergence behavior.

Therefore, the target vector is the shortest vector in the lattice $[eqn]$ provided l > 3. $[eqn]$

Remark 1. Note that the LLL algorithm guarantees that the first reduced basis vector $[eqn]$ satisfies: $[eqn]$ $[eqn]$ $[eqn]$ . It is well-known that the LLL algorithm performs well when the dimension of the lattice is smaller than 50. From Lemma 1, one can recover the target vector S by utilizing LLL algorithm when l is not big. The gap between the length of the target vector and the expected length of Gaussian heuristic becomes larger, then LLL algorithm will recover the target vector much more easily. It is validated by the experimental data.

Our approach shares similarities with the one presented in [21], yet it differs in two aspects. Firstly, our lattice has a lower dimension. Secondly, we offer a more rigorous theoretical analysis ensuring the lattice’s ability to find the target vector.

3.2 Recover the equivalent key

We all know that one can solve the super-increasing knapsack problem in n times arithmetic operations. Shamir’s method aims to recover the whole group of the equivalent keys, and then recover the plaintext based on the equivalent keys. In this paper, we propose a method to recover the whole group of equivalent keys except the first small part of the equivalent keys, and then, we can recover most of the plaintext from the tail. After that, one can easily search for the remaining part of the plaintext, because the size of the knapsack problem is quite small.

From the last subsection, one can obtain $[eqn]$ and $[eqn]$ by using the LLL lattice reduction algorithm. Notice that $[eqn]$ may be equal to the original ki or not, but as long as it satisfies the relationship $[eqn]$ , it will not affect our successful cracking of the cryptosystem. For convenience, we will not distinguish ki and $[eqn]$ in the following, and they will all be recorded as ki.

Interestingly, we observe that there exists a fixed integer i0, the sequence $[eqn]$ forms a super-increasing sequence, which is an important property of the equivalent key we are looking for. Therefore, we regard Si as the private key bi. The relationship between bi and ai is Eq 1. For Si and ai, we can find an equation (5) with the same structure . Therefore, we obtain the equivalent key:

$$[eqn]$$ $$[eqn]$$ $$[eqn]$$

Lemma 2. In the parameters defined above, there exists an integer i_0_ to be determined, such that $[eqn]$ forms a super-increasing sequence.

Proof: It can be derived from Eq 1 (5) that

$$[eqn]$$

As long as it is proved that MSi is a super-increasing sequence, we can get that Si is also a super-increasing sequence. Let’s calculate that

$$[eqn]$$

Note that bi forms a super-increasing sequence, so $[eqn]$ . For the second term, there exists an integer i0, such that for any i>i0,

$$[eqn]$$

In the following we will prove that when $[eqn]$ , Eq 7 is true with a probability close to 1.

Consider a sequence of i independent random variables $[eqn]$ , where each ak ( $[eqn]$ ) represents a random integer uniformly chosen from the discrete interval $[eqn]$ . Let $[eqn]$ denote the sum of these i random integers. Each ak is a discrete random variable, and its expectation and variance are derived from the properties of a uniform distribution. Specifically, the expectation of ak is given by:

$$[eqn]$$

which is the mean of the uniform distribution over $[eqn]$ . The variance of ak is:

$$[eqn]$$

Since Ri is the sum of i independent and identically distributed random variables, the expectation and variance of Ri are:

$$[eqn]$$

and

$$[eqn]$$

To compute P(Ri>M), we use the Central Limit Theorem (CLT), which states that the sum of a sufficiently large number of independent and identically distributed random variables converges to a normal distribution. Consequently, Ri can be approximated as:

$$[eqn]$$

By standardizing Ri into the standard normal variable Z, we write:

$$[eqn]$$

The probability P(Ri>M) is then expressed as:

$$[eqn]$$

Substituting $[eqn]$ and $[eqn]$ , the argument of the standard normal cumulative distribution function (CDF) becomes:

$$[eqn]$$

Finally, the probability P(Ri>M) is expressed as:

$$[eqn]$$

where $[eqn]$ denotes the CDF of the standard normal distribution. This formulation provides the exact probability of the sum of the i random integers exceeding M, based on their uniform distribution over $[eqn]$ .

For the specific case where i = 10 and M is a 200-bit integer, substituting these values into the formula gives the standardized value:

$$[eqn]$$

Numerically approximating this for M = 2^200^, we find:

$$[eqn]$$

It should be noted that the Central Limit Theorem is most accurate when the number of summands i is sufficiently large. For i = 10, the approximation is reasonable but not exact. Nonetheless, for practical purposes, the CLT-based approximation remains highly effective, particularly for large M, where the relative error becomes negligible.

In summary, the above analysis shows that when $[eqn]$ , $[eqn]$ holds with a probability close to 1. $[eqn]$

Remark 2. Here we use another method to give a lower bound on the probability that Eq 7 holds.If we can prove that $[eqn]$ , then $[eqn]$ must be true. The necessary condition for $[eqn]$ is that at least two of $[eqn]$ are greater than M/2. Since $[eqn]$ , M is very large, a can be approximately regarded as uniformly randomly selected from [0,M–1]. Then it is easy to calculate

$$[eqn]$$

According to the above analysis, this probability rises as i increases and when i = 10, the probability that Eq 7 being true is not less than 98.9%.

Based on this parameters setting, one can recover the plaintext $[eqn]$ . For the remaining unknown part $[eqn]$ , we can solve a knapsack problem with size i0−1, i.e.

$$[eqn]$$

This size-reduced problem can be solved easily. Because i0 is usually not larger than 5 in the practical cryptanalysis, whose probability exceeds 96%. See the experimental section later for details.

It can be seen from Remark 2 that the probability lower bound corresponding to the constant value of i0 is independent of n and its size is O(1), so the complexity of exhaustively enumerating $[eqn]$ is also O(1). According to Lemma 2 and Remark 2, the theoretical probability of $[eqn]$ is 99.9994%, and the probability lower bound of $[eqn]$ and $[eqn]$ is 98.9258% and 99.9938% respectively. In the experiment, the appropriate parameter setting can ensure that i0 is all within 10, so 10 can be regarded as the "actual effective upper bound" of i0. In Remark 2, the lower bound of the probability corresponding to i0 decreases exponentially with its increase. Therefore, the theoretical upper bound of i0 will be a small integer, and an exhaustive search of this scale can be easily performed.

Finally, we recover the whole plaintext of the basic Merkle-Hellman cryptosystem. The whole description of our attack is given in Algorithm 1 below.

Algorithm 1. Our algorithm for breaking basic Merkle-Hellman cryptosystem.

Require: Public key $[eqn]$ and Ciphertext c.

Ensure: Message $[eqn]$ .

1: Construct the lattice basis matrix H mentioned in Sect.3.1.

2: Invoke the LLL algorithm to obtain a set of reduced basis.

3: Select the last coefficient corresponding to the shortest

non-zero vector as k1.

4: Let n be the length of public key.

5: $[eqn]$ .

$$[eqn]$$

9: Determine i0, such that the sequence $[eqn]$ form a

super-increasing sequence.

10: $[eqn]$ .

11: Obtain $[eqn]$ by solving the super-increasing

knapsack problem.

12: Solve the size-reduced knapsack problem

$[eqn]$ by enumeration the

$[eqn]$ .

The most time-consuming part of our method is invoking the LLL algorithm to recover k1. The lattice basis matrix H is $[eqn]$ , and the complexity of invoking classical LLL algorithm on lattice H is $[eqn]$ . Note that the value of l is a small integer and $[eqn]$ , so the time complexity of this attack is $[eqn]$ .

BKZ algorithm [22] has stronger reduction capabilities than the LLL algorithm in practice. However, the dimension of our lattice is a small constant. The LLL algorithm can easily find the target vector from the lattice. The BKZ algorithm is a waste of talent here and can not bring any improvement. Therefore, we use the LLL algorithm instead of the BKZ algorithm in our method.

4 Experiments

According to Lemma 2, there exists an integer i0, such that the sequence $[eqn]$ forms a super-increasing sequence. Experiment data validates Lemma 2. We find that the first few elements of $[eqn]$ are not always super-increasing. This will lead to incorrect decryption of the first few bits when solving this partially super-increasing knapsack problem directly. Fortunately, there is an upper limit for the number of error bits in decryption. When the size of plaintext is 100 bits, errors are usually concentrated in the first 5 bits in most cases, and rarely up to around 10 bits, which can be obtained by exhaustive methods by solving the size-reduced knapsack problem. Note that the S1 given by our algorithm is always 0, and the ciphertext obtained when the coefficient x1 is 0 and 1 in the subset sum problem is the same, so the first bit of plaintext can only be obtained by exhaustion.

In the experiment, we choose n = 100, $[eqn]$ and the size of the message is 100 bits. We define T as the number of message bits the algorithm successfully recovered. To check the effect of our method, we generate 1000 sets of public keys and ciphertext of Merkle-Hellman knapsack cryptosystem for each group of parameters. $[eqn]$ denotes the proportion of instances that successfully recover c bits.

Case I, we do not consider the final step of Algorithm.1, i.e. solving the size-reduced knapsack problem. The specific experiment data are shown in Table 1.When n = 100, experimental results show that the success rate of restoring 99 bits is stable at 84%, and the success rate of restoring 90 bits is up to 98.9% when l = 10. When l = 20, experimental data show that the success rate of restoring 99 bits is stable at over 85%, and the success rate of restoring 90 bits is up to 99.5%. It should be noted that when T = 99, we consider that all the plaintexts have been recovered, because the first plaintext can only be recovered by enumeration.

Table 1: Success rate of case I.

Moreover, we examine the performance of the algorithm when n = 200 and n = 300 in Table 1. We find that when the scale of the system becomes larger, our method can still achieve excellent results. The probability of correctly recovering the plaintext is over 99%. As we have theoretically analyzed,the dimension of lattice H will not change as n increases, so the probability of successfully cracking the private key will not change significantly.

The conclusion we can draw is that the more public key used, the more plaintext bits T can be correctly recovered. However, l = 20 is enough. At this time, the failure probability of recovering 90% of the plaintext bits is negligible. The remaining plaintext of less than 10 bits can be obtained through exhaustive search.

Case II, we run the whole Algorithm 1. For the parameters n = 100, $[eqn]$ , the size of the message is 100 bits, and the success rate is $[eqn]$ . We can recover the plaintext for each set of parameters. Experimental data show that i0 is mostly concentrated in $[eqn]$ when $[eqn]$ . The value of i0 is shown in Table 2.

Table 2: Distribution of i0.

We can see that in 1000 sets of data, more than $[eqn]$ of S can form a super-increasing sequence after removing the first five digits at most no matter l is 10 or 20. The case of 20 +  indicates that the decryption failed. When l = 10, there is a probability of 8 out of 1000, and there is no failure when l = 20. Since the first element of S is 0, there is no case of i0 = 2. The experimental data also validates Lemma 2.

We used the same computing power to run Shamir’s algorithm and our algorithm. The running time of the two algorithms is shown in Table 3. As we can see, the running time of our algorithm is very short, which is much more efficient than Shamir’s. Moreover, as the size of n increases, the running efficiency of our algorithm is very little affected. This is because the lattice dimension used to solve the intermediate variables in our algorithm does not change with the increase of n. Accordingly, the increase of n has a very small impact on the complexity of lattice basis reduction, and the running time will not change significantly. Therefore, our algorithm can still perform well when n is large.

Table 3: Comparison of running time.

In summary, the more information of the public key we use, the higher the success rate should be. From Table 2, one can choose l = 20 conservatively for the typical parameters of the Merkle-Hellman cryptosystem. In this case, i0 will be smaller than 10 for the overwhelming probability, that one can recover the whole plaintext by solving a reduced knapsack problem with size smaller than 10.

5 Conclusion

Our paper presents a novel approach to cryptanalyzing the Merkle-Hellman Knapsack Cryptosystem, one of the earliest public-key cryptosystems. Our improvement lies in an enhanced algorithm that significantly reduces the time complexity for key recovery compared to Shamir’s method. By leveraging the LLL lattice reduction algorithm on a specially constructed lattice, we efficiently identify a partial super-increasing sequence, which serves as the equivalent private key. This approach allows for the rapid decryption of the plaintext message, with experimental data indicating a recovery time of less than 1 second on a standard laptop for typical parameters of the Merkle-Hellman cryptosystem.

The significance of this work mainly lies in two aspects: it not only provides a more efficient method for analyzing the security of Merkle-Hellman cryptosystem but also contributes to the broader field of cryptanalysis by offering insights into the potential vulnerabilities of knapsack-based cryptographic schemes. This could have implications for the ongoing development of post-quantum cryptographic algorithms, as the knapsack problem’s resistance to quantum attacks makes it a promising candidate for future secure communication protocols.

For future research, we propose several directions. First, it would be beneficial to explore the application of our method to other knapsack-based schemes and assess its generalizability. Besides, further optimization of the LLL algorithm for our specific use case could lead to even more significant performance gains. Lastly, the development of new cryptographic schemes that build upon the lessons learned from attacks like ours is essential to staying ahead in the ever-evolving field of cryptography.

Supporting information

S1 FileMain code.The experimental code of the algorithm in this paper and the environment configuration required to run the code.(zip)