# Calculadora de Hashes CSP

> Una página de jmrp.io, publicada como markdown. Índice: https://jmrp.io/llms.txt

Canonical: https://jmrp.io/es/tools/hash-calculator/
Language: es
Alternate: https://jmrp.io/tools/hash-calculator/index.md
Updated: 2026-08-23
License: https://jmrp.io/es/license/
Category: security
Tags: csp, hash, sha256, seguridad, sri

Genera hashes SHA-256 para scripts inline. Obtén directivas CSP listas para usar en tu Content Security Policy. Todo en el navegador.
Build-Date: 2026-09-06

Características:
- Cálculo SHA-256 en tiempo real mientras escribes
- Admite SHA-256, SHA-384 y SHA-512
- Genera directivas script-src CSP listas para usar
- Limpieza opcional de espacios antes del hash
- Web Crypto API, el contenido nunca se envía a un servidor

Preguntas que responde:

**¿Cuándo debo usar un hash CSP en lugar de un nonce?**

Usa un hash para scripts o estilos inline cuyo contenido nunca cambia, así puedes permitirlos sin "unsafe-inline". Si el script contiene valores dinámicos como un ID de usuario, usa un nonce, porque cualquier cambio en el contenido invalida el hash.

**¿Por qué mi script inline se sigue bloqueando tras añadir el hash?**

Los hashes CSP requieren una coincidencia exacta byte a byte, así que incluso un espacio o salto de línea de más genera un hash distinto y el navegador bloquea el script. Asegúrate de calcular el hash solo del contenido interno, sin las etiquetas "<script>" o "<style>".

**¿Cuál es la diferencia entre un hash CSP y un hash SRI?**

Un hash CSP (SHA-256 en base64) autoriza código inline específico en tu Content Security Policy. Un hash SRI (normalmente SHA-384) va en el atributo "integrity" de una etiqueta script o link externa para verificar que el archivo descargado no ha sido manipulado.

**¿Se envía el contenido de mi script a un servidor?**

No. Todo el cálculo del hash se ejecuta localmente en tu navegador mediante la Web Crypto API, por lo que el contenido de tu script o estilo nunca se transmite por la red.

**¿Qué algoritmo de hash debo elegir?**

SHA-256 es la opción estándar y más compatible para CSP. SHA-384 y SHA-512 también son válidos y se usan habitualmente para Subresource Integrity, pero SHA-256 basta para casi todos los casos de uso de CSP.


---

**Herramienta interactiva** — esta página contiene la aplicación en funcionamiento, no una descripción de ella.

## Acerca de esta herramienta

Cuando necesitas permitir scripts o estilos inline específicos en tu Content Security Policy (CSP) sin usar `'unsafe-inline'`, puedes utilizar hashes criptográficos. Esta herramienta calcula el hash SHA-256 de tu contenido en el formato base64 exacto que esperan los navegadores.

### Características

- **Cálculo en tiempo real** — el hash se actualiza al instante mientras escribes o pegas
- **Varios algoritmos** — admite SHA-256, SHA-384 y SHA-512
- **Directivas listas para usar** — obtén la cadena `'sha256-...'` completa o la línea `script-src` entera
- **Limpieza automática** — elimina los espacios y saltos de línea sobrantes al principio y al final, si lo activas
- **Solo en el cliente** — tus scripts sensibles nunca se envían a un servidor

### ¿Por qué usar hashes en CSP?

Los hashes proporcionan una forma segura de permitir scripts inline específicos
sin abrir la puerta a ataques XSS. Cada hash es único para su contenido exacto,
lo que garantiza que solo se ejecuten los scripts autorizados.

### ¿Cómo se usa esta herramienta?

1. Pega el contenido de tu script o estilo inline (sin las etiquetas `<script>` o `<style>`)
2. Copia el hash generado o la directiva CSP completa
3. Añade el hash a tu directiva `script-src` o `style-src` en la configuración de Nginx/Apache o en la etiqueta meta

### Notas importantes

- **Coincidencia exacta** — cualquier cambio en el script (hasta un solo espacio o salto de línea) produce un hash completamente distinto y hace que el navegador bloquee el script.
- **Sin etiquetas** — no incluyas las etiquetas HTML `<script>` ni `<style>`, solo el contenido interior.
- **Scripts dinámicos** — si tu script contiene valores dinámicos (como un ID de usuario), los hashes no sirven. Considera usar [nonces](https://jmrp.io/es/blog/003-implementing-content-security-policy-nginx/#solución-3-usar-nonces) en su lugar.
- Consulta [la guía completa de CSP](https://jmrp.io/es/blog/003-implementing-content-security-policy-nginx/) para conocer las buenas prácticas

### Privacidad

La seguridad es la prioridad. Todas las operaciones criptográficas se realizan
localmente en tu navegador mediante la Web Crypto API. El contenido de tus
scripts nunca se transmite por la red.

### Referencia de comandos en Linux

También puedes calcular estos hashes a mano en tu terminal con utilidades
estándar de Linux.

#### SHA-256 para CSP

```bash
echo -n 'console.log("Hello CSP");' | openssl dgst -sha256 -binary | openssl base64
```

**Salida del hash SHA-256 en base64**

```text
7fJ6A1b9qS8r...[hash]...=
```

#### SHA-384 para SRI (Subresource Integrity)

```bash
cat script.js | openssl dgst -sha384 -binary | openssl base64 -A
```

**Salida del hash SHA-384 en base64**

```text
Nkhj...[base64 hash]...
```