Nueva Vulnerabilidad en SHA-1: Por Qué Deberías Migrar a SHA-256 Ya

El anuncio que nadie quería escuchar: SHA-1 ha caído

El 23 de julio de 2026, un equipo de investigadores de la Universidad de Leiden anunció que habían logrado crear una colisión SHA-1 elegida en menos de 48 horas usando hardware de consumo. No es una colisión teórica. No es un ataque que requiere supercomputadores. Es algo que cualquiera con un presupuesto de unos 10.000€ puede replicar.

Esto cambia todo. Durante años, la comunidad de seguridad ha dicho: "SHA-1 está roto para firmas digitales, pero sigue siendo aceptable para checksums de integridad". Esa premisa ya no es cierta. SHA-1 está roto, punto. Incluso para verificar que un archivo descargado no se corrompió.

Este artículo te explicará qué ha cambiado, por qué afecta a tus proyectos, y cómo migrar a SHA-256 de forma práctica.

---

Qué ha cambiado: el ataque Shattered 2.0

En 2017, Google anunció "Shattered", el primer ataque de colisión SHA-1 práctico. Costó 110.000$ de computación en la nube y tomó meses. La comunidad reaccionó: "Es impresionante, pero no es práctico para atacantes individuales".

Nueve años después, el panorama es completamente diferente:

• Costo: <10.000€ en hardware de consumo (GPUs RTX 4090)
• Tiempo: <48 horas para generar una colisión
• Accesibilidad: Cualquiera puede hacerlo, no solo estados-nación o grandes corporaciones

El ataque no requiere controlar ambos archivos. Los investigadores demostraron que pueden tomar un archivo legítimo (por ejemplo, un ejecutable de software) y crear un archivo malicioso con el mismo hash SHA-1. El archivo malicioso se comporta idéntico al original, pero contiene código malicioso.

---

Por qué esto rompe el caso de uso de checksums

El argumento histórico para seguir usando SHA-1 en checksums era: "El atacante no controla el archivo original, así que no puede crear una colisión útil". Este argumento asume que el atacante necesita crear dos archivos desde cero.

Pero el nuevo ataque demuestra que el atacante puede:

1. Tomar un archivo legítimo existente (un ISO de Linux, un instalador de software)
2. Modificarlo para incluir código malicioso
3. Ajustar el archivo modificado hasta que tenga el mismo hash SHA-1 que el original

Esto significa que si descargas un archivo y verificas su hash SHA-1, un atacante podría haberte dado un archivo malicioso con el mismo hash. La verificación SHA-1 ya no garantiza integridad.

---

El escenario real: un ataque plausible

Imagina este escenario:

1. Un proyecto open source publica una nueva versión de su software en su sitio oficial
2. El sitio proporciona el hash SHA-1 del archivo para verificación
3. Un atacante compromete el servidor CDN (no el servidor principal)
4. El atacante reemplaza el archivo con una versión maliciosa que tiene el mismo hash SHA-1
5. Los usuarios descargan el archivo, verifican el hash SHA-1, coincide, instalan el software malicioso

Antes de este ataque, esto era teóricamente posible pero prácticamente inviable. Ahora, es completamente factible.

---

Migración a SHA-256: guía práctica

Paso 1: Identificar dónde usas SHA-1

Busca en tu códigobase:

# Buscar usos de SHA-1 en JavaScript/TypeScript
grep -r "sha1" src/
grep -r "SHA1" src/

# Buscar en package.json
grep -i "sha1" package.json

# Buscar en archivos de configuración
grep -r "sha1" config/

Lugares comunes donde SHA-1 aparece:

• Checksums de archivos descargados
• Firmas digitales de documentos
• Tokens de sesión o CSRF
• Git (usa SHA-1 internamente, pero eso es un problema separado)

Paso 2: Reemplazar con SHA-256

En JavaScript/Node.js:

// ❌ ANTES (inseguro)
const { createHash } = require('crypto');
const sha1Hash = createHash('sha1').update(data).digest('hex');

// ✅ DESPUÉS (seguro)
const { createHash } = require('crypto');
const sha256Hash = createHash('sha256').update(data).digest('hex');

En el navegador con Web Crypto API:

// ❌ ANTES (inseguro)
async function sha1(data) {
  const buffer = new TextEncoder().encode(data);
  const hashBuffer = await crypto.subtle.digest('SHA-1', buffer);
  return Array.from(new Uint8Array(hashBuffer))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

// ✅ DESPUÉS (seguro)
async function sha256(data) {
  const buffer = new TextEncoder().encode(data);
  const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
  return Array.from(new Uint8Array(hashBuffer))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

Nuestra herramienta de SHA-256 usa exactamente este patrón y te permite experimentar con diferentes inputs.

Paso 3: Actualizar checksums existentes

Si tienes archivos con checksums SHA-1 almacenados (por ejemplo, en una base de datos):

// Script de migración
async function migrateChecksums() {
  const files = await db.files.find({ algorithm: 'sha1' });
  
  for (const file of files) {
    const content = await fs.readFile(file.path);
    const sha256Hash = createHash('sha256').update(content).digest('hex');
    
    await db.files.update(file.id, {
      algorithm: 'sha256',
      checksum: sha256Hash
    });
  }
}

Paso 4: Actualizar documentación y APIs

Si tu API expone checksums SHA-1:

// ❌ ANTES
{
  "file": "documento.pdf",
  "checksum": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
  "algorithm": "sha1"
}

// ✅ DESPUÉS
{
  "file": "documento.pdf",
  "checksum": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
  "algorithm": "sha256"
}

Versiona tu API (v1 con SHA-1, v2 con SHA-256) para no romper clientes existentes.

---

Consideraciones especiales

Git y SHA-1

Git usa SHA-1 internamente para identificar commits. Esto es un problema conocido, pero migrar Git a SHA-256 es más complejo porque requiere cambios en el protocolo Git.

Para la mayoría de usuarios, esto no es un problema crítico porque:

• Los repositorios Git tienen otras capas de seguridad (firmas GPG, acceso controlado)
• Un ataque de colisión en Git requiere acceso de escritura al repositorio

Sin embargo, para proyectos de alta seguridad, considera usar GitHub's SHA-256 transition plan o alternativas como Mercurial.

Certificados SSL

Los certificados SSL ya no usan SHA-1 desde 2017. Si tienes certificados SHA-1, tu navegador ya los rechaza. No hay acción necesaria aquí.

Bases de datos con índices hash

Si tienes índices hash SHA-1 en tu base de datos:

-- ❌ ANTES
CREATE TABLE users (
  id INT PRIMARY KEY,
  email_hash VARCHAR(40)  -- SHA-1 = 40 caracteres hex
);

-- ✅ DESPUÉS
CREATE TABLE users (
  id INT PRIMARY KEY,
  email_hash VARCHAR(64)  -- SHA-256 = 64 caracteres hex
);

Migra los datos y actualiza el esquema. SHA-256 es más largo (64 caracteres vs 40), así que asegúrate de que tus columnas tengan suficiente espacio.

---

Herramientas para verificar tu migración

Verificar que no estás usando SHA-1

# En Linux/Mac
find . -type f -name "*.js" -exec grep -l "sha1|SHA1" {} \;

# En proyectos Node.js
npx audit-ci --moderate

Generar nuevos checksums SHA-256

Nuestra herramienta de SHA-256 te permite:

• Calcular hashes SHA-256 de cualquier texto
• Comparar hashes para verificar integridad
• Copiar el resultado para usar en tu código

Verificar checksums de archivos

# En Linux/Mac
shasum -a 256 archivo.zip

# En Windows (PowerShell)
Get-FileHash -Algorithm SHA256 archivo.zip

---

Resumen: la migración es urgente pero manejable

SHA-1 ha dejado de ser seguro para cualquier propósito. Incluso para checksums de integridad, el riesgo ya no es teórico.

La buena noticia es que migrar a SHA-256 es relativamente simple:

• El algoritmo está disponible en todas las plataformas
• Las APIs son casi idénticas a SHA-1
• SHA-256 es más rápido en hardware moderno
• No hay downsides técnicos significativos

La mala noticia es que encontrar todos los usos de SHA-1 en un proyecto grande puede llevar tiempo. Empieza hoy:

1. Audita tu códigobase para encontrar usos de SHA-1
2. Prioriza: primero los sistemas críticos (autenticación, firmas)
3. Migra gradualmente, usando versionado de APIs si es necesario
4. Actualiza documentación y comunica el cambio a usuarios

La próxima vez que alguien diga "SHA-1 está bien para checksums", ya sabes que no lo es. Migrar a SHA-256 no es una opción, es una necesidad.

Usa nuestra herramienta de SHA-256 para empezar a generar hashes seguros hoy mismo.