Ir al contenido principal

JavaScript / TypeScript · SAST

SAST JavaScript y TypeScript que se ejecuta totalmente sin conexión

Audite sus backends Node.js y frameworks front-end (React, Vue, Angular, Svelte) contra XSS, prototype pollution, fallos de inyección y riesgos supply-chain — sin subir una sola línea a la nube.

Frameworks y librerías escaneados

Probamos la cobertura mediante fixtures en estos frameworks. Se añaden nuevos patrones en cada release de reglas integradas.

Express Fastify Next.js Nuxt NestJS Hapi React Vue Angular Svelte Mongoose Sequelize Prisma TypeORM Knex jsonwebtoken cookie-parser

Principales clases CWE detectadas

Estas clases CWE aparecen con mayor frecuencia en bases de código modernas de este lenguaje. StaticCodeAudit incluye reglas dedicadas para cada una, mapeadas a OWASP Top 10 / ISO 27001 / ASVS cuando es pertinente.

CWE-79

Cross-Site Scripting (XSS)

innerHTML, dangerouslySetInnerHTML en React, v-html en Vue, Angular bypassSecurityTrust* con datos de usuario. Variantes stored, reflected y DOM-based cubiertas.

Detectado por la regla SCA: xss_innerhtml

CWE-1321

Prototype Pollution

Object.assign recursivo, _.merge, o obj[key] = value sin protección cuando key viene del usuario. Una sola clave __proto__ puede romper todos los objetos derivados.

Detectado por la regla SCA: prototype_pollution

CWE-89

Inyección SQL

Sequelize.literal(), queries raw en Prisma $queryRaw\`${input}\`, Mongoose $where con strings, Knex .raw() con concat.

Detectado por la regla SCA: sql_injection_concat

CWE-918

SSRF

axios.get(url), fetch(url), http.get en URLs de usuario. Particularmente peligroso en serverless vía endpoints metadata internos.

Detectado por la regla SCA: taint_ssrf

CWE-798

Credenciales hardcoded

API keys commiteadas en .env.example, config.js, o React process.env.REACT_APP_* expuesto al bundle cliente.

Detectado por la regla SCA: hardcoded_secret

CWE-915

Mass Assignment

User.update(req.body) sin allow-list de campos. Permite escalada de privilegios (isAdmin: true) vía body JSON.

Detectado por la regla SCA: mass_assignment

Vulnerable vs. seguro — tres ejemplos rápidos

CWE-79 Detectado por la regla SCA: xss_innerhtml
❌ Vulnerable
// Vulnerable — React dangerouslySetInnerHTML
function Bio({ user }) {
    return <div dangerouslySetInnerHTML={{ __html: user.bio }} />;
}
✅ Seguro
// Seguro — contenido texto, sin interpretación HTML
function Bio({ user }) {
    return <div>{user.bio}</div>;
}
CWE-1321 Detectado por la regla SCA: prototype_pollution
❌ Vulnerable
// Vulnerable — deep merge sin guard proto
function merge(target, source) {
    for (const key in source) {
        if (typeof source[key] === "object") {
            merge(target[key] = target[key] || {}, source[key]);
        } else { target[key] = source[key]; }
    }
}
✅ Seguro
// Seguro — bloquea __proto__/constructor
function merge(target, source) {
    for (const key of Object.keys(source)) {
        if (key === "__proto__" || key === "constructor") continue;
        if (typeof source[key] === "object") {
            merge(target[key] = target[key] || {}, source[key]);
        } else { target[key] = source[key]; }
    }
}
CWE-89 Detectado por la regla SCA: sql_injection_concat
❌ Vulnerable
// Vulnerable — concat en Sequelize.literal
const users = await User.findAll({
    where: sequelize.literal(`name = \'${req.query.name}\'`)
});
✅ Seguro
// Seguro — parámetro bind
const users = await User.findAll({
    where: { name: req.query.name }
});

Qué detecta StaticCodeAudit (este lenguaje)

  • XSS en React dangerouslySetInnerHTML, Vue v-html, Angular trust bypass, vanilla innerHTML
  • Prototype pollution vía deep merge, asignación dinámica de clave
  • Inyección SQL en Sequelize, Mongoose, Prisma, TypeORM, Knex raw queries
  • Inyección NoSQL (Mongoose $where con strings, operadores Mongo en entrada user)
  • SSRF vía axios, fetch, http con URLs de usuario
  • Secretos hardcoded (API keys, secretos JWT, AWS, Stripe, GitHub, tokens Slack)
  • Mass assignment en Sequelize/Mongoose sin allow-list de campos
  • Cookies inseguras (flags httpOnly, secure, sameSite)
  • Token CSRF faltante en formularios Express
  • Path traversal en fs.readFile con entrada user
  • Cripto insegura (MD5 en crypto, IV hardcoded, random débil)
  • Open redirect (res.redirect(req.query.url))
  • Dependencias obsoletas vía patrones package.json
  • Misconfiguraciones CI/CD (.gitlab-ci, GitHub Actions, scripts npm)

