Conceptos Básicos de Seguridad

8 ejemplos para empezar con la Seguridad para backends de Node.js: 6 básicos y 2 intermedios.

Prerrequisitos

npm install zod express@5 helmet
npm install -D typescript@5.6 tsx

Los servicios de Node.js se enfrentan a entradas no confiables de cuerpos HTTP, cadenas de consulta, encabezados, archivos subidos, webhooks y variables de entorno cargadas al inicio.

Ejemplos Básicos

1. Valida los Cuerpos de Solicitud con Zod

Rechaza la entrada mal formada antes de que llegue a la lógica de negocio.

import { z } from "zod";
 
const CreateUserSchema = z.object({
  email: z.string().email(),
  name: z.string().min(1).max(120),
});
 
type CreateUser = z.infer<typeof CreateUserSchema>;
 
function parseCreateUser(body: unknown): CreateUser {
  return CreateUserSchema.parse(body);
}

• parse lanza un error con datos inválidos; mapea a HTTP 400 en tu manejador de errores.
• unknown para body fuerza la validación; nunca confíes solo en el tipado de req.body desde el middleware.
• Mantén los esquemas junto a las definiciones de ruta o en un módulo schemas/ compartido.

Relacionado: OWASP Top 10 para APIs - API1 autorización a nivel de objeto rota

2. Nunca Confíes en los Parámetros de Consulta

Los IDs y filtros de la URL están controlados por el atacante.

import { z } from "zod";
 
const ListQuerySchema = z.object({
  page: z.coerce.number().int().min(1).default(1),
  limit: z.coerce.number().int().min(1).max(100).default(20),
});
 
function parseListQuery(query: Record<string, unknown>) {
  return ListQuerySchema.parse(query);
}

• z.coerce maneja los valores de cadena de consulta de Express/Fastify.
• Limita limit para prevenir DoS a través de ?limit=999999.
• La autorización aún debe verificar que el llamador puede acceder a las filas devueltas.

Relacionado: Paginación y Filtrado - parámetros de lista acotados

3. Carga los Secretos del Entorno, No del Código

Las claves API en el historial de git son para siempre.

import { z } from "zod";
 
const EnvSchema = z.object({
  JWT_SECRET: z.string().min(32),
  DATABASE_URL: z.string().url(),
});
 
export const env = EnvSchema.parse(process.env);

• parse al inicio falla las implementaciones tempranamente cuando faltan secretos.
• Los secretos de producción provienen de vault/SSM/k8s Secrets, no de .env en la imagen.
• Nunca registres env o process.env en los banners de inicio.

Relacionado: Conceptos Básicos de Configuración - configuración de doce factores

4. Establece Encabezados de Seguridad con Helmet

Los encabezados predeterminados reducen el riesgo de XSS, clickjacking y MIME sniffing.

import express from "express";
import helmet from "helmet";
 
const app = express();
app.use(helmet());
app.disable("x-powered-by");

• helmet() establece valores predeterminados sensatos para encabezados comunes.
• disable("x-powered-by") elimina la huella digital del framework.
• Ajusta CSP según las necesidades del frontend; los valores predeterminados estrictos pueden romper los scripts en línea.

Relacionado: Encabezados de Seguridad y CORS - reglas CORS de credenciales

5. Autentica Antes de Autorizar

Las comprobaciones de identidad y permisos son pasos separados.

type AuthUser = { id: string; role: "admin" | "member" };
 
function requireAuth(user: AuthUser | undefined): AuthUser {
  if (!user) throw new HttpError(401, "Unauthorized");
  return user;
}
 
function requireAdmin(user: AuthUser): void {
  if (user.role !== "admin") throw new HttpError(403, "Forbidden");
}

• 401 = no autenticado; 403 = autenticado pero no permitido.
• Verifica la propiedad del recurso (user.id === resource.ownerId) en cada acceso al objeto.
• El middleware puede adjuntar user; los manejadores aún verifican el acceso a nivel de objeto.

Relacionado: Reglas de Seguridad - reglas HTTP básicas

6. Sanea los Errores de Salida

Las trazas de pila pertenecen a los registros, no a las respuestas JSON.

import express from "express";
import pino from "pino";
 
class HttpError extends Error {
  constructor(public status: number, message: string) {
    super(message);
  }
}
 
const logger = pino({ level: "info" });
const app = express();
 
app.use((err: unknown, req: express.Request, res: express.Response, _next: express.NextFunction) => {
  const status = err instanceof HttpError ? err.status : 500;
  const message = status < 500 ? (err as Error).message : "Internal Server Error";
  logger.error({ err, path: req.path }, "request_error");
  res.status(status).json({ error: message });
});

• Las respuestas 5xx usan mensajes genéricos; los detalles ayudan a los atacantes.
• Registra el err completo con el serializador Pino { err } para las trazas de pila.
• Mapea ZodError de Zod a 400 con rutas de campo, no mensajes internos.

Relacionado: Estándares de Respuesta de Errores - errores de API consistentes

Ejemplos Intermedios

7. Bloquea SSRF en URLs Suministradas por el Usuario

La obtención de URLs arbitrarias permite el acceso a servicios de metadatos internos.

import { lookup } from "node:dns/promises";
import ipaddr from "ipaddr.js";
 
async function assertPublicUrl(raw: string): Promise<URL> {
  const url = new URL(raw);
  if (!["http:", "https:"].includes(url.protocol)) throw new Error("Invalid protocol");
  const { address } = await lookup(url.hostname);
  const parsed = ipaddr.parse(address);
  const range = parsed.range();
  if (range !== "unicast") throw new Error("Blocked IP range");
  return url;
}

• Resuelve DNS antes de la obtención; los atacantes usan el re-binding de DNS si solo verificas el nombre de host.
• Bloquea rangos privados, de bucle invertido y de enlace local.
• Permite dominios cuando el conjunto de integración es conocido (socios de webhook).

Relacionado: Protecciones SSRF - implementación completa de la protección

8. Fusión Segura de Objetos Sin Contaminación de Prototipos

La fusión profunda de JSON no confiable puede contaminar Object.prototype.

function safeAssign<T extends Record<string, unknown>>(
  target: T,
  source: unknown
): T {
  if (source === null || typeof source !== "object" || Array.isArray(source)) {
    throw new Error("Invalid merge source");
  }
  for (const key of Object.keys(source as object)) {
    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
    (target as Record<string, unknown>)[key] = (source as Record<string, unknown>)[key];
  }
  return target;
}

• Nunca Object.assign(target, req.body) sin filtrar claves en entradas no confiables.
• Prefiere parse de Zod sobre la fusión profunda para dar forma a las solicitudes.
• Fija las versiones de lodash y evita _.merge en JSON de usuario.

Relacionado: Contaminación de Prototipos - riesgos de lodash y merge

Versiones de la pila: Esta página fue escrita para Node.js 24.18.0 (LTS Activo), npm 10+, TypeScript 5.6+, Express 5, Fastify 5 y NestJS 11.