Seulement les failles qu'un attaquant peut atteindre.

Chaque faille suivie du point d'entrée jusqu'à la ligne, avec son correctif.

checkout-apiSASTProjet de démonstration

ÉlevéeInjection SQLusers.controller.ts:10
CWE-89, atteignable depuis GET /users/:id
```
10-db.query(`SELECT * FROM users WHERE id=${id}`)10+db.query("SELECT * FROM users WHERE id = $1", [id])
```
Correctif prêtRequête paramétrée, réécrite dans la même session

Les failles atteignables, chacune avec son correctif.

Des failles atteignables
1. GET /users/:id
2. users.controller.ts:10
3. db.query()
Votre politique
- Équipe Paiements Bloquer à la pull request
- Équipe Growth Avertir seulement
Des flux de données propres à chaque framework
- Expressreq.params.id
- Djangorequest.GET["id"]
- Spring@PathVariable id
Un correctif pour chaque alerte
Un patch dans votre éditeur, ou une pull request signée avec un test de non-régression.

Neuf alertes de motif sur dix sont fausses.

91 %

des vulnérabilités signalées par des scanners à base de motifs sur près de 3 000 dépôts open source étaient des faux positifs.

Ghost Security, Exorcising the SAST Demons, 2025

Un scanner à motifs

Alerte: Injection SQL possibleusers.controller.ts:10
Alerte: Injection SQL possiblePOST /avatar
Alerte: Injection SQL possibleGET /export

CybeDefend

Atteignable: Injection SQLusers.controller.ts:10
Écartée: Ligne signalée, n'atteint aucun sinkPOST /avatar
Écartée: Ligne signalée, n'atteint aucun sinkGET /export

Corrigé par votre agent, avant le commit.

Votre agent lit ces résultats pendant qu'il écrit et les corrige avant le commit.

Découvrir VibeDefend

SASTScanne le dépôt à chaque push.Détectée
VibeDefendTransmet l'alerte à votre agent de code.Servie
Votre agentLa corrige dans la session.Corrigée
CommitPart sans la faille.Propre

Fonctionne avec
Claude Code
Cursor
Windsurf
GitHub Copilot
OpenAI Codex

Commencez par un dépôt.

Connectez GitHub, GitLab, Bitbucket ou Azure DevOps, choisissez un dépôt, et le premier scan démarre.

Essayer le cloud Réserver une démo

En détail

Pour chaque alerte : le chemin, la ligne, la correction.

Des failles atteignables
Suivies depuis un point d'entrée, comme GET /users/:id, jusqu'au sink.
Le chemin d'exploitation
La route, le fichier et la ligne, pour que toute l'équipe puisse le reproduire.
Des flux de données propres à chaque framework
Express, Spring, Django, Rails, Laravel, ASP.NET, Gin, Fastify et les principaux ORM.
Un correctif pour chaque alerte
Un patch dans votre éditeur, ou une pull request signée avec un test de non-régression.
Votre politique
Gravité et périmètre réglés par équipe. Bloquer à la pull request, ou seulement avertir.

Tout ce qu'il vérifie

Ce que notre SAST voit et qui échappe au vôtre.

Une vraie faille par langage, avec la ligne signalée et son correctif.

JavaScript (Express)
Cross-site scripting. Le nom passé dans la query string arrive dans le HTML sans échappement.
ÉlevéeCWE-79
```
8-res.send(`<h1>Hi ${req.query.name}</h1>`);+res.send(`<h1>Hi ${escapeHtml(req.query.name)}</h1>`);
```
TypeScript (Fastify)
Contournement d'autorisation (IDOR). N'importe quel utilisateur connecté lit n'importe quelle facture en changeant l'id.
ÉlevéeCWE-639
```
20-return db.invoice.findUnique({ where: { id } });+return db.invoice.findFirst({ where: { id, ownerId: req.user.id } });
```
Python (Django)
Injection SQL. Le terme recherché est collé dans le SQL : une apostrophe suffit à réécrire la requête.
CritiqueCWE-89
```
23-cursor.execute(f"SELECT * FROM books WHERE title = '{q}'")+cursor.execute("SELECT * FROM books WHERE title = %s", [q])
```

Go (Gin)

Path traversal. Un nom comme ../../etc/passwd sort du dossier uploads.

ÉlevéeCWE-22

32-c.File(filepath.Join("uploads", name))+c.File(filepath.Join("uploads", filepath.Base(name)))

