Grain128-AEAD is a stream cipher, which has reached round 2 in the light-weight cryptography competition organized by NIST. The authenticated version is designed by Hell, Johansson, Meier, Sönnerup and Yoshida. In particular, the cipher consists of two main blocks: an LFSR and an NFSR. The authentication works by extracting bits from the keystream, which are exclusively used for the authentication tag, via an accumulator. A nice consequence of this, is that the security of the tag — in some regard — can be reduced to the security of the cipher.

The authentication tag is computed as

So, given the matrix , we can solve the equations to find a message which has any tag we want. If we have a set of keys, say , we can compute the corresponding key matrices . Note that since we know , we can make the dimension of them arbitrarily large.

Construct and solve the equation system for any arbitrary . Now, we have solved the problem of the same message evaluating to the same tag. But this not exactly what we want — instead we want equal ciphertexts to evaluate to the same tag. If we denote the keystream used for encryption as and the ciphertext , then we can rewrite the above as

and we solve for . We now get two equal ciphertexts (and same IV), but different decrypted messages which evaluate to the same arbitrary tag. Of course, we can extend this to an arbitrary amount of messages. Compared to GCM and Poly1305, which both have a nice structured matrix allowing for complexity, the inclusion of non-linear bits in Grain makes the solving part a bit more expensive and ends up around .

In the context of partition oracles, we typically assume that the keys were generated using a KDF from a large set of passwords which we like to probe for using limited queries.

For instance, the block

decrypts successfully (i.e. tag is valid) under both keys

So, using the above cipertext and tag we can simultaneously test for two passwords such that and using an oracle which validates the tag. The response can be error based, timing based or some other measurable information.

Assume there is a black box, that given a cryptographic hash function , finds some and in polynomial time, such that applying , times gives :

The question is if an oracle, denoted in the text, can be used to prove if this function is not collision resistant or pre-image resistant.

We claim the following, without proof (for now):

Theorem 1: Given a random hash function and an oracle (according to the above), then a collision can be found in time if has a cycle of length .

We will spend the following sections to prove this. Let us first consider the simplest construction for which the above claim holds. We also state the following corollary.

Corollary 1: If the function in Theorem 1 does not have a cycle, then there exists an polynomial-time probabilistic algorithm which randomizes the cycle structure and solves the problem with probability 1.

By Corollary 1, an adversary cannot craft a special function that averts the result of Theorem 1.

Fixed points

We start off by looking how the oracle can be used to derive fixed points, i.e. elements in such that . If the oracle was to return the shortest cycle, it would immediately tells us if there is a fixpoint or not.

Let us assume the oracle instead picks a cycle at random (which is a reasonable assumption, as this is how cycle-finding algoritm works). We create an auxilliary function as follows

Or (equivalently) in Python:

def h_prime(x):
    if h(x) == x: # is fixpoint
        return x
    else:
        return x + 1

Once our new modified function is fed to the oracle, the oracle in turn will give a fix point for both and if one such exists in . More specifically, upon calling the oracle with , it will return and for some .
Obviously, no other point can be a fixpoint nor in a cycle (unless the value of wraps around and no fixpoints exist), just leading up to a fixpoint. So, the oracle can only return fixpoints and will do so if one exists.

Assuming that the function behaves randomly, then the expected number of fixpoints is As a result, we can, with high probability find at least one element that is a fixpoint. We will see that this can in fact be fixed by using randomization of the cycle structure, by composition with a random permutation.

A preimage as also easy to find. Assume that we want to find . We then construct

Any value leading to will be a 1-cycle (or fixpoint) in the . No other cycles will exist.

Random oracles

Clearly, the above idea can be used to find fixpoints in any function acting as a random oracle (or any cycle of length that we see fit). We will now see how to extend this idea further.

If a point leads to a fixpoint , then necessarily we have a collision . We call a second-order fixpoint (c.f. , which is a first-order fixpoint).

To include the second-order points in the result from the oracle, we simply remove the first-order fixpoints and turn the second-order fixpoints into first-order fixpoints.

