Inicio/Blog/Investigación de vulnerabilidades
Investigación de vulnerabilidadesPublicado · Actualizado ⚡ 15 min de lectura

Deja de dispararte en el pie. Así es como se escribe de verdad código seguro en 2026.

Un manual crudo y sin rodeos de prácticas de codificación segura. Validación de entrada con Zod, consultas parametrizadas, CSP y los patrones de seguridad del SDLC que probablemente estás ignorando.

VG
Vladyslav Gusarov
DevSecOps Lead en Bryxe
Prácticas de codificación segura: el manual del ingeniero senior [auditoría de 2026]

# Deja de entregar basura: el manual de 2026 para la codificación segura

Mira, estoy cansado. Reviso PR todo el día y sigo viendo los mismos errores de seguridad básicos que acaban en producción de la mano de ingenieros que deberían saber más. Tenemos IA que nos completa el código y, aun así, seguimos cayendo en vulnerabilidades de la época de 1999. El llamado ciclo de vida de desarrollo de software seguro (seguridad en el SDLC) en la mayoría de las organizaciones es un chiste. Es un ticket de Jira en el que alguien hace clic en «Done», mientras la concatenación de strings en crudo se cuela en la capa de base de datos.

En resumen: las prácticas de codificación segura ya no son opcionales. No puedes plantar un WAF delante de tu backend de Node.js hecho a trompicones y darlo por terminado. Este es el manual. Sigue estas directrices de codificación segura o sufrirás una brecha. Me da igual tu velocidad de sprint si estás comprometiendo activamente los datos de los usuarios.

1. Buenas prácticas de validación de entrada: Zod o nada

Veo muchas comprobaciones del tipo if (req.body.userId == null). Para. En serio, para. Eso no es validación de entrada. Es una plegaria. Necesitas validación estricta por esquema justo en los bordes de tu aplicación. Si no encaja con el esquema, fuera. Sin excepciones.

Estoy harto de ver esto en los PR. Aquí es donde las reglas de codificación segura de OWASP se encuentran con la realidad. Usamos Zod. ¿Por qué? Porque impone un tipado estricto y elimina la basura por debajo.

typescriptCódigo fuente
import { z } from 'zod';
import express from 'express';

const app = express();
app.use(express.json());

// Strict schema. No extra keys allowed.
const UserProfileSchema = z.object({
  username: z.string().min(3).max(30).regex(/^[a-zA-Z0-9_]+$/),
  email: z.string().email(),
  age: z.number().int().min(18).max(120),
}).strict();

app.post('/api/profile', (req, res) => {
  const result = UserProfileSchema.safeParse(req.body);
  
  if (!result.success) {
    // Log this internally, but give a generic 400 to the client
    console.error('Validation failed:', result.error.format());
    return res.status(400).json({ error: 'Invalid input data.' });
  }

  // result.data is now 100% typed and scrubbed
  const validData = result.data;
  // proceed to business logic
});

Si no haces esto, estás pidiendo a gritos una NoSQL injection o un prototype pollution. Los esquemas estrictos hacen que los atacantes se den contra un muro antes siquiera de llegar a tu lógica de negocio. Las buenas prácticas de validación de entrada son tu primera línea de defensa.

2. Consultas parametrizadas: la epidemia de SQLi sigue aquí

No puedo creer que tenga que escribir esto en 2026. Si usas interpolación de strings para las consultas SQL, deberían retirarte el acceso para hacer commits. Me da igual que sea una herramienta de administración interna. Las herramientas internas son la vía del movimiento lateral.

Mira esta porquería:

typescriptCódigo fuente
// DO NOT DO THIS. EVER.
const query = `SELECT * FROM users WHERE email = '${userEmail}'`;
db.query(query);

Mira, lo he visto cien veces. Así es como se hace de verdad con consultas parametrizadas. El driver de la base de datos se encarga del saneamiento. No intentes escaparlo tú mismo.

typescriptCódigo fuente
// GOOD: Using parameterized queries with pg (PostgreSQL)
const query = 'SELECT * FROM users WHERE email = $1';
const values = [userEmail];

try {
  const res = await db.query(query, values);
  return res.rows;
} catch (err) {
  // Generic error to the user
  throw new Error('Database operation failed');
}

Y si usas un ORM como Prisma o Drizzle, no uses sus atajos de consultas en crudo a menos que no te quede otra, e incluso entonces, usa los tagged template literals que ofrecen. La seguridad en el SDLC exige entradas parametrizadas en todas partes.

3. Codificación de la salida: acabar con el XSS para siempre

React y los frameworks modernos codifican por defecto, pero a los desarrolladores les encanta encontrar maneras de dispararse en el pie con dangerouslySetInnerHTML. Si renderizas entrada del usuario sin codificar la salida, tienes XSS.

Cuando no te quede más remedio que renderizar HTML en crudo (como con un parser de markdown), usa DOMPurify. Y hazlo en el servidor si es posible.

typescriptCódigo fuente
import DOMPurify from 'isomorphic-dompurify';

