Generador de Hash MD5 y SHA-256: Guia Completa con Ejemplos de Codigo

Las funciones hash son de los componentes mas importantes en informatica y ciberseguridad. Cada dia, los desarrolladores utilizan generadores de hash MD5, calculos de hash SHA-256 y otros algoritmos para verificar la integridad de archivos, almacenar contrasenas de forma segura y alimentar la blockchain. Esta guia completa cubre desde la teoria fundamental hasta ejemplos de codigo practicos en JavaScript, Python, Bash y PowerShell.

Prueba nuestro generador de hash en linea gratuito — MD5, SHA-1, SHA-256, SHA-512.

Que es una funcion hash?

Una funcion hash es un algoritmo matematico que toma una entrada de cualquier tamano y produce una salida de tamano fijo llamada valor hash. Por ejemplo, el hash MD5 de "hello" es siempre 5d41402abc4b2a76b9719d911017c592.

Las funciones hash tienen cuatro propiedades esenciales: Determinista, Longitud de salida fija, Unidireccional (resistencia a preimagen) y Efecto avalancha — un pequeno cambio en la entrada cambia completamente el hash.

La resistencia a colisiones es critica para funciones hash criptograficas. SHA-256 permanece seguro mientras que MD5 y SHA-1 tienen vulnerabilidades de colision conocidas.

Comparacion de algoritmos hash comunes

Aqui hay una comparacion de los algoritmos hash mas populares:

MD5 produce un digest de 128 bits y esta criptograficamente roto desde 2004. SHA-1 produce 160 bits y fue atacado por Google en 2017. SHA-256 produce 256 bits y permanece seguro. SHA-512 produce 512 bits con mayor margen de seguridad.

Para cualquier aplicacion sensible a la seguridad, use SHA-256 o SHA-512.

Como funcionan las funciones hash

La mayoria de las funciones hash modernas siguen la construccion Merkle-Damgard en tres etapas:

1. Relleno del mensaje: El mensaje se rellena para que su longitud sea multiplo del tamano del bloque (512 bits para SHA-256).

2. Procesamiento por bloques: El mensaje se divide en bloques de tamano fijo, procesados por una funcion de compresion con operaciones bit a bit y rotaciones.

3. Salida final: Despues de procesar todos los bloques, el valor final es el digest hash.

Incluso un solo bit de cambio en la entrada produce un hash completamente diferente (efecto avalancha).

Casos de uso practicos

Las funciones hash se usan en todas partes en la informatica moderna:

Verificacion de integridad de archivos: Compare el hash SHA-256 de un archivo descargado con el valor publicado.

Almacenamiento de contrasenas: Las aplicaciones seguras hashean contrasenas con bcrypt, scrypt o Argon2.

Firmas digitales: El software calcula un hash del documento y lo cifra con la clave privada. Los certificados TLS/SSL dependen de funciones hash.

Control de versiones Git: Git usa hashes SHA-1 para identificar de forma unica cada commit.

Blockchain: Bitcoin usa doble SHA-256 para encabezados de bloques y verificacion de transacciones.

Deduplicacion y cache: Los sistemas de almacenamiento cloud usan hashes para detectar archivos duplicados sin comparacion byte a byte.

Ejemplos de codigo de generacion de hash

JavaScript (navegador y Node.js)

Use crypto.subtle.digest en el navegador y el modulo crypto en Node.js:

// ===== Browser: Web Crypto API (SHA-256) =====

async function sha256(message) {
  const encoder = new TextEncoder();
  const data = encoder.encode(message);
  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
}

// Usage
const hash = await sha256('Hello World');
console.log(hash);
// "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e"

