Herramientas de Seguridad y Cripto

Genera contraseñas seguras, hashes, HMAC, checksums y huellas SHA-256 de archivos en tu navegador. Gratis, privado y sin subidas.

100 % Privado • Sin cargas de archivos a servidores

¿Por qué usar Herramientas de Seguridad y Cripto gratis en Utiliome?

Diseñado para máxima privacidad, ejecución instantánea y sin fricción. Sin suscripciones ni registros.

Motor CSPRNG Web Crypto

Obtiene entropía criptográfica pura directamente de crypto.getRandomValues() del navegador, respaldada por el CSPRNG del kernel del sistema operativo en lugar del estado predecible de Math.random().

Selección de Palabras Diceware con CSPRNG

Extrae palabras aleatorias del diccionario de forma uniforme mediante Web Crypto crypto.getRandomValues() con muestreo por rechazo sin sesgo en lugar de frases humanas predecibles.

Matriz Simultánea de Cinco Algoritmos

Calcula MD5 de 128 bits (RFC 1321) junto con SHA-1 de 160 bits, SHA-256 de 256 bits, SHA-384 de 384 bits y SHA-512 de 512 bits (NIST FIPS 180-4) desde una sola cadena UTF-8 o búfer binario en una sola pasada.

API Nativa Web Crypto

Utiliza la aceleración por hardware de window.crypto.subtle para calcular checksums SHA-256 a la máxima velocidad de tu CPU.

Utiliome vs Alternativas en la nube tradicionales

Compara nuestro motor local en WebAssembly frente a herramientas en la nube.

Característica Utiliome (Navegador local) Convertidores en la nube tradicionales
Privacidad y Seguridad de Datos Cero cargas al servidor (Procesamiento en el navegador) Suben tus PDF confidenciales a servidores en la nube
Privacidad y Seguridad de Datos Cero cargas al servidor (Procesamiento en el navegador) Suben tus PDF confidenciales a servidores en la nube
Tamaño Máximo de Archivo Sin límites estrictos (limitado solo por la RAM) Límites estrictos de 10MB a 50MB
Privacidad y Seguridad de Datos Cero cargas al servidor (Procesamiento en el navegador) Suben tus PDF confidenciales a servidores en la nube
Cómo funciona

Cómo usar Herramientas de Seguridad y Cripto en 3 sencillos pasos

Sin instalación de software. Todo funciona directamente dentro de tu navegador web.

1

Define Longitud y Clases de Caracteres

Selecciona una longitud entre 4 y 128 caracteres y activa mayúsculas (A-Z), minúsculas (a-z), dígitos (0-9) y símbolos ASCII imprimibles según las restricciones de tu sistema destino.

2

Configura Exclusiones y Cantidad por Lote

Activa el filtrado de caracteres ambiguos (0/O, 1/l/I) para facilitar la transcripción manual o aumenta el tamaño del lote para generar múltiples secretos independientes simultáneamente.

3

Audita los Bits de Entropía y Copia

Verifica la lectura en vivo de entropía combinatoria y de Shannon en bits frente a tu umbral de seguridad (128+ bits para credenciales de producción) y cópiala localmente.

Generación de Contraseñas CSPRNG de Alta Entropía: Configuración y Ejemplos

Respuesta rápida: Adapta los conjuntos de caracteres y la longitud (de 4 a 128 caracteres) a la forma en que se almacena y procesa el secreto. Usa 24+ caracteres ASCII completos para gestores de contraseñas, 32+ caracteres alfanuméricos para cadenas de conexión URI y archivos .env con el fin de evitar errores de escape de delimitadores, y cadenas filtradas sin homoglifos para ingreso manual en consola.

Los distintos entornos de ejecución imponen restricciones estrictas de análisis sintáctico (parsing) sobre las credenciales. Seleccionar el mayor conjunto seguro de caracteres N y escalar la longitud L te permite alcanzar los márgenes objetivo de entropía en bits sin provocar interpolaciones de shell ni fallos en el analizador de URI.

Perfil 1: Secreto para Bóveda de Gestor de Contraseñas (ASCII Imprimible Completo)

Al almacenar credenciales dentro de una bóveda cifrada (1Password, Bitwarden, KeePassXC o HashiCorp Vault) para autocompletado de formularios o cabeceras de API, habilita las cuatro clases de caracteres (A-Z, a-z, 0-9 y 32 símbolos de puntuación ASCII, N = 94) con una longitud L = 24:

Configuration : Length = 24 | Upper + Lower + Digits + Symbols (N = 94) | Exclude Ambiguous = Off
Output        : v9#Km!2pQ@7xR$4nL^8wZ&5j
Pool Entropy  : 24 * log2(94) = 157.31 bits
Search Space  : 94^24 = 2.26e+47 combinations