def h_prime(x):
    if h(x) == x: # is fixpoint
        return x+1
    elif h(x) == h(h(x)):
        # leads to fixpoint, so x != h(x)
        return x
    else:
        return x+1

Now, we can use this to determinstically find a collision. Consider an algorithm which calls the oracle with the modified function . Assume that returns . If is of second order, then we have a collision.

Obviously a first-order fixpoint is a 1-cycle. But what about -cycles? Consider the following (efficiently computable function)

How does this work? Every element that is in a -cycle will be turned into elements leading to a 1-cycle, and every element that jumps into a cycle (but is not part of it) is turned into a 1-cycle.

By setting and calling the oracle with the function , we will ultimately find a collision if admits a cycle of length up to . If the cost of computing and can be neglected, then the complexity is constant.

Evidently, the collision is between the elements and . This concludes the proof.

If no cycle exists of length (let us assume the adversary created one with special structure to thwart this attack), then it is possible to do a re-randomization of . By composition with a random permutation , we create . This will alter the cycle structure (and can be done multiple times). After finding a collision in , we can find one in as .

Algorithm 1:

Input: function
Output: Colliding pair

1. Pick a random (efficiently computable) permutation . Let .
2. Construct
3. Ask oracle to find a cycle in , call this . If the returned length is not 1, to go 1 (first step).
4. Return collision

As a final note: If the output should have a finite image in, say, bits, then the must be taken . This is no problem, as this will not constitute a cycle if there exists at least one 1-cycle.

A simple example

What would a result like this be without a real-world example? Here is a toy example, which assumes . Hence .

from random import randint
from hashlib import sha256

def h(x):
    return int(
        sha256(str(x)).hexdigest()[2:6], 16
    )

def h_prime(x):
    # x = h^6(x)
    if x == h(h(h(h(h(h(x)))))):
        return x + 1
    elif h(x) == h(h(h(h(h(h(h(x))))))):
        return x
    else:
        return x + 1

def oracle(h):
    x0 = randint(0, 256**2)
    tortoise = x0
    hare = h(x0)

    while True:
        tortoise = h(tortoise)
        y = h(hare)
        hare = h(y)
        if tortoise == y or tortoise == hare:
            break

    return hare

y = oracle(h_prime)
x = h(h(h(h(h(h(y))))))

assert(y != x)
assert(h(x) == h(y))

The decision oracle flavour

Worth noting, we can solve this problem with a weaker form of the oracle. If we have a fixed-point (or -cycle) oracle that can be asked if the function has this property and replies with yes or no, then this can be turned into the original oracle. By construction, we can keep half of the function to remain the same, while the other part is crafted so that it has no cycles. Then, by using binary search, it is possible to determine the fixed point (or -cycle).

Most recently, four security researchers disclosed two vulnerabilities on TPM modules, named collectively under the umbrella name TPM-FAIL. Effectively, the attack allows an attacker to leak cryptographic keys stored inside the TPM modules. More specifically, the attack is targeted at a timing-information leakage within elliptic-curve computation.

Elliptic curve signatures

The private and public keys are generated as follows.

where and . Below is an (insecure) example of such a construction, in Sage.

p = random_prime(2**128)
R = GF(p)
E = EllipticCurve(R, [-3, 1])

# generate public/private key
d = ZZ(R.random_element())
P = E.random_element()
Q = ZZ(d) * P

The signature in DSA is computed  in the following way. First pick a secret integer . Then compute . Set . Then compute

The signature is . Here is how to compute it.

# message to be signed
message = "sample message"
Hm = int(md5(message).hexdigest(), 16)
k = ZZ(R.random_element())
r,_,_ = k*Q
s = 1/R(k)*(Hm +d*r)
signature = (r, s)

Timing-information leaks

The attacks exploits the simple property that the computation of does not finish in constant time. If is small, then it completes measurably faster.

Assume that we have an oracle for this and can obtain signatures with, say, of the leading bits of the secret nonce set to .

# samples obtained from the oracle
ns = 50
A = []
B = []

# real values for k
ks = []