// Supports SHA-1, SHA-256, SHA-384, SHA-512
async function hashDigest(message, algorithm = 'SHA-256') {
  const data = new TextEncoder().encode(message);
  const buffer = await crypto.subtle.digest(algorithm, data);
  return Array.from(new Uint8Array(buffer))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

await hashDigest('hello', 'SHA-1');    // "aaf4c61d..."
await hashDigest('hello', 'SHA-256');  // "2cf24dba..."
await hashDigest('hello', 'SHA-512');  // "9b71d224..."

// ===== Node.js: crypto module =====

const crypto = require('crypto');

// MD5 hash
const md5 = crypto.createHash('md5').update('Hello World').digest('hex');
console.log(md5); // "b10a8db164e0754105b7a99be72e3fe5"

// SHA-1 hash
const sha1 = crypto.createHash('sha1').update('Hello World').digest('hex');
console.log(sha1); // "0a4d55a8d778e5022fab701977c5d840bbc486d0"

// SHA-256 hash
const sha256 = crypto.createHash('sha256').update('Hello World').digest('hex');
console.log(sha256); // "a591a6d40bf420404a011733cfb7b190..."

// SHA-512 hash
const sha512 = crypto.createHash('sha512').update('Hello World').digest('hex');
console.log(sha512); // "2c74fd17edafd80e8447b0d46741ee24..."

// Hash a file
const fs = require('fs');
function hashFile(filePath, algorithm = 'sha256') {
  return new Promise((resolve, reject) => {
    const hash = crypto.createHash(algorithm);
    const stream = fs.createReadStream(filePath);
    stream.on('data', data => hash.update(data));
    stream.on('end', () => resolve(hash.digest('hex')));
    stream.on('error', reject);
  });
}

const fileHash = await hashFile('./package.json', 'sha256');

Python (hashlib)

Python proporciona el modulo hashlib para MD5, SHA-1, SHA-256 y otros:

import hashlib

# MD5 hash
md5_hash = hashlib.md5("Hello World".encode('utf-8')).hexdigest()
print(md5_hash)  # "b10a8db164e0754105b7a99be72e3fe5"

# SHA-1 hash
sha1_hash = hashlib.sha1("Hello World".encode('utf-8')).hexdigest()
print(sha1_hash)  # "0a4d55a8d778e5022fab701977c5d840bbc486d0"

# SHA-256 hash
sha256_hash = hashlib.sha256("Hello World".encode('utf-8')).hexdigest()
print(sha256_hash)  # "a591a6d40bf420404a011733cfb7b190..."

# SHA-512 hash
sha512_hash = hashlib.sha512("Hello World".encode('utf-8')).hexdigest()
print(sha512_hash)  # "2c74fd17edafd80e8447b0d46741ee24..."

# Hash a file (memory-efficient for large files)
def hash_file(filepath, algorithm='sha256'):
    h = hashlib.new(algorithm)
    with open(filepath, 'rb') as f:
        for chunk in iter(lambda: f.read(8192), b''):
            h.update(chunk)
    return h.hexdigest()

file_hash = hash_file('document.pdf', 'sha256')
print(f"SHA-256: {file_hash}")

# Compare file hashes for integrity verification
def verify_integrity(filepath, expected_hash, algorithm='sha256'):
    actual_hash = hash_file(filepath, algorithm)
    return actual_hash == expected_hash

# List all available hash algorithms
print(hashlib.algorithms_available)
# {'md5', 'sha1', 'sha256', 'sha512', 'sha3_256', ...}

Bash / Linux

Linux y macOS proporcionan md5sum, sha256sum y openssl dgst:

# MD5 hash of a string
echo -n "Hello World" | md5sum
# b10a8db164e0754105b7a99be72e3fe5  -

# SHA-1 hash of a string
echo -n "Hello World" | sha1sum
# 0a4d55a8d778e5022fab701977c5d840bbc486d0  -

# SHA-256 hash of a string
echo -n "Hello World" | sha256sum
# a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e  -

# SHA-512 hash of a string
echo -n "Hello World" | sha512sum
# 2c74fd17edafd80e8447b0d46741ee243b7eb74dd2149a0ab1b9246fb30382f2...  -

# Hash a file
md5sum package.json
sha256sum package.json
sha512sum package.json

# Using openssl (works on both Linux and macOS)
echo -n "Hello World" | openssl dgst -md5
echo -n "Hello World" | openssl dgst -sha1
echo -n "Hello World" | openssl dgst -sha256
echo -n "Hello World" | openssl dgst -sha512

# Hash a file with openssl
openssl dgst -sha256 package.json

# macOS uses shasum instead of sha256sum
echo -n "Hello World" | shasum -a 256
echo -n "Hello World" | shasum -a 512

# Verify a downloaded file against a known hash
echo "expected_hash_here  filename" | sha256sum --check

# Hash all files in a directory
find . -type f -exec sha256sum {} \;

PowerShell (Get-FileHash)

PowerShell proporciona Get-FileHash para archivos y clases .NET para cadenas:

# Hash a file with Get-FileHash (SHA-256 is default)
Get-FileHash -Path "C:\document.pdf"
Get-FileHash -Path "C:\document.pdf" -Algorithm MD5
Get-FileHash -Path "C:\document.pdf" -Algorithm SHA1
Get-FileHash -Path "C:\document.pdf" -Algorithm SHA256
Get-FileHash -Path "C:\document.pdf" -Algorithm SHA512

# Hash a string (MD5)
$md5 = [System.Security.Cryptography.MD5]::Create()
$bytes = [System.Text.Encoding]::UTF8.GetBytes("Hello World")
$hash = $md5.ComputeHash($bytes)
$hashString = [BitConverter]::ToString($hash).Replace("-", "").ToLower()
Write-Output $hashString
# "b10a8db164e0754105b7a99be72e3fe5"

# Hash a string (SHA-256)
$sha256 = [System.Security.Cryptography.SHA256]::Create()
$bytes = [System.Text.Encoding]::UTF8.GetBytes("Hello World")
$hash = $sha256.ComputeHash($bytes)
$hashString = [BitConverter]::ToString($hash).Replace("-", "").ToLower()
Write-Output $hashString
# "a591a6d40bf420404a011733cfb7b190..."

# Reusable function for string hashing
function Get-StringHash {
    param(
        [string]$InputString,
        [string]$Algorithm = "SHA256"
    )
    $hasher = [System.Security.Cryptography.HashAlgorithm]::Create($Algorithm)
    $bytes = [System.Text.Encoding]::UTF8.GetBytes($InputString)
    $hash = $hasher.ComputeHash($bytes)
    return [BitConverter]::ToString($hash).Replace("-", "").ToLower()
}

Get-StringHash "Hello World" "MD5"
Get-StringHash "Hello World" "SHA256"
Get-StringHash "Hello World" "SHA512"

# Verify file integrity
$expected = "a591a6d40bf420404a011733cfb7b190..."
$actual = (Get-FileHash -Path "file.zip" -Algorithm SHA256).Hash.ToLower()
if ($actual -eq $expected) { "MATCH" } else { "MISMATCH" }

MD5 vs SHA-256: cual usar?

MD5 esta criptograficamente roto — las colisiones se pueden generar en segundos. Para aplicaciones de seguridad, MD5 no es seguro.

MD5 aceptable: sumas de verificacion no criptograficas, claves de cache, deduplicacion, ETags HTTP.

SHA-256 requerido: firmas digitales, certificados, hashing de contrasenas, blockchain, firma de codigo, HMAC para autenticacion API.

Conclusion: En caso de duda, siempre elija SHA-256.

Mejores practicas de seguridad hash

Estas son las mejores practicas esenciales para desarrolladores:

Nunca hashee contrasenas con MD5/SHA-256 simple: Use bcrypt, scrypt o Argon2.

Use siempre sales: Una sal es un valor aleatorio unico anadido a la contrasena antes del hashing, previniendo ataques de tablas arcoiris.

Use HMAC para autenticacion de mensajes: HMAC-SHA256 es el estandar de la industria para autenticacion API.

Evite ataques de extension de longitud: Use HMAC en lugar de Hash(secret + message).

Compare hashes en tiempo constante: Use crypto.timingSafeEqual() en Node.js o hmac.compare_digest() en Python.

Preguntas frecuentes

Cual es la diferencia entre MD5 y SHA-256?

MD5 produce un hash de 128 bits y esta criptograficamente roto. SHA-256 produce un hash de 256 bits y permanece seguro. MD5 es mas rapido pero solo debe usarse para sumas de verificacion no de seguridad.

MD5 sigue siendo seguro?

MD5 NO es seguro para uso criptografico. Es aceptable para sumas de verificacion no de seguridad, claves de cache y deduplicacion.

Se puede revertir un hash?

No, las funciones hash son unidireccionales. Sin embargo, las contrasenas debiles pueden ser "descifradas" por fuerza bruta o tablas arcoiris. Use bcrypt o Argon2 para contrasenas.

Las funciones hash son un pilar fundamental de la informatica y la ciberseguridad. Use SHA-256 para seguridad, bcrypt/Argon2 para contrasenas y HMAC para autenticacion de mensajes.

Genere hashes MD5, SHA-1, SHA-256 y SHA-512 al instante con nuestra herramienta gratuita.