0
$\begingroup$

I'm trying a Birthday Attack to randomly generated strings and its $\mathop{SHA-1}$ hashes using a Mapped table of values in order to find a collision on only the first 8 bytes. With the first 4 or 5 bytes it was easy, but the problem now with 8 bytes is I'm running out of RAM memory as I'm storing the values, and I don't think generating all the possible hashes and storing them in a file is a solution. Any ideas to make it memory-efficient/faster?

$\endgroup$

closed as off-topic by e-sushi Oct 28 '16 at 18:47

This question appears to be off-topic. The users who voted to close gave this specific reason:

  • "Programming questions are off-topic even if you are writing or debugging cryptographic code. Unless your question is specifically about how the cryptographic algorithm or protocol works, you should look into asking on Stack Overflow instead." – e-sushi
If this question can be reworded to fit the rules in the help center, please edit the question.

1
$\begingroup$

About the memory requirement

Your target is 8 bytes long i.e. $2^{64}$ possibilities.

The probability to have a collision is given by the formula: $$P(n,N) \approx 1 - e^{-n^2/2N}$$ Where $N$ is the size of the output space and $n$ the number of values you try. By inverting the equation you get: $$n \approx \sqrt{-2N\ln (1 - p)}$$ For $p = 0.5$, you get : $$n \approx 1.2\sqrt{N}$$ Thus with $N = 2^{64}$, $$n = 1.2\times 2^{32}$$ Therefore you will need to generate about $5\ 000\ 000\ 000$ values of 8 bytes. The memory requirement is therefore of $40 GB$.

If you target $p = 10\%$ in order to reduce the memory requirement (you will just need to do the experiment a bunch of times), you will need $0.46\times 2^{32} \approx 2\ 000\ 000\ 000$ values and about $16 GB$ (which is a bit less constraining.

What you are doing is actually called a multi-target attack. I would also suggest you to have a look at this question : What are the memory requirements for this type of search if the hash function has an output length n bits?

Some optimisations:

You might want to avoid the random generation part. You could just take a seed $s$ and iterate from it using an array of values such that $$\forall i, h[i] = \mathop{SHA}(s + i)$$ This will divide the memory space required by 2 (as you don't need to store the value because it is the array index of the hash).

You might also want to consider the time complexity of your search (for each value you need to check that there are no previous collision). From my point of view, this really looks like in $O(n^2)$...

Another possibility would require you to look at differential cryptanalysis of $\mathop{SHA1}$ and look for differential trails where the 8 first bytes of the last difference are being composed only of $0$.

$\endgroup$

Not the answer you're looking for? Browse other questions tagged or ask your own question.