12 autres langages, une faille chacun

Java (Spring)
Entités externes XML. Le parseur résout les entités externes : un fichier envoyé peut lire des fichiers locaux.
ÉlevéeCWE-611
```
46-var doc = dbf.newDocumentBuilder().parse(f.getInputStream());+dbf.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
```
Kotlin (Spring)
Hachage de mot de passe faible. MD5 est rapide et sans sel : des hachages qui fuient se cassent sans effort.
ÉlevéeCWE-916
```
19-val md = MessageDigest.getInstance("MD5")+users.save(form.email, encoder.encode(form.password))
```
C# / .NET (ASP.NET)
Open redirect. returnUrl accepte n'importe quel site : la connexion se termine chez un attaquant.
MoyenneCWE-601
```
54-return Redirect(returnUrl);+return LocalRedirect(returnUrl);
```

Ruby (Rails)

Mass assignment. permit! accepte tous les attributs, admin compris.

ÉlevéeCWE-915

15-@user.update(params.require(:user).permit!)+@user.update(params.require(:user).permit(:name, :email))

PHP (Laravel)
Désérialisation non sûre. Un cookie forgé est désérialisé en objets bien vivants.
CritiqueCWE-502
```
28-$cart = unserialize($request->cookie('cart'));+$cart = json_decode($request->cookie('cart'), true);
```
Rust
Injection de commande système. Le nom de fichier atteint un shell : un nom contenant ; lance une commande.
CritiqueCWE-78
```
10-Command::new("sh").arg("-c").arg(cmd).status()+Command::new("convert").args([name, "thumb.png"]).status()
```
Swift
Token stocké en clair. Le token de session reste dans UserDefaults, lisible depuis une sauvegarde de l'appareil.
MoyenneCWE-312
```
15-UserDefaults.standard.set(reply.token, forKey: "token")+try keychain.save(reply.token, account: "token")
```
Scala
Aléa faible pour un token de réinitialisation. scala.util.Random est prévisible : les tokens de réinitialisation se devinent.
ÉlevéeCWE-338
```
12-val token = Random.alphanumeric.take(32).mkString+val token = UUID.randomUUID().toString
```
Elixir (Phoenix)
Cross-site request forgery. Les routes du navigateur acceptent les POST de n'importe quel site, sans vérifier de token CSRF.
ÉlevéeCWE-352
```
11-plug :fetch_session+plug :protect_from_forgery
```

Solidity

Réentrance. L'ether part avant que le solde ne baisse : withdraw peut être rappelée.

CritiqueCWE-841

25-payable(msg.sender).call{value: amount}("");+balances[msg.sender] -= amount;+payable(msg.sender).transfer(amount);

C / C++
Dépassement de tampon. Un nom de plus de 31 octets déborde du tampon sur la pile.
CritiqueCWE-120
```
33-strcpy(name, argv[1]);+snprintf(name, sizeof name, "%s", argv[1]);
```
HTML
Contrôle d'intégrité absent. Pas de hash d'intégrité : un fichier CDN altéré s'exécute avec un accès complet à la page.
MoyenneCWE-353
```
10-<script src="https://cdn.example/chart.js"></script>+<script src="/static/vendor/chart.js"></script>
```

La sécurité du code en temps réel, là où vit votre code.

Erreurs et avertissements s'accumulent pendant que l'agent écrit. Interceptés avant la pull request.

Des retours en temps réel
Scannez et sécurisez votre code en temps réel pendant le développement, en agent-time, pas dans une CI nocturne.
Technologie IA hybride
Notre solution combine les grands modèles de langage et l'analyse classique de taint et de reachability.
Outils de collaboration
Les alertes partent vers Jira, GitHub Issues, GitLab Issues et Slack.
Couverture complète des langages
Dix-huit langages et tous les frameworks web qui comptent.
Correctifs automatiques
Des correctifs générés par IA arrivent directement dans l'IDE, ou en PR signée accompagnée d'un test de régression.
Politiques personnalisables
Réglez la sévérité, le périmètre et le cloisonnement par équipe. Bloquez à la PR ou avertissez seulement.
Des rapports pensés pour les développeurs
Chaque alerte est livrée avec une explication claire en 3 lignes, le chemin d'exploitation reproductible, le fichier et la ligne, et le correctif suggéré.

Du signalement au correctif

