-2
$\begingroup$

I have been researching SHA algorithms extensively, specifically SHA1, SHA2-256, SHA2-512, SHA3-256, and SHA3-512, and have found many instances of successful collision attacks as well as methods.

In my list are the following:

  • Brute Force attacks
    • Birthday attacks
    • Yuval's Birthday attack (improved birthday attack with different conditions)
  • Reduced round attacks
    • Successful on attacks on all SHA algorithms, SHA1, SHA-2, and Keccak ("Parent" function of SHA-3)
  • Chosen Prefix attacks

As well as attacks that defeat the security provided by algorithms in application.

  • Length extension attacks
    • SHA-3 is invulnerable due to the concatenation of capacity during permutations of Keccak sponge function.

I have excluded Brute force attacks (when not about finding collisions), including dictionary attacks, as well as rainbow tables since these are vulnerabilities created by something external to the algorithm itself.

Improve this question
$\endgroup$
5
  • $\begingroup$ Great work done, but the your question is a bit too broad. We can give you a summary of what each attack mean for those algorithms, but everything else is beyond the capability of community members. $\endgroup$
    – DannyNiu
    Jun 23 at 5:03
  • 1
    $\begingroup$ And kelalaka makes a good point in the comment of your previous question - "it is a research-type question". I would expect self researchers come to ask specific instances of issues instead of asking for overall summaries. $\endgroup$
    – DannyNiu
    Jun 23 at 5:08
  • $\begingroup$ @DannyNiu i feel more since the answer was exact copy of the previous. Circler scheme. Names $\endgroup$
    – kelalaka
    Jun 23 at 7:12
  • 2
    $\begingroup$ SHA-{1,2} and SHA-3 have completely different designs. It doesn't make sense to study them together. What kind of answer do you expect to this question anyway that goes beyond what's in the Wikipedia articles? $\endgroup$
    – Gilles 'SO- stop being evil'
    Jun 23 at 7:34
  • 1
    $\begingroup$ “have found many instances of successful collision attacks as well as methods” Read more carefully. All the successful attacks are on SHA-1 specifically. $\endgroup$
    – Gilles 'SO- stop being evil'
    Jun 23 at 7:35
1
$\begingroup$

I agree with your list but I would also consider adding comments in terms of how detrimental these attacks are to the actual security of the algorithms in terms of application. For example, successful reduced round attacks are not as worrying as they might seem since every additional round of an algorithm provides exponential amounts of added security, meaning that "breaking" a 42 round SHA256 algorithm does not breach any of the security provided by the full-round SHA256.

Additionally, actually "breaking" an algorithm doesn't completely make it insecure, in practice, since successful attacks often take up massive amounts of resources and time (breaking SHA1 took over 1.5 years and a collective of computers to break). So even if SHA1 is "insecure" it is still theoretically safe enough to use since it is infeasible to compute a collision in a reasonable amount of time and with a limited amount of resources.

Improve this answer
$\endgroup$
0
0
$\begingroup$

It might be worth noting the actual math behind the infeasibility of computing hash collisions in terms of preimage hashes too. It is one thing to find a collision where two hashes collide and to find a hash that collides with a pre-existing hash. Security is actually measured in terms of bit length, so theoretically it would take 2^n computations to find a collision in a n bit hashing algorithm. You can find more about ways of measuring security in hashing algorithms here.

Improve this answer
$\endgroup$
1
  • $\begingroup$ It is also notable that in terms of "broken" hash functions the actual data used to break them where PDF files. Also in context, the limitations provided by passwords means that even though SHA is used in password storage it will never be possible to create a collision there. It is impossible to find a collision of a SHA algorithm with less than a certain amount of data (I am unsure about the exact amount but surely more than 100MB of data or so). $\endgroup$
    – bean_
    Jun 23 at 5:18

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