¿Cuáles son las prácticas clave de seguridad para una aplicación Node.js?

Question

IT Interview Practice · Accepted Answer

Asegurar una aplicación Node implica defenderse de vulnerabilidades web comunes (el OWASP Top 10) en múltiples capas: manejo de entrada, autenticación, dependencias y configuración. La seguridad es por capas (defensa en profundidad), no una única corrección.

## 1. Valida y sanea toda la entrada

```js
import { z } from "zod";
// nunca confíes en la entrada del cliente — valida forma/tipo antes de usarla
const schema = z.object({ email: z.string().email(), age: z.number().min(0) });
const data = schema.parse(req.body); // rechaza entrada malformada/maliciosa
```

## 2. Previene inyecciones (SQL, NoSQL, comandos)

```js
// ❌ concatenación de strings → inyección SQL
db.query(`SELECT * FROM users WHERE id = ${req.params.id}`);
// ✅ consultas parametrizadas — la entrada es dato, nunca SQL ejecutable
db.query("SELECT * FROM users WHERE id = $1", [req.params.id]);
```

Usa siempre consultas parametrizadas / un ORM, y nunca construyas comandos a partir de la entrada del usuario (ver inyección de comandos con `child_process`).

## 3. Autenticación y secretos

```text
✓ Hashea contraseñas con bcrypt/argon2/scrypt (lento + con salt) — nunca en texto plano/SHA
✓ Almacena secretos en variables de entorno, nunca en el código/git
✓ Usa cookies httpOnly, secure, sameSite para sesiones (resistentes a XSS)
✓ Firma/verifica JWTs correctamente; mantén los tokens de corta duración
```

## 4. Configura cabeceras de seguridad y rate-limiting

```js
import helmet from "helmet";
import rateLimit from "express-rate-limit";

app.use(helmet()); // establece cabeceras HTTP seguras (CSP, HSTS, X-Frame-Options, etc.)
app.use(rateLimit({ windowMs: 60_000, max: 100 })); // limita abuso/fuerza bruta
```

`helmet` agrega cabeceras protectoras; el rate limiting defiende contra ataques de fuerza bruta y DoS.

## 5. Mantén las dependencias seguras (cadena de suministro)

```bash
npm audit          # revisa los paquetes instalados en busca de vulnerabilidades conocidas
npm audit fix
# + mantén las deps actualizadas; revisa los scripts postinstall; fija versiones con el lockfile
```

La mayor parte del código Node son paquetes de terceros; las dependencias vulnerables son un vector de ataque importante. Audita y actualiza con regularidad.

## 6. Otros aspectos esenciales

```text
✓ Usa HTTPS (TLS) en todas partes; redirige HTTP → HTTPS
✓ No filtres detalles de errores/stack traces a los clientes en producción
✓ Escapa la salida para prevenir XSS (los frameworks suelen hacerlo)
✓ Implementa autorización adecuada (no solo autenticación) — verifica permisos por acción
✓ Configura CORS con una allowlist, no "*" para APIs con credenciales
✓ Limita el tamaño del cuerpo de la solicitud para prevenir DoS basado en payload
```

## Por qué es importante

Las aplicaciones web son blancos constantes, y las aplicaciones Node están expuestas a todo el rango de vulnerabilidades web: inyección, autenticación rota, XSS, dependencias vulnerables, mala configuración.

Ninguna medida individual es suficiente; la seguridad es **por capas**: valida la entrada, parametriza las consultas, hashea las contraseñas correctamente, gestiona los secretos de forma segura, configura cabeceras protectoras, aplica rate-limiting, audita dependencias y usa HTTPS.

Comprender estas prácticas (y los riesgos OWASP detrás de ellas) es una responsabilidad esencial para quien construye servicios Node de producción: una sola capa descuidada (una inyección, un secreto filtrado, una dependencia sin parchear) puede comprometer todo el sistema.

1. Valida y sanea toda la entrada

2. Previene inyecciones (SQL, NoSQL, comandos)

3. Autenticación y secretos

4. Configura cabeceras de seguridad y rate-limiting

5. Mantén las dependencias seguras (cadena de suministro)

6. Otros aspectos esenciales

Por qué es importante

Preguntas relacionadas