const rawHtml = getUserInput(); 
// Sanitize before it ever hits the DOM or gets saved to the DB
const cleanHtml = DOMPurify.sanitize(rawHtml, {
  ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'a'],
  ALLOWED_ATTR: ['href']
});

4. Cabeceras CSP: defensa en profundidad

Sinceramente, es una pesadilla. Configurar la Content Security Policy (CSP) es un dolor de cabeza. Lo entiendo. Tu script de analítica se rompe. Tu fuente deja de cargar. Pero es la red de seguridad definitiva contra el XSS. Si fallas en la codificación de la salida, la CSP impide que el payload se ejecute.

Usa Helmet en Express. Configura una CSP estricta.

typescriptCódigo fuente
import helmet from 'helmet';

app.use(
  helmet.contentSecurityPolicy({
    directives: {
      defaultSrc: ["'self'"],
      scriptSrc: ["'self'", "https://trusted.cdn.com"],
      objectSrc: ["'none'"],
      upgradeInsecureRequests: [],
    },
  })
);

No uses 'unsafe-inline'. Si tienes scripts inline, refactorízalos. Sí, cuesta trabajo. Hazlo de todos modos.

5. Configuración de CORS: deja de usar comodines

Veo Access-Control-Allow-Origin: * en los PR todo el tiempo. Es una enorme señal de alarma. Si tu API se autentica mediante cookies, una política de CORS abierta es un desastre a punto de ocurrir.

Sinceramente, es una pesadilla. Sé explícito.

typescriptCódigo fuente
import cors from 'cors';

const whitelist = ['https://app.bryxe.com', 'https://admin.bryxe.com'];
const corsOptions = {
  origin: function (origin, callback) {
    if (!origin || whitelist.indexOf(origin) !== -1) {
      callback(null, true)
    } else {
      callback(new Error('Not allowed by CORS'))
    }
  },
  credentials: true // Only if you actually need cookies
};

app.use(cors(corsOptions));

6. Gestión segura de sesiones

Los JWT no son una bala de plata. Si guardas un JWT en localStorage, cualquier vulnerabilidad XSS compromete la sesión de inmediato.

Usa cookies HttpOnly, Secure, SameSite=Strict.

typescriptCódigo fuente
app.post('/login', (req, res) => {
  // ... validate user ...
  const sessionId = generateSecureSessionId();
  
  res.cookie('sessionId', sessionId, {
    httpOnly: true, // No JS access
    secure: process.env.NODE_ENV === 'production', // HTTPS only
    sameSite: 'strict', // CSRF protection
    maxAge: 3600000 // 1 hour
  });
  
  res.json({ message: 'Logged in' });
});

7. Manejo de errores sin fugas de información

Cuando algo se rompe, tu stack trace nunca debe llegar al cliente. Nunca. Le dice a los atacantes exactamente qué versiones de qué librerías usas, las rutas absolutas de tu servidor y, a veces, incluso la estructura de la base de datos.

Estoy harto de ver esto en los PR. Captura los errores de forma global. Registra los detalles en tu SIEM. Devuelve un 500 genérico al usuario.

typescriptCódigo fuente
app.use((err, req, res, next) => {
  // Log the full stack trace internally
  logger.error('Unhandled Exception:', err);
  
  // Return generic response
  res.status(500).json({
    error: 'An unexpected error occurred. Please try again later.'
  });
});

8. Buenas prácticas criptográficas

Deja de inventarte tu propia criptografía. Deja de usar MD5 o SHA-1 para las contraseñas. Usa Argon2id o bcrypt. En 2026, Argon2id es el estándar.

typescriptCódigo fuente
import * as argon2 from 'argon2';

async function hashPassword(password: string) {
  try {
    return await argon2.hash(password, {
      type: argon2.argon2id,
      memoryCost: 2 ** 16,
      timeCost: 3,
      parallelism: 1,
    });
  } catch (err) {
    throw new Error('Hashing failed');
  }
}

Para el cifrado en reposo de PII, usa AES-256-GCM. Proporciona cifrado autenticado. No toques el modo ECB. No toques CBC sin HMAC. Usa GCM y olvídate.

Para cerrar

Mira, las prácticas de codificación segura no son magia. Son disciplina. Es negarse a hacer merge de PR chapuceros. Es integrar la seguridad del SDLC en tus pipelines con herramientas SAST/DAST para que estas cosas se detecten automáticamente.

Estoy harto de ver esto en los PR. Empieza hoy mismo a implementar estos patrones. Limpia tus esquemas de Zod. Arregla tu CORS. Elimina tus comodines. Tu rotación de guardias te lo agradecerá cuando no te llamen a las 3 de la madrugada por una filtración de datos.

DEFENSA AUTOMATIZADA

No esperes a un exploit para auditar tu código

Revisa los riesgos de código compatibles, los secretos expuestos y los hallazgos en dependencias con Bryxe Shield. Verifica las correcciones en tu aplicación antes del lanzamiento.

¿Necesitas un siguiente paso práctico? Explora las guías de seguridad o lee nuestra política editorial y de fuentes.

Investigación de seguridad recomendada