Video summary

Google Did The Impossible

Main summary

Key takeaways

News and Commentary

Overview

The video explains how Google’s SHA-1 hashing algorithm effectively “died” after researchers demonstrated practical SHA-1 collisions—two different files producing the same hash. This breaks a core security property and puts any system relying on SHA-1 integrity at risk.

What happened: the “SHAttered” SHA-1 collision

  • On Feb 23, 2017, Google published details of an attack (part of the “SHAttered” project) showing that two visibly different PDFs could be crafted to have identical SHA-1 hashes.
  • The result violates collision resistance, the property SHA-1 is supposed to maintain—making it practically impossible for different inputs to produce the same hash.
  • A rapid response followed:
    • developer communities discussed which systems might be exposed,
    • users were urged to stop trusting SHA-1 in production.

Why SHA-1 breaking was “impossible” before—and how it became feasible

  • The video contrasts earlier expectations that collisions would require astronomical effort with the reality that cryptanalytic techniques can beat brute force.
  • The attack used differential cryptanalysis, aiming to exploit how carefully chosen small differences in input can cause the hash’s internal state to converge.
  • The team estimated the attack was orders of magnitude faster than brute force, with compute costs roughly around $110,000, described as feasible thanks to access to large-scale Google hardware/clusters.

Google’s disclosure and mitigation tools

  • Due to vulnerability disclosure policies, Google had to wait 90 days before releasing the public collision-generation code.
  • In the interim, Google provided a detection tool (“file tester” on the SHAttered site) to help identify suspicious files matching the collision pattern.
  • The main takeaway emphasized migrating away from SHA-1 toward safer hashes (e.g., the SHA-256 family).

Why SHA-1 was still widely used

Even before 2017, cryptographers had raised concerns:

  • Researchers like Stevens and others showed SHA-1 becoming weaker over time—reducing the effective difficulty of finding collisions in practice.
  • Standards bodies and browsers began shifting away earlier:
    • NIST deprecated SHA-1 for digital signatures in 2011.
    • Chrome began distrusting SHA-1 certificates and “sunsetting” them based on expiration timelines, with enforcement ramping up around 2017 onward.

However, migration was incomplete because SHA-1 was embedded in many long-lived systems and artifacts, such as:

  • certificate infrastructures,
  • firmware and embedded devices,
  • corporate and legacy systems,
  • stored hashes and signed content.

The video highlights that even major vendors moved slowly—for example, Windows update signing and the removal of old SHA-1 signed content took multiple years—showing how hard “complete” migration can be.

Secondary impacts and continued risk

  • Later work suggested collisions could become cheaper:
    • A 2020 paper (“SHA-1 is a shambles”) estimated collisions could be done for around $45,000 using rented GPU time.
  • Practical consequences extend beyond websites:
    • PGP/GPG identity certifications were discussed as still defaulting to SHA-1 in some workflows, potentially enabling impersonation within a web-of-trust model if collisions were crafted successfully.
    • Git uses SHA-1 object identifiers; while collisions could theoretically undermine integrity assumptions, GitHub implemented SHA-1 collision detection to reject known collision patterns. Migration was described as ongoing.
  • The video uses MD5 as a historical analogy: weaker hashing algorithms often took years/decades to fully retire, suggesting SHA-1 cleanup would be similarly prolonged.

Recommendation / conclusion

The video advises:

  • Don’t panic for typical day-to-day actions (e.g., browser padlocks and commit hashes are usually protected by newer standards).
  • Stay aware:
    • most systems should already rely on SHA-2 (especially SHA-256),
    • but legacy dependencies make migration difficult, so security practitioners must keep updating and auditing where SHA-1 is still used.

Presenters or contributors

  • Google researchers / SHAttered team
    • collaboration of researchers at CWI Amsterdam and Google’s security group
    • team of five referenced
  • Bruce Schneier
  • Shao Ying Wang (and colleagues)
  • Mark Stevens (and collaborators)
  • Gayton Laurent and Thomas Pin
  • NIST (standards body; referenced)
  • Microsoft (referenced)
  • GitHub (referenced)
  • Chrome/Firefox (referenced)
  • Boot.dev / us
    • sponsor message; the narrator is not separately named in the subtitles

Original video