Aller au contenu principal

JavaScript / TypeScript · SAST

SAST JavaScript & TypeScript hors-ligne

Auditez vos backends Node.js et frameworks front-end (React, Vue, Angular, Svelte) contre XSS, prototype pollution, failles d'injection et risques supply-chain — sans téléverser une seule ligne dans le cloud.

Frameworks & bibliothèques scannés

Nous testons la couverture sur ces frameworks via fixtures. De nouveaux patterns sont ajoutés à chaque release de règles builtin.

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

Principales classes CWE détectées

Ces classes CWE apparaissent le plus souvent dans les codebases modernes de ce langage. StaticCodeAudit livre des règles dédiées pour chacune, mappées à OWASP Top 10 / ISO 27001 / ASVS quand pertinent.

CWE-79

Cross-Site Scripting (XSS)

innerHTML, dangerouslySetInnerHTML en React, v-html en Vue, Angular bypassSecurityTrust* avec des données utilisateur. Variantes stored, reflected et DOM-based couvertes.

Détecté par la règle SCA : xss_innerhtml

CWE-1321

Prototype Pollution

Object.assign récursif, _.merge, ou obj[key] = value non protégé quand key vient de l'utilisateur. Une seule clé __proto__ peut casser tous les objets en aval.

Détecté par la règle SCA : prototype_pollution

CWE-89

Injection SQL

Sequelize.literal(), requêtes raw en Prisma $queryRaw\`${input}\`, Mongoose $where avec strings, Knex .raw() avec concat.

Détecté par la règle SCA : sql_injection_concat

CWE-918

SSRF

axios.get(url), fetch(url), http.get sur URLs utilisateur. Particulièrement dangereux en serverless via les endpoints metadata internes.

Détecté par la règle SCA : taint_ssrf

CWE-798

Identifiants en dur

Clés API committées dans .env.example, config.js, ou React process.env.REACT_APP_* exposé au bundle client.

Détecté par la règle SCA : hardcoded_secret

CWE-915

Mass Assignment

User.update(req.body) sans allow-list de champs. Permet de monter en privilèges (isAdmin: true) via body JSON.

Détecté par la règle SCA : mass_assignment

Vulnérable vs. sain — trois exemples rapides

CWE-79 Détecté par la règle SCA : xss_innerhtml
❌ Vulnérable
// Vulnérable — React dangerouslySetInnerHTML
function Bio({ user }) {
    return <div dangerouslySetInnerHTML={{ __html: user.bio }} />;
}
✅ Sain
// Sain — contenu texte, pas d'interprétation HTML
function Bio({ user }) {
    return <div>{user.bio}</div>;
}
CWE-1321 Détecté par la règle SCA : prototype_pollution
❌ Vulnérable
// Vulnérable — deep merge sans 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]; }
    }
}
✅ Sain
// Sain — bloque __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 Détecté par la règle SCA : sql_injection_concat
❌ Vulnérable
// Vulnérable — concat dans Sequelize.literal
const users = await User.findAll({
    where: sequelize.literal(`name = \'${req.query.name}\'`)
});
✅ Sain
// Sain — paramètre lié
const users = await User.findAll({
    where: { name: req.query.name }
});

Ce que StaticCodeAudit détecte (ce langage)

  • XSS en React dangerouslySetInnerHTML, Vue v-html, Angular trust bypass, vanilla innerHTML
  • Prototype pollution via deep merge, assignation de clé dynamique
  • Injection SQL dans Sequelize, Mongoose, Prisma, TypeORM, Knex raw queries
  • Injection NoSQL (Mongoose $where avec strings, opérateurs Mongo dans entrée user)
  • SSRF via axios, fetch, http avec URLs utilisateur
  • Secrets en dur (clés API, secrets JWT, AWS, Stripe, GitHub, tokens Slack)
  • Mass assignment dans Sequelize/Mongoose sans allow-list de champs
  • Cookies non sécurisés (flags httpOnly, secure, sameSite)
  • Token CSRF manquant dans les formulaires Express
  • Path traversal dans fs.readFile avec entrée user
  • Crypto non sécurisée (MD5 dans crypto, IV en dur, random faible)
  • Open redirect (res.redirect(req.query.url))
  • Dépendances obsolètes via patterns package.json
  • Misconfigurations CI/CD (.gitlab-ci, GitHub Actions, scripts npm)