# sign with small k
for i in range(0, ns):
    k = ZZ(R.random_element()) // 2^20
    ks += [k]
    r,_,_ = k*Q
    s = 1/R(k)*(Hm +d*r)
    A += [1/s * Hm]
    B += [1/s * r]

Running this code, gives us enough signatures to recover .

Lattice attack

The attack proceeds by using lattice-reduction techniques, which finds short vectors in a lattice. The researchers construct a lattice in the following way

where the blanks are 0. The upper row with the entries exist to get the behavior of modulo reduction by .

Here, and are defined as

which gives us a relation for in terms of known and computable values. The value is a weighting factor, which effectively forces the coefficient for to be in the lattice reduction (whereas a randomly selected is typically in the order of ). Continuing our example, by setting , we can implement the attack as follows.

K = p
X = p * identity_matrix(QQ, ns)
Z = matrix(QQ, [0] * ns + [K/p] + [0]).transpose()
Z2 = matrix(QQ, [0] * (ns+1) + [K]).transpose()

Y = block_matrix([[X],[matrix(QQ, B)], [matrix(QQ, A)]])
Y = block_matrix([[Y, Z, Z2]])
Y = Y.LLL()
print "Found", Y[-1][0]
print "Should be", ks[0]

With high probability, this yields the secret . From this, it is trivial to obtain the private key .

On this years SEC-T CTF, I made three challenges. One of the challenges, likeason[1] was given as follows:

#! /usr/bin/env python
import sys

from secret import d, n

def oracle(c, x=1):
    res = bin(pow(c, d * x, n)).count('1') & 0x1
    return int(res)

while True:
    try:
        c = [int(x) for x in sys.stdin.readline().split(" ")]
        if len(c) == 1:
            sys.stdout.write("%d\n" % oracle(c[0]))
        else:
            sys.stdout.write("%d\n" % oracle(c[0], x=c[1]))
    except Exception:
        sys.stdout.write("Nope.\n")

    sys.stdout.flush()

# e = 0x10001
# c = 32028315366572316530941187471534975579021238700122793819215559206747120150118490538115208229905399038122261293920013020124257186389163654867911967899754432511568776857320594304655042217535057811315461534790485879395513727264354857833013662037825295017832478478693519684813603327210332854320793948700855663229

As we can see, the oracle returns the parity of the bits in the decrypted plaintext. We also know that the ciphertext contained only {" ", ".", "-"}, followed by some random padding. A specific format is actually not needed, but it makes the challenge easier. The reader may notice that it has some resemblence with the Bleichenbacher oracle, but an easier way is to treat it as a regular (but unreliable) LSB (or MSB) oracle. We observe that for any unique query

but we also have that

.

We may assume random events, although this is not completely true.

Finding the modulus

First we need to find the modulus . This is quite simple. Pick a number and send by sending the pair 2**k e to the oracle. We know that parity is always 1 if . However, when and , the decryption yields . This may cause a parity flip, but not necessary. So, what can we do about that? Randomization!

Instead, we can send , where is a random number, sufficiently small (here, works) to not cause overflow when . Alternatively, we can use a single bit, i.e. for some . In this manner, we can send queries and w.h.p detect the parity changes.

Finding the plaintext using known plaintext properties

An efficient way of determining the plaintext is as follows:

First, build a set of parities from sufficiently many queries of the form , for some integer . This is mostly for caching purposes, so that no redundant calls are needed to be made.

Define an upperbound and lowerbound on the plaintext , and , respectively. Then, build a search tree using the ideas from attacking LSB (or MSB oracles). If we observe a parity flip, from previous step, then we record a new lowerbound in its single child node. On the other hand, if there is no flip from previous we cannot be sure (which is the same problem as before, when determining ). Define the parity at step to be . Then, recursion will be as follows:

So, to be certain, we need to investigate both paths (i.e., assuming an overflow and updating the lowerbound and no overflow, hence setting a new upperbound ). We can do so, and prune paths by using that the bytes for which the upperbound and lowerbound agrees need to be in the alphabet for the message (see above). This was the intended solution, and probably easiest to find.

