 The subject of this paper is the improvement of linear key recovery attacks using another proning technique for the fast-force transform. In a linear key recovery attack, we express the value of a linear approximation as a function of parts of the plaintext, the ciphertext and the key. In this paper, we assume that part of the key is absorbed directly to the plaintext and the ciphertext. So the aim of the attacker is to compute the experimental correlation of this linear approximation for each possible key, with the hopes of distinguishing the correct guess from the wrong ones. One popular way of computing these experimental correlations is the so-called Walsh Transform or FFT technique. Broadly speaking, this technique consists of the following steps. First, we count the number of occurrences in the data for each possible value of the plaintext and ciphertext segments. Next, we apply the FFT on this vector, then we multiply the vector by the Walsh spectrum of the key recovery map. And finally, we apply the FFT to obtain the desired experimental correlations. The total complexity of this version of the attack depends on the data complexity as well as the length of the inputs to the key recovery map. However, we may want to improve this complexity by exploiting specific details about the target cipher. For example, we may want to acknowledge the fact that in some cases, the initial vector will be very sparse. We also want to make use of any relations on the key guess, which are induced by the key schedule. And finally, we want to take into account the structure of the key recovery map, which depends on the cipher construction. We can express all of these properties as zeros in the input and the output vectors to the Walsh transform steps of the attack. However, in order to exploit this capacity, we must modify the FFT algorithm. It is for this reason that we introduce a new pruning technique for the FFT. We consider that all the non-zero inputs will lie in some known affine subspace x. And we also assume that we only wish to compute the outputs, which lie on another affine subspace u. We describe an algorithm which can reduce the complexity of computing such a Walsh transform to one of smaller dimensions, 2 to the t, where this parameter t is smaller than the dimensions of x and u. This means that the final complexity will only depend on the number of non-zero inputs, the number of desired outputs, and the parameter t. In particular, the complexity is not dependent on the size of the full transform. This algorithm can be applied to linear key recovery attacks, when we can restrict the inputs and the outputs of some of these Walsh transform steps to affine subspaces. This means that we can obtain a particularly large complexity gains when the support of the Walsh spectrum of the key recovery map lies on some union of small dimension affine subspaces. We study this type of property for ciphers using bit permutations as linear layers, and find that such structures appear when certain Walsh coefficients of the S-box are equal to zero. We also show that we can effectively set this Walsh coefficient to zero by rejecting a small fraction of the plaintext ciphertext s. We describe two application examples for this improved attack algorithm. First, we provide an improved version of Matsui's attack on the full DES, and we achieve the best known data complexity. Second, we construct the first attack on 29 rounds of the 128-bit key variant of present. There are several open problems regarding this technique, but we think that the main one is studying its applicability to more general linear layers.