Envie de savoir comment la qualité de détection est réellement mesurée ? Consultez la méthodologie complète des benchmarks multi-langages (OWASP Benchmark, NIST Juliet, précision/recall/F1 par langage) →

CVE Test Suite — le chiffre honnête pour Express

StaticCodeAudit a été mesuré sur un CVE Test Suite réel : 45 cas reconstitués à partir de CVE publiées et historiques, sur 8 frameworks et 5 langages. Express en fait partie — et c'est l'avant-dernier framework du classement de toute la suite.

76,1 %
Score F1
80,0 %
Rappel
45
CVE Test Suite (total, tous langages)

Express, reconstitué depuis CVE

76,1 %
Express (reconstitué depuis CVE)

Divulgué, pas caché : Express/JavaScript est l'avant-dernier du tableau cross-langage, précision à 72,7 %. Les chemins de taint multi-sauts complexes à travers les chaînes de middleware sont le pattern précis que le moteur de règles rate encore sur certaines CVE Express. Détail complet cross-langage (y compris où Python et PHP obtiennent un meilleur score) sur la <a href="/fr/language-benchmarks.php" class="text-primary font-semibold hover:underline">page des benchmarks par langage</a>.

Les vraies failles tiennent rarement dans un seul fichier

Les applications Express répartissent la logique en couches : un handler de route reçoit la requête, un module d'accès aux données construit la requête SQL. Un scanner limité à un seul fichier à la fois ne fait jamais le lien — il voit la donnée utilisateur dans routes/orders.js et l'appel base de données dans db/orders.js, mais jamais la connexion entre les deux. StaticCodeAudit suit la donnée à travers les fichiers.

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 provient de la query string dans le handler de route, et atteint la requête SQL un fichier plus loin, sans modification — StaticCodeAudit le signale à la ligne exacte où la requête s'exécute.

Comment ça se compare à ESLint ou Semgrep ?

ESLint (avec des plugins de sécurité comme eslint-plugin-security) et Semgrep sont les deux outils qui reviennent en premier quand une équipe JavaScript/TypeScript cherche un scanner de sécurité gratuit. Les deux sont légitimes, et beaucoup d'équipes en utilisent déjà un — voici un comparatif honnête, pas un dénigrement.

ESLint + eslint-plugin-security

Gratuit, open source

Déjà présent dans la plupart des chaînes d'outils JS/TS, donc ajouter le plugin de sécurité coûte presque rien en configuration. La couverture est maintenue par la communauté et basée sur des patterns (ex. signale eval, regex non sécurisées) — pas de suivi de taint inter-fichiers, et les findings ne sont pas mappés CWE/ISO 27001/ASVS par défaut.

Semgrep (Community)

Gratuit, moteur open source

Moteur de pattern-matching couvrant de nombreux langages, dont JS/TS, avec un large registre de règles ouvertes. Le tier gratuit couvre l'essentiel du quotidien ; le suivi de taint inter-fichiers, le reporting de conformité et certaines intégrations entreprise sont réservés aux tiers payants de Semgrep.

Comparatif complet StaticCodeAudit vs Semgrep →

Aucun des deux n'est remplacé par l'installation de StaticCodeAudit — si votre config ESLint couvre déjà ce dont votre équipe a besoin, continuez à l'utiliser. Ce que StaticCodeAudit ajoute : des findings déjà mappés CWE/OWASP/ISO 27001/ASVS/NIST CSF (un finding prêt pour un dossier d'audit, pas juste un identifiant de règle), un suivi de taint inter-fichiers sur vos routes et modules par défaut, et 7 autres langages couverts par le même binaire — pas de scanner séparé à configurer par langage. Beaucoup d'équipes utilisent les deux.

Auditez votre code

Auditez vos backends Node.js et frameworks front-end (React, Vue, Angular, Svelte) contre XSS, prototype pollution, failles d'injection et risques supply-chain — sans téléverser une seule ligne dans le cloud.

Télécharger le binaire démo Réserver une démo guidée