¿Quiere saber cómo se mide realmente la calidad de detección? Consulte la metodología completa de benchmarks multilingües (OWASP Benchmark, NIST Juliet, precisión/recall/F1 por lenguaje) →

CVE Test Suite — el número honesto para Express

StaticCodeAudit fue medido contra un CVE Test Suite real: 45 casos reconstruidos a partir de CVE publicadas e históricas, en 8 frameworks y 5 lenguajes. Express es uno de ellos — y es el segundo framework peor puntuado de toda la suite.

76,1%
Puntuación F1
80,0%
Recall
45
CVE Test Suite (total, todos los lenguajes)

Express, reconstruido desde CVE

76,1%
Express (reconstruido desde CVE)

Divulgado, no ocultado: Express/JavaScript es el segundo peor puntuado de la tabla cross-lenguaje, precisión en 72,7%. Las rutas de taint multi-salto complejas a través de cadenas de middleware son el patrón concreto que el motor de reglas todavía no detecta en algunas CVE de Express. Desglose completo cross-lenguaje (incluyendo dónde Python y PHP puntúan más alto) en la <a href="/es/language-benchmarks.php" class="text-primary font-semibold hover:underline">página de benchmarks por lenguaje</a>.

Las vulnerabilidades reales rara vez caben en un solo archivo

Las aplicaciones Express dividen la lógica en capas: un route handler recibe la solicitud, un módulo de acceso a datos construye la consulta. Un escáner limitado a un solo archivo a la vez nunca conecta ambos — ve el dato del usuario en routes/orders.js y la llamada a base de datos en db/orders.js, pero nunca la conexión entre ambos. StaticCodeAudit sigue el dato a través de los archivos.

routes/orders.js
router.get('/orders', (req, res) => {
    const id = req.query.id;
    res.json(findOrder(id));
});
db/orders.js
function findOrder(id) {
    const sql = `SELECT * FROM orders WHERE id = ${id}`;
    return db.query(sql);
}

id proviene del query string en el route handler, y llega a la consulta SQL un archivo después, sin modificar — StaticCodeAudit lo reporta en la línea exacta donde se ejecuta la consulta.

¿Cómo se compara esto con ESLint o Semgrep?

ESLint (con plugins de seguridad como eslint-plugin-security) y Semgrep son las dos herramientas que aparecen primero cuando un equipo JavaScript/TypeScript busca un escáner de seguridad gratuito. Ambas son legítimas, y muchos equipos ya usan una de ellas — esta es una comparación honesta, no una crítica.

ESLint + eslint-plugin-security

Gratuito, open source

Ya presente en la mayoría de las cadenas de herramientas JS/TS, así que añadir el plugin de seguridad cuesta casi nada de configuración. La cobertura la mantiene la comunidad y se basa en patrones (p. ej. marca eval, regex inseguras) — sin seguimiento de taint entre archivos, y los hallazgos no se mapean a CWE/ISO 27001/ASVS por defecto.

Semgrep (Community)

Gratuito, motor open source

Motor de coincidencia de patrones que cubre muchos lenguajes, incluido JS/TS, con un amplio registro de reglas abiertas. El tier gratuito cubre la mayoría de reglas del día a día; el seguimiento de taint entre archivos, los informes de cumplimiento y algunas integraciones empresariales están en los planes de pago de Semgrep.

Comparativa completa StaticCodeAudit vs Semgrep →

Ninguna de las dos se reemplaza al instalar StaticCodeAudit — si su configuración de ESLint ya cubre lo que su equipo necesita, sigan usándola. Lo que StaticCodeAudit añade: hallazgos ya mapeados a CWE/OWASP/ISO 27001/ASVS/NIST CSF (un hallazgo listo para un expediente de auditoría, no solo un ID de regla), seguimiento de taint entre archivos en sus rutas y módulos por defecto, y 7 lenguajes más cubiertos por el mismo binario — sin un escáner distinto que configurar por lenguaje. Muchos equipos usan ambos.

Audite su código

Audite sus backends Node.js y frameworks front-end (React, Vue, Angular, Svelte) contra XSS, prototype pollution, fallos de inyección y riesgos supply-chain — sin subir una sola línea a la nube.

Descargar el binario demo Reservar una demo guiada