The hull of a linear code is defined as the intersection of the code and its dual. This concept was initially introduced to classify finite projective planes. The hull plays a crucial role in determining the complexity of algorithms used to check the permutation equivalence of two linear codes and compute a linear code’s automorphism group. Research has shown that these algorithms are very effective when the hull size is small. Linear complementary dual (LCD) codes have the smallest hulls, while codes with a one-dimensional hull have the second smallest. A recent notable paper that directs our investigation is authored by H. Chen, titled “On the Hull-Variation Problem of Equivalent Linear Codes", published in IEEE Transactions on Information Theory, volume 69, issue 5, in 2023. In this paper, we first explore the one-dimensional hull of a linear code over finite fields. Additionally, we demonstrate that any LCD code over an extended binary field $$ \mathrm{I\!F}_q $$ (where $$ q > 3 $$ ) with a minimum distance of at least 2 is equivalent to the one-dimensional hull of a linear code under a specific weak condition. Furthermore, we provide a construction for creating hulls with $$ \ell + 1 $$ -dimensionality from an $$ \ell $$ -dimensional hull of a linear code, again under a weak condition. This corresponds to a particularly challenging direction, as creating $$ \ell $$ -dimensional hulls from $$ \ell + 1 $$ -dimensional hulls. Finally, we derive several constructions for the $$ \ell $$ -dimensional hulls of linear codes as a consequence of our results.

In this paper, a new strategy, maximum last round, is proposed to select cubes for cube attacks. This strategy considers the cubes in a particular round where the probability of its superpoly to be 1 is at most, where is a very small number. A heuristic method to find a number of suitable cubes using this strategy and the previously used strategies (i.e., maximum initial zero, maximum last zero) are proposed. To get a bias at the higher rounds, the heuristic, too, imposes conditions on some state bits of the cipher to make the non-constant superpoly of a cube as zero for the first few rounds. Some cube testers are formed by using those suitable cubes to implement a distinguishing attack on Grain-128a of reduced KSA (or initialization) rounds. We present a distinguisher for Grain-128a of 191 (out of 256) KSA round in the single key setup and 201 (out of 256) KSA round in the weak key setup by using the cubes of dimension 5. The number of rounds is the highest till today, and the cube dimension is smaller than the previous results. Further, we tested our algorithm on Grain-128 and achieved good results by using small cubes.

In this study, the authors construct two different distinguishers on Grain‐v1 with 112 and 114 initialisation rounds. Their first distinguisher can distinguish Grain‐v1 with 112 initialisation rounds from a uniform random source for 99% of the randomly chosen keys from full key space. The second one can distinguish Grain‐v1 from a random source for 73% of the randomly chosen keys for one‐fourth of the total key space (2 78 keys out of 2 80 keys). Our results improve upon the earlier distinguishers. The technique used for the distinguishers is conditional differential cryptanalysis. The existing works in this direction considered only one bit difference in the initialisation vector. However, for the first time, they could handle complicated conditions for the 2‐bit difference to obtain better cryptanalytic results. Extending their technique by allowing the 1‐bit difference in the pair of keys (i.e. related keys) and the 4‐bit difference in IVs, they could observe the non‐randomness till 116 initialisation rounds with a success in 62% cases.

Studying Boolean functions with high algebraic immunity (i.e., which can provide some kind of resistance against algebraic attack) has attracted much attention recently. In FSE 2005, Dalai, Gupta and Maitra presented the first construction of Boolean functions achieving maximum possible algebraic immunity. However, the important cryptographic properties, such as algebraic degree and nonlinearity, of the Boolean functions constructed using that method could not be answered, except (by experiment) when the number of variables was small (at most 16). In this paper we solve this problem for every number of variables. Further we study the structure of the construction in detail, and we deduce an algorithm for fast evaluation of the functions, which is crucial for a practical use in stream ciphers

Recently, algebraic attacks have received a lot of attention in the cryptographic literature. It has been observed that a Boolean function f used as a cryptographic primitive, and interpreted as a multivariate polynomial over F/sub 2/, should not have low degree multiples obtained by multiplication with low degree nonzero functions. In this paper, we show that a Boolean function having low nonlinearity is (also) weak against algebraic attacks, and we extend this result to higher order nonlinearities. Next, we present enumeration results on linearly independent annihilators. We also study certain classes of highly nonlinear resilient Boolean functions for their algebraic immunity. We identify that functions having low-degree subfunctions are weak in terms of algebraic immunity, and we analyze some existing constructions from this viewpoint. Further, we present a construction method to generate Boolean functions on n variables with highest possible algebraic immunity /spl lceil/n/2/spl rceil/ (this construction, first presented at the 2005 Workshop on Fast Software Encryption (FSE 2005), has been the first one producing such functions). These functions are obtained through a doubly indexed recursive relation. We calculate their Hamming weights and deduce their nonlinearities; we show that they have very high algebraic degrees. We express them as the sums of two functions which can be obtained from simple symmetric functions by a transformation which can be implemented with an algorithm whose complexity is linear in the number of variables. We deduce a very fast way of computing the output to these functions, given their input.