Perfil 2: Credencial de Servicio Segura para URI y Shell (Solo Alfanumérica)

Los DSN de bases de datos (postgres://user:password@db.internal:5432/app) y los archivos .env de Docker suelen fallar cuando las contraseñas contienen delimitadores URI reservados por el RFC 3986 (:, /, ?, #, [, ], @) o tokens de expansión de shell ($, `, ", ', \). Desactivar los símbolos (N = 62) y ampliar la longitud a L = 32 proporciona mayor entropía que una contraseña de 24 caracteres con símbolos, sin ningún riesgo de escape:

Configuration : Length = 32 | Upper + Lower + Digits (N = 62) | Symbols = Off
Output        : 8fKp3mQv9xRt2nLw7zJc4bYh6dGs5aPe
Pool Entropy  : 32 * log2(62) = 190.53 bits
Search Space  : 62^32 = 2.27e+57 combinations

Perfil 3: Códigos Break-Glass por Lotes (Excluyendo Caracteres Ambiguos)

Para consolas fuera de banda IPMI/iLO o planillas de recuperación ante desastres donde un ingeniero debe leer caracteres en pantalla con fuentes monoespaciadas o proporcionales, activa la exclusión de ambiguos (0, O, 1, l, I eliminados de N = 62, dejando N = 57) y genera un lote:

Configuration : Length = 20 | Upper + Lower + Digits | Exclude Ambiguous (0/O, 1/l/I) = On (N = 57) | Bulk = 3
Outputs       :
  1. 7mKp4xQv9nRw3zJc8bYh
  2. 5dGs2fPe6tMa9kVu4wNx
  3. 3hBz8qJr7cLy2pWt6gKm
Pool Entropy  : 20 * log2(57) = 116.66 bits per credential
Característica ISO 32000 / WebAssembly / Web Crypto Utiliome (Navegador local)
Generador de contraseñas seguras Web Crypto CSPRNG (getRandomValues) Genera contraseñas aleatorias complejas y seguras en tu dispositivo.
Contraseñas memorables Cryptographic Diceware Passphrases Crea contraseñas seguras y fáciles de recordar con Diceware.
Generador de hashes SHA-256 / SHA-512 / SHA-1 (FIPS 180-4) Genera hashes criptográficos seguros (SHA-256, SHA-512) desde texto.
Generador HMAC Keyed-Hash HMAC (RFC 2104 / FIPS 198-1) Genera y verifica códigos HMAC (HMAC-SHA256, HMAC-SHA512) en local.
Calculadora de checksum Multi-Hash Binary File Fingerprinting Calcula hashes SHA-1, SHA-256, SHA-384 y SHA-512 de archivos en local.
SHA256 de archivo Local Multi-GB SHA-256 Verification Calcula y verifica el hash SHA-256 de cualquier archivo en local.

Creación de Frases de Contraseña Diceware: Cantidad de Palabras, Delimitadores y Ejemplos

Respuesta rápida: Una frase de contraseña de 6 palabras extraída uniformemente de un diccionario Diceware de 7.776 palabras proporciona 77,55 bits de entropía criptográfica, manteniendo la facilidad para memorizarla y escribirla a ciegas. Añadir un dígito y un símbolo aleatorios eleva la fortaleza total por encima de los 85 bits y supera los estrictos validadores empresariales de clases de caracteres.

La memoria humana tiene dificultades para retener 16 glifos ASCII aleatorios (v9#Km!2pQ@7xR$4n), pero retiene fácilmente de 5 a 7 palabras concretas organizadas como imágenes mentales. Usar un CSPRNG para elegir palabras de forma independiente preserva una seguridad matemática estricta al tiempo que optimiza la ergonomía de escritura.

Perfil 1: Clave Maestra de Gestor de Contraseñas y Cifrado de Disco Completo (LUKS2 / FileVault)

Durante las solicitudes de cifrado de disco completo previas al arranque (LUKS2, VeraCrypt, FileVault), el pegado desde el portapapeles no está disponible y las distribuciones de teclado distintas a la estadounidense pueden desplazar los signos de puntuación con la tecla Shift. Seis palabras en minúsculas separadas por guiones sobre un diccionario Diceware estándar de 7.776 palabras eliminan los errores tipográficos con la tecla Shift y ofrecen una resistencia masiva ante ataques KDF sin conexión:

Configuración      : 6 Palabras | Separador = Guion (-) | Formato = minúsculas | Extras = Desactivado
Salida             : lantern-cobalt-harvest-velvet-orbit-spruce
Entropía Palabras  : 6 * log2(7776) = 77.55 bits
Espacio Búsqueda   : 7776^6 = 2.21e+23 combinaciones

Perfil 2: Cumplimiento de Políticas Corporativas de SSO y Active Directory

Muchas políticas corporativas de IAM y Active Directory aplican comprobaciones mediante expresiones regulares que exigen mayúsculas, minúsculas, un dígito [0-9] y un símbolo. Aplicar Formato Título con delimitadores de guion bajo o punto más un dígito extraído por CSPRNG (+3,32 bits) y un símbolo CSPRNG (por ejemplo, de un conjunto de 32 símbolos, +5,00 bits) satisface limpiamente los validadores heredados:

Configuración  : 5 Palabras | Separador = Punto (.) | Formato = Tipo Título | Añadir Dígito + Símbolo = Activado
Salida         : Glacier.Badger.Summit.Quartz.Anchor.7#
Entropía Total : (5 * 12.925) + log2(10) + log2(32) = 72.95 bits

Perfil 3: Clave Maestra GPG Aislada (Air-Gapped) o Passphrase de CA Raíz

Para raíces de confianza criptográficas sin conexión de larga duración (claves de certificación OpenPGP, claves en frío age/SSH o extensiones de frase de contraseña BIP-39 en billeteras de hardware), escala a 7 u 8 palabras separadas por espacios:

Configuración      : 8 Palabras | Separador = Espacio ( ) | Formato = minúsculas | Extras = Desactivado
Salida             : canyon timber falcon magnet fossil harbor meadow quartz
Entropía Palabras  : 8 * log2(7776) = 103.40 bits
Espacio Búsqueda   : 7776^8 = 1.34e+31 combinaciones

¿Qué es un Checksum de Archivo SHA-256?

Respuesta rápida: Un checksum de archivo SHA-256 es un digest hexadecimal único de 64 caracteres que representa el contenido binario exacto de un archivo. Funciona como una huella digital para garantizar que los archivos no estén corruptos ni alterados.

SHA-256 (Secure Hash Algorithm 256-bit) es un miembro de la familia SHA-2 definida por el NIST. Produce un valor de hash fijo de 256 bits (32 bytes), representado habitualmente como una cadena hexadecimal de 64 caracteres.

  Debido al *Efecto Avalancha* criptográfico, cambiar un solo byte o bit en un archivo de varios gigabytes generará una salida SHA-256 completamente diferente. Esto convierte a SHA-256 en el estándar de oro para verificar descargas de software, imágenes ISO de sistemas operativos y copias de seguridad de bases de datos.

Cálculo y Verificación de Firmas HMAC en Webhooks y APIs: Guía Práctica

Respuesta rápida: Firmar el mensaje what do ya want for nothing? con el secreto de 4 bytes Jefe (Caso de Prueba 2 de IETF RFC 4231) bajo HMAC-SHA256 produce 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 en Hex y W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= en Base64 en los modos de clave UTF-8, Hex (4a656665) y Base64 (SmVmZQ==).

Un Código de Autenticación de Mensajes Basado en Hash con Clave (HMAC) demuestra tanto la integridad de los datos (el payload no fue alterado en tránsito) como la autenticidad (el remitente posee la clave secreta compartida). Reproducir la firma de un proveedor requiere hacer coincidir tres parámetros exactos: la primitiva hash subyacente, la decodificación en bytes puros de la clave secreta y la secuencia exacta de bytes del payload firmado.

Ejemplo 1: Caso de Prueba 2 de IETF RFC 2104 / RFC 2202 / RFC 4231

Ya sea que introduzcas la clave secreta de 4 bytes como texto UTF-8 Jefe, hexadecimal puro 4a656665 o Base64 SmVmZQ==, se decodifica al mismo búfer de clave [0x4a, 0x65, 0x66, 0x65]. Firmar el mensaje UTF-8 de 28 bytes what do ya want for nothing? produce:

{
  "keyUtf8": "Jefe",
  "keyHex": "4a656665",
  "keyBase64": "SmVmZQ==",
  "message": "what do ya want for nothing?",
  "signatures": {
    "hmac_md5_hex": "750c783e6ab0b503eaa86e310a5db738",
    "hmac_sha1_hex": "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
    "hmac_sha256_hex": "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
    "hmac_sha256_base64": "W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM=",
    "hmac_sha256_base64url": "W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM",
    "hmac_sha384_hex": "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649",
    "hmac_sha512_hex": "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"
  }
}

Ejemplo 2: Base64 vs Base64URL y Payloads Canónicos de Webhooks

El formato Base64 estándar (RFC 4648 Sección 4) emite +, / y relleno final =, mientras que Base64URL seguro para URL (RFC 4648 Sección 5, utilizado en firmas JWS/JWT y URLs firmadas) sustituye + por -, / por _ y elimina el relleno =. Firmar The quick brown fox jumps over the lazy dog con la clave UTF-8 key bajo HMAC-SHA256 ilustra directamente la diferencia de codificación:

Key (UTF-8):     key
Message (UTF-8): The quick brown fox jumps over the lazy dog

HMAC-SHA256 Hex:       f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8
HMAC-SHA256 Base64:    97yD9DBThCSxMpjmqm+xQ+9NWaFJRhdZl0edvC0aPNg=
HMAC-SHA256 Base64URL: 97yD9DBThCSxMpjmqm-xQ-9NWaFJRhdZl0edvC0aPNg

Al verificar cabeceras de webhooks reales, construye el payload exacto previo a la firma definido por cada proveedor antes de eliminar los prefijos de la cabecera:

GitHub (X-Hub-Signature-256: sha256=<hex>):
  Signed input = <raw_http_body>

Stripe (Stripe-Signature: t=1730419200,v1=<hex>):
  Signed input = 1730419200.<raw_http_body>

Slack (X-Slack-Signature: v0=<hex>):
  Signed input = v0:1730419200:<raw_http_body>

Shopify (X-Shopify-Hmac-Sha256: <base64>):
  Signed input = <raw_http_body>
Preguntas frecuentes

Preguntas frecuentes y guía técnica de Herramientas de Seguridad y Cripto

Todo lo que necesitas saber sobre el uso gratuito en línea de generador de contraseñas y hashes sha256 en Utiliome.

¿Por qué debería desactivar los símbolos para cadenas de conexión de bases de datos y archivos .env?

El RFC 3986 reserva caracteres como :, /, ?, #, [, ], @ y % como delimitadores estructurales de URI, mientras que las shells POSIX y los cargadores de .env interpretan $, comillas invertidas (backticks), comillas, # y \ como expansiones de variables, comentarios o secuencias de escape. Generar una contraseña alfanumérica de 32 caracteres (A-Z, a-z, 0-9, N = 62) produce 190.53 bits de entropía —más fuerte que una contraseña de 24 caracteres con símbolos (157.31 bits)— eliminando al mismo tiempo los fallos de análisis sintáctico y codificación de URL en Kubernetes Secrets, Terraform y controladores JDBC/libpq.

Si la lista de palabras es pública, ¿no puede un atacante descifrar mi passphrase con un ataque de diccionario?

Incluso cuando un atacante carga el diccionario exacto de 7.776 palabras en Hashcat en modo combinador, la selección uniforme mediante CSPRNG lo obliga a buscar en cada combinación W^k. Para una frase de contraseña de 6 palabras, 7.776^6 equivale a 2,21 x 10^23 candidatos equiprobables (77,55 bits), exactamente la misma barrera computacional que una clave binaria pura de 77,5 bits, con cero patrones gramaticales para tomar atajos.

¿Por qué el comando echo "text" | sha256sum en mi terminal devuelve un hash diferente al que obtengo al pegar text aquí?

Por defecto, echo añade un carácter de salto de línea final (<LF>, byte 0x0a) a tu cadena, por lo que echo "abc" en realidad calcula el hash de la secuencia de 4 bytes 61 62 63 0a en lugar de la cadena de 3 bytes 61 62 63. Ejecuta printf '%s' 'abc' | sha256sum (o echo -n 'abc' | sha256sum) en tu consola para omitir el salto de línea final y coincidir exactamente con los resúmenes de cadenas UTF-8.

¿Por qué falla la verificación HMAC de mi webhook incluso cuando mi clave secreta y los campos JSON parecen idénticos?

Dos problemas causan más del 90 % de los fallos de coincidencia de HMAC en webhooks. Primero, middlewares como express.json() de Express analizan y vuelven a serializar el JSON, alterando los espacios en blanco, el escape Unicode o el orden de las claves con respecto al flujo de bytes TCP crudo que firmó el remitente; firma siempre el búfer crudo sin analizar de la petición e incluye los prefijos de marca de tiempo del proveedor (como <timestamp>.<body> de Stripe o v0:<timestamp>:<body> de Slack). Segundo, comprueba si el secreto del proveedor debe decodificarse desde Base64 o Hex a bytes puros en lugar de leerse como una cadena UTF-8.

¿Qué es un checksum y por qué es importante?

Un checksum es una cadena alfanumérica única generada al aplicar un algoritmo criptográfico al contenido de un archivo. Funciona como una huella digital: si cambia un solo byte del archivo, el checksum resultante cambia drásticamente. Es importante porque permite verificar que el archivo descargado sea exactamente igual al original, garantizando que no se ha corrompido ni infectado con malware.

¿Se suben mis archivos a algún servidor?

No. Todo el cálculo se realiza localmente dentro de la memoria de tu navegador utilizando la Web Crypto API nativa.