La ligne est signalée.
Exploitable et atteignable, pas un simple motif.
Jugée dans la boucle.
Vos règles chargées, un verdict avant la sauvegarde.
Corrigée sur la ligne.
L'agent la réécrit dans la même session.

Questions fréquentes sur CybeDefend SAST.

Qu'est-ce qui distingue CybeDefend SAST des scanners classiques comme Semgrep, Snyk Code ou Checkmarx ?

Le SAST classique tourne sur les commits et noie les vraies failles sous le bruit. Quand Ghost Security a passé des scanners à base de patterns sur près de 3 000 dépôts open source en 2025, plus de 91 % des vulnérabilités signalées se sont révélées être des faux positifs. CybeDefend intervient en agent-time, sur le diff que votre agent IA s'apprête à écrire, avant même que le fichier soit enregistré. Nous combinons le traçage de reachability (ce chemin de taint atteint-il vraiment un sink ?), des modèles de flux de données adaptés aux frameworks, qui couvrent Express, Spring, Django, Rails, ASP.NET et les principaux ORM, et un score de chemin d'exploitation qui classe les alertes selon leur exploitabilité réelle plutôt que selon le nombre de correspondances. Sur des dépôts en production, notre file vérifiée reste assez courte pour être triée en quelques minutes plutôt qu'en plusieurs jours. Nous livrons aussi des correctifs IA vérifiés avec chaque alerte, là où la plupart des scanners classiques s'arrêtent à l'alerte. Résultat : beaucoup moins de faux positifs, une sécurité appliquée avant même l'existence de la PR, et une correction automatique que votre agent peut appliquer dans la même session.

Quels langages et frameworks prenez-vous en charge ?

Dix-huit langages : JavaScript, TypeScript, Python, Go, Java, Kotlin, Rust, C# / .NET, Ruby, PHP, Swift, Scala, Elixir, Solidity, plus C / C++, HTML et d'autres. Des modèles de flux de données adaptés aux frameworks couvrent Express, Spring, Django, Rails, Phoenix, Laravel, ASP.NET, Gin, Fastify et les principaux ORM. De nouveaux frameworks s'ajoutent chaque mois.

CybeDefend SAST s'intègre-t-il à mon IDE et à ma CI ?

Oui. Grâce au serveur MCP natif, tout agent compatible MCP (Claude Code, Cursor, Windsurf, GitHub Copilot, Gemini) reçoit directement les verdicts. Des plugins dédiés sont disponibles pour VS Code et toute la famille JetBrains : IntelliJ, PhpStorm, WebStorm, PyCharm, DataGrip, Rider, CLion, RustRover, GoLand, RubyMine, AppCode. Intégration CI native sur GitHub Actions et GitLab CI ; une API REST et une CLI couvrent tous les autres systèmes.

Et les faux positifs ?

L'IA hybride couplée au traçage de reachability ramène les faux positifs au plus près de zéro dans la file vérifiée. Les alertes que le moteur ne peut pas confirmer sont marquées « reachable but cold » ou « unreachable » et leur priorité est abaissée, sans jamais déclencher d'astreinte. Résultat sur de vrais dépôts clients : beaucoup moins de faux positifs en SAST, SCA, IaC et secrets, avec une file vérifiée assez courte pour être triée en quelques minutes, pas en plusieurs jours.

Lire la documentationLe CybeDefend Engine, ses propres règles et Opengrep, et les langages pris en charge, de Go et Python jusqu'à Rust.en anglais

Seulement les failles qu'un attaquant peut atteindre.

Des failles atteignables

Votre politique

Des flux de données propres à chaque framework

Un correctif pour chaque alerte

En détail

Des failles atteignables

Le chemin d'exploitation

Des flux de données propres à chaque framework

Un correctif pour chaque alerte

Votre politique

JavaScript (Express)

TypeScript (Fastify)

Python (Django)

Go (Gin)

Java (Spring)

Kotlin (Spring)

C# / .NET (ASP.NET)

Ruby (Rails)

PHP (Laravel)

Rust

Swift

Scala

Elixir (Phoenix)

Solidity

C / C++

HTML

Des retours en temps réel

Technologie IA hybride

Outils de collaboration

Couverture complète des langages

Correctifs automatiques

Politiques personnalisables

Des rapports pensés pour les développeurs

La ligne est signalée.

Jugée dans la boucle.

Corrigée sur la ligne.

Questions fréquentes sur CybeDefend SAST.