Finding the plaintext using randomization

Will be added when I have time to describe it in detail.

[1] An anagram for snakeoil in honor to Crown Sterling.

 

During the last months, the problem of finding magic hashes for various hash functions has had a renaissance. After this tweet, the over-a-decade-old problem received new attention from a few people in the security community and, as a consequence, a flurry of new magical hashes were found.

Magical hashes have their roots in PHP. In particular, it all revolves around the improper use of the equality operator ==. PHP uses implicit typing, e.g., if a string has the format 0e[digits], then it is interpreted as the scientific notation for . This has some undesired side effects: when comparing hashes from password input it causes a small but non-negligible subset of elements that are all equal under the == operation.

The probability of a hash being magical is easy to compute if we can assume that the hash function behaves completely at random. Let the be a hash function with -hexdigit long output. If we disregard all but the ones starting with 0e..., we have

for an randomly selected over all strings of any length.

The inverse probability amounts to the number of trials (or hash-function oracle calls) required on average to find a magic hash. For instance, SHA-256, which has an output length corresponds to about calls.

Modifying hashcat kernels

We will take SHA-224 as an example, since it is a bit easier to find magic hashes for. First, we are going to define two masks:

The first one returns 0 if the hex representation contains nothing but decimal digits:

#define  IS_MAGIC(x)    ((x & 0x88888888) & (((x & 0x22222222) >> 1 | (x & 0x44444444) >> 2) & ((x & 0x88888888) >> 3)) << 3)

The second one does the same as the first, but it forces the first two hex digits to 0e.

#define  IS_MAGIC_H(x)  ((x & 0x00888888) & (((x & 0x00222222) >> 1 | (x & 0x00444444) >> 2) & ((x & 0x00888888) >> 3)) << 3) | ((x & 0xff000000) ^ 0x0e000000)

We add these lines to inc_hash_sha224.h. Then, we locate the function sha224_final_vector in inc_hash_sha224.cl.

DECLSPEC void sha224_final_vector (sha224_ctx_vector_t *ctx)
{
  MAYBE_VOLATILE const int pos = ctx->len & 63;  
  append_0x80_4x4 (ctx->w0, ctx->w1, ctx->w2, ctx->w3, pos ^ 3);  
  if (pos >= 56)
  {
     sha224_transform_vector (ctx->w0, ctx->w1, ctx->w2, ctx->w3, ctx->h);
     ctx->w0[0] = 0;
     ctx->w0[1] = 0;
     ctx->w0[2] = 0;
     ctx->w0[3] = 0;
     ctx->w1[0] = 0;
     ctx->w1[1] = 0;
     ctx->w1[2] = 0;
     ctx->w1[3] = 0;
     ctx->w2[0] = 0;
     ctx->w2[1] = 0;
     ctx->w2[2] = 0;
     ctx->w2[3] = 0;
     ctx->w3[0] = 0;
     ctx->w3[1] = 0;
     ctx->w3[2] = 0;
     ctx->w3[3] = 0;
  }  
  ctx->w3[2] = 0;
  ctx->w3[3] = ctx->len * 8;  
  sha224_transform_vector (ctx->w0, ctx->w1, ctx->w2, ctx->w3, ctx->h);

  // Add these lines
  ctx->h[0] = IS_MAGIC_H(ctx->h[0]); // first block starts with 0e
  ctx->h[1] = IS_MAGIC(ctx->h[1]);
  ctx->h[2] = IS_MAGIC(ctx->h[2]);
  ctx->h[3] = IS_MAGIC(ctx->h[3]);
  ctx->h[4] = IS_MAGIC(ctx->h[4]);
  ctx->h[5] = IS_MAGIC(ctx->h[5]);
  ctx->h[6] = IS_MAGIC(ctx->h[6]);
}

Finally, we need to modify the corresponding module m01300_a3_pure.cl. More specifically, we modify the following function:

KERNEL_FQ void m01300_sxx (KERN_ATTR_VECTOR ())
{
  /**
   * modifier
   */

  const u64 lid = get_local_id (0);
  const u64 gid = get_global_id (0);

  if (gid >= gid_max) return;

  /**
   * digest
   */

  const u32 search[4] =
  {
    digests_buf[digests_offset].digest_buf[DGST_R0],
    digests_buf[digests_offset].digest_buf[DGST_R1],
    digests_buf[digests_offset].digest_buf[DGST_R2],
    digests_buf[digests_offset].digest_buf[DGST_R3]
  };

  /**
   * base
   */

  const u32 pw_len = pws[gid].pw_len;

  u32x w[64] = { 0 };

  for (u32 i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
  {
    w[idx] = pws[gid].i[idx];
  }

  /**
   * loop
   */

  u32x w0l = w[0];

  for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
  {
    const u32x w0r = words_buf_r[il_pos / VECT_SIZE];

    const u32x w0 = w0l | w0r;

    w[0] = w0;

    sha224_ctx_vector_t ctx;

    sha224_init_vector (&ctx);

    sha224_update_vector (&ctx, w, pw_len);

    sha224_final_vector (&ctx);

    const u32x r0 = ctx.h[0];
    const u32x r1 = ctx.h[1];
    const u32x r2 = ctx.h[2];
    const u32x r3 = ctx.h[3];
    const u32x r4 = ctx.h[4];
    const u32x r5 = ctx.h[5];
    const u32x r6 = ctx.h[6];
    
    // this is one hacky solution
    if ((r4 == 0) && (r5 == 0) && (r6 == 0)) {
       COMPARE_S_SIMD (r0, r1, r2, r3);
    }
  }
}

This assumes no vectorization. Now build hashcat. Since all magic hashes will be mapped to the all-zero sequence, we run it as follows:

$ ./hashcat.bin -m 1300 00000000000000000000000000000000000000000000000000000000 -a 3 --self-test-disable --keep-guessing

--keep-guessing causes hashcat to continue looking for hashes, even after one has been found. The --self-test-disable is needed, since we have modified how SHA-224 functions, and the testcases defined in hashcat will consequently fail.

Running it on AWS

TBA?

Results

Relatively quickly, we found several magic hashes using this modification for SHA-224:

noskba6h0:0e615700362721473273572994672194243561543298826708511055
Ssrodxcm0:0e490606683681835610577024835460055379837761934700306599
i04i19pjb:0e487547019477070898434358527128478302010609538219168998
Fuq0guvec:0e469685182044169758492939426426028878580665828076076227
Sjv2n8fjg:0e353928003962053988403389507631422927454987073208369549
L0gg4bvt5:0e730381844465899091531741380493299916620289188395999379
7v2k2to5o:0e676632093970918870688436761599383423043605011248525140

For SHA-256:

Sol7trnk00:0e57289584033733351592613162328254589214408593566331187698889096

For a more comprehensive list of hashes, refer to this Github repo.

Thanks to @0xb0bb for providing crucial help with computational resources.

---

Problem 1  (Knapsack)

We want to maximize the value of a subset of items such that the weight of the set is no larger than weight .

---

Let us first study another problem. It is easy to see that this problem is at least as hard as Problem 1.

---

Problem 2  (Auxiliary problem)

---

We can solve Problem 1 using an oracle for Problem 2. For a knapsack instance with an item of weight and weight , we create a terms . The must be unique for every item. This is done for every item in the knapsack. So, Problem 2 is NP-hard.

Now, we want to build some theory towards polynomials. Consider the following construction. Assign each with a corresponding monomial . Now assume that we want to represent the term . Define to be a product . is a prime number.

We map the term to the polynomial

This means that . To consider all terms jointly, pick a number large number . Then, we create a polynomial using the terms ,  and so on. We assume there are terms.

Then, the polynomial is constructed as . Since was a large number, it means that the terms of and will not interfere.

We now turn this problem into an instance of finding a low-weight codeword in a QC-MDPC code.

---

Problem 3  (Low-weight codeword of QC-MDPC code)

Let be the generator of a QC-MDPC code. Find a non-zero codeword with minimal weight, i.e., minimize .

---

There is a bijective mapping from a quasi-cyclic code to a polynomial, i.e., generates a code as well. So, generates a quasi-cyclic code. Let us first assume we have access to an oracle for Problem 2.

Indeed, a optimal solution to Problem 2 will give rise to a codeword in the corresponding code of low weight. Assume that the optimum is . This means that is of degree and that , i.e., has at most non-zero coefficients.

Using an oracle for Problem 3, we find a minimal-weight codeword for the generator .

In index calculus, the main problem is to represent powers of in a predefined prime-number basis. We are interested in unravel from .

Normal approach

First, we find some offset such that the factorization is -smooth.

Using the prime-number basis , generate a corresponding vector

Then, we generate powers and check if they have the same property. The results are put into a matrix after which one performs Gaussian eliminiation over .

. Then compute to find .

Different approach

Almost like in the normal approach, we find some offset such that the factorization of at least fraction of greater than is -smooth.

Again, Using the prime-number basis , generate a corresponding vector

The vector is chosen such that corresponds to the product of primes not represented in the chosen basis. In other words, for the vector above, or equivalently, .

Again, we generate powers and check if they have the same property as above and solved as the normal approach.

Find . Then compute to find . There is a catch here. It will be correct if and only if

It remains to see if this actually improves over the normal approach.

Tests with sage.

(Originally posted here)

Scenario

In this scenario, and wants to distribute segments of their data (preferably encrypted). We do not care about coverage, we are trying to maximize the amount of remotely stored data. The game is essentially that any peer, will try to minimize their own storage requirements and thus maximize other peers’.

Protocol

Two peers and will repeatedly negotiate upon storage space according to the follwing protocol, where is prover and verifier. Let be the set of segments owned by and stored by . Moreover, let be an abritrary segment and let denote the signature of .

1. picks a random string of length bits (equal to the length of the signature)
2. asks to send the closests segment from , i.e., such that is minimized.
3. verifies the segment via the signature. Then, using the distance , can estimate the number of segments stored by .

Repeat until the variance is low enough. The procedure is performed both ways.

Approximating

Intuitively, we can think of as a random (non-linear) code over and the task is to find a minimum-weight codeword in . Then corresponds to the number of codewords in .

Assume that A has stored segments. Without loss of generality, we can assume that is the all-zero string, hence transforming the problem to finding the minimum weight of $n$ binomial variables. Let and . Then with high probability and for larger values of ,

The above can be obtained by Gaussian approximation and the conventional expectation of the minimum of Gaussian random variables. We omit the proof here. Of course, this can be pre-computed for reasonable values of .

Assume there exists a peer with infinite computing power that tries to minimize its required storage for a given minimum distance . Done in an optimal manner, will pick equidistant points in the space . This corresponds to a perfect error-correcting code with minimum distance $d$. The covering-coding bound states that . For a perfect code, which has minimal size, we have . Therefore, the size of the code is , which is also the number of elements needs to store.

A glaring problem is that cannot arbitrarily pick points (since points must be valid signatures). The best can do is to decide upon a perfect code (or pick one that is closest to the current set of points — which is a very hard problem). Then, will look for points and that map to the same codeword and discard the point that is the farthest away from . For larger and smaller , it is not realistic to achieve the covering-coding bound since there in reality are not that many shared segments. So, even given infinite computation, will not be able to sample points until a perfect code is achieved.

The covering-coding bound serves as a crude estimation on how to set the parameters.

Simulating

In Figure , we see that the upper bound for expected minimum distance approximates for values larger than and .

Assume that send a signature along with the segment. Let

can now use different bounds at its own choice. Assume that Then, using the expression

determines that most likely has at least segments with high probability. Using the lower bound, has at least segments.

So, what is all this?

The intention is to create a simplistic protocol for asserting that shared data actually is retrievable, based on a probabilistic model. This could serve as basis for shared storage, in which segments are distributed. Even if the storer does not have access to the segments it has distributed, it can use the protocol to verify that it can retrieve them without actually doing so.