Guide

Semgrep, des motifs plutôt que des regex et la limite Pro

Semgrep analyse le code par motifs syntaxiques. Version 1.174.0, licence LGPL, frontière avec l'offre Pro, licence des règles, tarifs et écriture de règles.

L'équipe CodeWorlds25 min de lecture ·

Pratique HTML et CSS dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article9

Semgrep applique des règles à l'arbre syntaxique plutôt qu'au texte, donc renommer une variable ou réagencer une ligne ne casse pas le motif. La version 1.174.0, publiée le 20 août 2026, est distribuée sous LGPL 2.1, mais seul le moteur est ouvert. L'analyse inter-fichiers, trois langages, la détection de secrets et le registre de règles exigent un compte, et dans la plupart des cas un paiement aussi.

Comment fonctionne la correspondance syntaxique

Un simple grep travaille sur des caractères. Si vous cherchez un appel avec un argument dangereux, vous devez prévoir toutes les écritures : des espaces autour de la virgule, des arguments nommés dans un autre ordre, un appel réparti sur trois lignes, une variable nommée cmd à un endroit et command à un autre. Une expression régulière qui couvre tout cela devient illisible après quelques itérations et manque quand même la quatrième variante.

Semgrep analyse le fichier en arbre syntaxique et le compare à un motif écrit dans la syntaxe du langage cible. Le motif subprocess.$FUNC(..., shell=$TRUE, ...) se lit comme du Python parce que c'est du Python, avec deux ajouts. $FUNC et $TRUE sont des métavariables qui capturent n'importe quelle expression et la mémorisent pour des conditions ultérieures. Les trois points sont l'opérateur d'ellipse, qui correspond à n'importe quel nombre d'arguments, d'instructions ou d'éléments à cet endroit. Le formatage, les commentaires et les noms réels des variables cessent de compter.

La façon la plus courte de tester l'idée n'exige pas de fichier de règles.

Bash
# install into a dedicated virtual environment
python3 -m venv .venv && .venv/bin/pip install semgrep==1.174.0

# a one-off pattern with no rule file
semgrep --lang python --pattern 'subprocess.$FUNC(..., shell=True, ...)' src/

# a pattern with a replacement, preview mode
semgrep --lang python --pattern 'assert $X' --replacement 'if not $X: raise AssertionError' --dryrun src/

# local rules only, no network and no telemetry
semgrep scan --config ./rules --metrics off .

# list the files that will actually reach the scan
semgrep scan --config ./rules --x-ls .

L'option --metrics prend auto, on et off. La valeur par défaut auto signifie, d'après le commentaire dans metrics.py, que des données ne sont envoyées que si la configuration a été tirée du serveur. Une analyse avec des règles locales n'envoie rien. Une analyse avec --config p/default envoie, et c'est le comportement par défaut, facile à oublier quand on introduit l'outil dans une entreprise à la politique de données stricte.

Version, licence et les métadonnées qui restent silencieuses

La version actuelle est la 1.174.0. L'archive source est arrivée sur PyPI le 20 août 2026 à 15 h 59 UTC, les wheels quelques minutes plus tard, et l'entrée de release dans le dépôt porte un horodatage de 15 h 58 UTC le même jour. Neuf versions sont apparues entre le 11 juin et le 20 août 2026, soit en moyenne une tous les neuf jours, avec un seul écart plus long de seize jours à cheval sur juillet et août. Le registre contient 353 versions et aucune n'est marquée comme retirée. Le dernier changement sur la branche develop date du 20 août 2026.

La licence n'est sans ambiguïté qu'une fois qu'on regarde au bon endroit. Le fichier LICENSE à la racine du dépôt sous le tag v1.174.0 contient le texte complet de la GNU Lesser General Public License version 2.1 de février 1999, 504 lignes. cli/LICENSE est un lien symbolique vers le même fichier, et son contenu brut sur le service d'hébergement est littéralement ../LICENSE. Au-delà, le dépôt n'a ni COPYING, ni NOTICE, ni LICENSING.md, ni fichiers de licence séparés dans src, libs, languages, tools ou interfaces.

Les ennuis commencent dans les métadonnées du registre. pyproject.toml déclare license = "LGPL-2.1-or-later" et license-files = ["LICENSE"], la nouvelle forme de la PEP 639. En conséquence PKG-INFO porte Metadata-Version: 2.4 et le champ License-Expression: LGPL-2.1-or-later. L'ancien champ License est vide, et dans l'interface JSON de PyPI info.license renvoie null. Pire, la liste des classifieurs ne contient aucune entrée commençant par License ::. Il y a onze classifieurs et ils ne décrivent que le système d'exploitation, les versions de Python et la catégorie thématique.

La conséquence pratique est qu'un scanner de dépendances qui lit info.license ou les classifieurs ne verra rien et signalera le paquet comme sans licence. Un scanner qui lit license_expression ou PKG-INFO verra le bon LGPL-2.1-or-later. Si votre entreprise a une barrière automatique qui bloque les paquets sans licence, celui-ci la déclenchera malgré un code correctement étiqueté. Il y a aussi une petite incohérence qui mérite d'être notée : les en-têtes des fichiers source parlent de la version 2.1 de la licence sans clause de version ultérieure, alors que l'expression dans les métadonnées indique or-later. Dans un audit de conformité soigneux, c'est une différence à régler avec le service juridique, pas avec la documentation.

Le contenu du paquet publié confirme la déclaration, mais révèle aussi une séparation en deux parties. L'archive source pèse 507 637 octets et ne contient que du code Python : les paquets semgrep et semdep, le fichier LICENSE avec le texte LGPL, pyproject.toml et README.md. Le moteur n'y est pas. Le moteur est dans les wheels. La wheel pour macOS sur arm64 pèse 49 480 382 octets compressés et contient le fichier semgrep/bin/semgrep-core de 208 085 424 octets, environ 198 Mio, avec les bibliothèques libtree-sitter, libpcre2-8, libgmp, libzstd, libdwarf et libev. À côté se trouve semgrep-1.174.0.dist-info/licenses/LICENSE de 26 526 octets, le même texte LGPL 2.1. La déclaration correspond entièrement au contenu, et le code est bien dans le paquet.

Les dépendances d'exécution sont nombreuses : vingt-sept paquets plus pywin32 sous Windows. Deux portent des versions exactes, mcp==1.29.0 et ruamel.yaml.clib==0.2.15, et la version requise de Python est au moins la 3.10. Le fichier pyproject.toml lui-même recommande en commentaire un environnement virtuel séparé ou une image de conteneur, et ce n'est pas de l'excès de prudence, car des versions exactes imposées à deux bibliothèques peuvent bloquer l'installation dans un environnement partagé avec un autre outil.

La frontière entre la version ouverte et la version payante

C'est ici que la plupart des écrits sur Semgrep décrivent des capacités sans mentionner qu'elles coûtent de l'argent. La séparation est visible directement dans le code, dans engine.py, où l'énumération EngineType a quatre valeurs : OSS, PRO_LANG, PRO_INTRAFILE et PRO_INTERFILE.

NiveauOptionPortée de l'analyseCompte requis
OSS--oss-onlyune seule fonction, taint dans une fonctionnon
PRO_LANG--pro-languagescomme OSS plus Apex, Elixir et Gosuoui
PRO_INTRAFILE--pro-intrafileentre fonctions dans un même fichieroui
PRO_INTERFILE--proentre fichiers dans tout le dépôtoui

La méthode decide_engine_type fixe le niveau par défaut selon une règle simple : un utilisateur connecté qui lance semgrep ci obtient PRO_INTRAFILE, tous les autres obtiennent OSS. Une analyse de diff rétrograde un PRO_INTERFILE demandé en PRO_INTRAFILE pour ne pas ralentir les pull requests. Une analyse de la seule chaîne d'approvisionnement fait de même, car le mode inter-fichiers n'utilise par défaut qu'un seul worker.

La réponse à la question du titre de cette section est donc : l'analyse entre fonctions et entre fichiers n'est pas dans la version ouverte. Elle vit dans le binaire semgrep-core-proprietary que la commande semgrep install-semgrep-pro télécharge. Le code de cette commande est sans ambiguïté. Sans token, c'est-à-dire sans semgrep login ou sans la variable SEMGREP_APP_TOKEN, la commande se termine avec le code d'erreur de clé invalide. Le binaire est récupéré au chemin api/agent/deployments/deepbinary/{platform} sur le serveur de l'éditeur. Une réponse 401 signifie un token invalide, une 403 porte le message que le déploiement connecté n'a pas accès au Pro Engine. Un fichier d'estampille de version atterrit à côté du binaire pour que la mise à jour du seul paquet ne laisse pas derrière elle un moteur incompatible.

Trois autres choses sont fermées en même temps que le moteur. La détection de secrets lève dans le code une exception explicite disant qu'elle ne fait pas partie du moteur open source, et avec un --oss-only explicite l'analyse s'interrompt avec un message disant que c'est une extension propriétaire. Le suivi du flux de données dans la sortie, c'est-à-dire --dataflow-traces, n'est disponible que pour les niveaux PRO_INTRAFILE et PRO_INTERFILE. Les langages marqués comme propriétaires sont exactement trois : Apex, Elixir et Gosu. Cela vient du fichier lang.json livré avec le paquet, où sur cinquante entrées seules ces trois portent l'étiquette is_proprietary.

Le même fichier vaut la peine d'être lu pour une autre raison. La maturité des langages est inégale : onze entrées ont le statut ga (C#, Go, JSON, Java, JavaScript, PHP, Python, Ruby, Scala, Terraform, TypeScript), une beta (Kotlin), vingt-cinq alpha et treize develop. La page des tarifs annonce « 35+ » langages pris en charge pour chaque offre. Les deux chiffres sont vrais dans leur propre cadre, car cinquante entrées couvrent aussi des éléments auxiliaires comme generic, regex et aliengrep ainsi que des variantes distinctes pour Python 2 et 3, mais l'écart est assez large pour qu'en choisissant un outil pour une pile précise il vaille mieux consulter lang.json que la page marketing.

Le registre de règles est un service, pas une partie du code ouvert. C'est visible dans config_resolver.py : les identifiants avec les préfixes r/, p/ et s/ (règle, pack, snippet) sont transformés en adresse {semgrep_url}/c/{id}, et --config auto en {semgrep_url}/c/auto. Le dépôt LGPL ne contient aucune règle de production. Les règles de la Community Edition vivent dans un dépôt séparé, semgrep-rules, et j'y ai compté 2 091 identifiants répartis sur 2 076 fichiers YAML, dont 378 pour Python, 351 pour Terraform, 257 pour le mode générique, 182 pour JavaScript, 132 dans le répertoire qui couvre les bibliothèques d'IA et 130 pour Java.

La licence de ce dépôt est un sujet séparé et la pièce la plus souvent négligée de tout le puzzle. Le fichier LICENSE contient une seule phrase renvoyant à la Semgrep Rules License v1.0, un document mis à jour pour la dernière fois le 13 décembre 2024. Ce n'est pas une licence ouverte. La concession est non exclusive, libre de redevance, mondiale, non sous-licenciable et non transférable. La limitation est formulée par finalité plutôt que par seuil : les règles ne peuvent être utilisées que pour vos propres besoins internes d'entreprise. La licence ne permet ni de les distribuer ni de les mettre à disposition d'autres comme service. Les mentions de licence et de droit d'auteur ne peuvent pas être retirées ni masquées, et copier une règle signifie emporter la mention avec elle. Les modifications doivent être marquées de façon visible dans la copie. Il y a une clause de brevet qui prend fin immédiatement si vous ou votre entreprise faites une revendication écrite selon laquelle les règles ou un produit Semgrep enfreignent un brevet. Une violation des conditions met fin automatiquement à la licence.

Ce que la licence ne contient pas compte tout autant. Il n'y a pas de seuil de nombre d'utilisateurs, pas de seuil de chiffre d'affaires et pas de date de conversion en licence ouverte du genre familier du modèle Business Source License. La restriction est permanente et concerne le type d'usage. En pratique : vous pouvez lancer ces règles sur votre propre code dans votre entreprise, vous ne pouvez pas les intégrer dans votre propre produit d'analyse, ni bâtir dessus un service d'analyse pour des clients, ni publier un fork comme collection indépendante. Contribuer à ce dépôt accorde à Semgrep une licence pour distribuer la règle soumise aux mêmes conditions. Les règles Pro, écrites par l'équipe de recherche de l'éditeur, n'arrivent jamais dans ce dépôt et ne sont disponibles que par le registre.

Pour résumer la séparation : le code du moteur ouvert est LGPL 2.1, le moteur Pro est un binaire fermé derrière une connexion, les règles de la Community Edition portent leur propre licence qui interdit la redistribution, et les règles Pro sont propriétaires et disponibles uniquement comme service.

Tarifs de la plateforme et leur arithmétique

La page des tarifs s'affiche sans JavaScript, donc les chiffres ci-dessous proviennent du HTML brut récupéré le 22 août 2026.

OffrePrixContributeursDépôts privésCrédits IA
Free Edition0 USDau plus 101060
Teamsà partir de 30 USD par contributeur et par moispas de limite indiquéejusqu'à 50020 par développeur et par mois
Enterprisedevis sur mesuresans limitesans limite50 par développeur et par mois

L'offre Teams détaillée par produit : Code 30 USD, Supply Chain 30 USD, Secrets 15 USD, chacun par contributeur et par mois. Une équipe qui veut les trois paie donc 75 USD par contributeur et par mois, ce qui à dix contributeurs fait 750 USD par mois et 9 000 USD par an. L'offre gratuite couvre Code et Supply Chain à 0 USD, et Secrets n'y figure pas.

Deux choses dans cette tarification méritent attention. La première est une divergence dans la page elle-même : la description de l'offre gratuite dit « Scan up to 10 repositories », alors que le tableau comparatif donne à la même offre des dépôts publics illimités et au plus dix dépôts privés. Je cite les deux, car la page ne permet pas de trancher laquelle s'applique.

La seconde concerne les crédits IA. L'offre gratuite reçoit soixante crédits décrits comme « inclus », sans période de facturation nommée. L'offre Teams reçoit vingt par développeur et par mois, donc une équipe de trois personnes atteint les mêmes soixante crédits, sauf que c'est chaque mois. Si les soixante de l'offre gratuite sont un pool unique, l'écart entre les offres est bien plus large que les chiffres bruts ne le suggèrent. La page ne le dit pas.

Un contributeur est défini comme quelqu'un qui a fait au moins un commit au cours des quatre-vingt-dix derniers jours dans un dépôt privé de l'organisation analysée par Semgrep. Avec le roulement des équipes et des bots qui font des commits, cette définition peut surprendre sur la facture.

Un autre fait ressemble à une contradiction et n'en est pas une. L'offre gratuite de la plateforme inclut l'analyse inter-fichiers avec les règles Pro. Cela ne signifie pas que ces fonctions sont dans le code ouvert. Cela signifie que l'éditeur les offre gratuitement aux petites équipes via sa plateforme, après connexion avec GitHub ou GitLab, plafonnées à dix contributeurs. Gratuit et ouvert sont ici deux choses différentes.

Écrire sa propre règle

Une règle personnalisée est ce qui distingue Semgrep d'un scanner prêt à l'emploi, et c'est aussi la seule raison de le choisir plutôt que quelque chose de plus simple. Le format est décrit par rule_schema_v1.yaml, livré dans le paquet, donc les noms de champs ci-dessous viennent de là plutôt que de la documentation.

Un fichier de règles a une seule clé de premier niveau, rules, qui contient une liste. En mode recherche, une règle exige id, message, languages, severity et l'un des champs décrivant un motif.

YAML
rules:
  - id: request-without-timeout
    message: >-
      A requests.$METHOD call without a timeout argument can hang the process
      indefinitely. Set timeout explicitly.
    languages: [python]
    severity: WARNING
    patterns:
      - pattern-either:
          - pattern: requests.get(...)
          - pattern: requests.post(...)
          - pattern: requests.request(...)
      - pattern-not: requests.$METHOD(..., timeout=$T, ...)
    paths:
      exclude:
        - tests/
        - "**/conftest.py"
    metadata:
      category: correctness
      confidence: HIGH

L'ordre des opérateurs dans patterns est une conjonction : chaque condition doit être vraie en même temps. pattern-either est une disjonction. pattern-not retranche les cas déjà corrects. paths, avec ses sous-champs include et exclude, restreint la règle à une partie du dépôt sans toucher à la configuration globale.

Le champ severity accepte ERROR, WARNING et INFO, et depuis la version 1.72.0 aussi CRITICAL, HIGH, MEDIUM et LOW. Le schéma permet en plus les valeurs expérimentales INVENTORY et EXPERIMENT. Les anciens et les nouveaux noms coexistent, donc il est facile de se retrouver avec un mélange dans un dépôt et un filtre --severity qui attrape la moitié de ce qu'il devrait.

La deuxième règle montre des conditions appliquées à des métavariables avec une correction automatique.

YAML
rules:
  - id: weak-jwt-signing-algorithm
    message: JWT signed with algorithm $ALG. Use HS256 or RS256.
    languages: [python]
    severity: ERROR
    min-version: 1.72.0
    patterns:
      - pattern: jwt.encode(..., algorithm=$ALG, ...)
      - metavariable-regex:
          metavariable: $ALG
          regex: ^["'](none|HS1|MD5)["']$
      - focus-metavariable: $ALG
    fix: '"HS256"'
    metadata:
      cwe:
        - "CWE-327: Use of a Broken or Risky Cryptographic Algorithm"

metavariable-regex applique une expression régulière au contenu capturé par une métavariable, mélangeant les deux mondes de façon contrôlée : la syntaxe choisit l'endroit, la regex restreint la valeur. focus-metavariable déplace la mise en évidence dans le résultat de l'appel entier vers le seul argument, ce qui permet au fix de ne remplacer que cet argument. À côté, le schéma définit metavariable-pattern (faire correspondre un motif au contenu d'une métavariable, éventuellement dans un autre langage), metavariable-comparison avec les champs metavariable, comparison, strip et base, ainsi que metavariable-type, metavariable-name et metavariable-analysis avec les champs analyzer et metavariable, utilisé entre autres pour l'analyse d'entropie. Le champ min-version existe pour qu'un Semgrep plus ancien ignore la règle au lieu d'échouer sur un champ inconnu. Le schéma fixe délibérément additionalProperties: true au niveau de la règle pour la même raison.

La troisième variante est le mode taint, la seule façon de relier une source de données à l'endroit où elles sont utilisées.

YAML
rules:
  - id: os-command-from-flask-parameter
    mode: taint
    message: Request data reaches os.system without validation.
    languages: [python]
    severity: ERROR
    pattern-sources:
      - patterns:
          - pattern-inside: |
              @app.route(...)
              def $HANDLER(...):
                  ...
          - pattern: flask.request.$ANYTHING
    pattern-sanitizers:
      - pattern: shlex.quote(...)
      - pattern: re.fullmatch("...", ...)
    pattern-sinks:
      - pattern: os.system(...)

Une règle en mode taint exige id, message, languages, severity, pattern-sources et pattern-sinks. pattern-sanitizers et pattern-propagators sont facultatifs. Et ici la séparation de la section précédente revient : dans le moteur ouvert, le suivi s'arrête à la frontière de la fonction. Si la source est dans un contrôleur et que l'appel système se trouve dans une fonction auxiliaire du même fichier, il vous faut --pro-intrafile. Si l'auxiliaire vit dans un autre module, il vous faut --pro. Une règle écrite sans cette conscience paraît cassée alors qu'elle est parfaitement correcte.

Les règles se vérifient avec semgrep --test, qui cherche un fichier de même nom de base et avec l'extension du langage et compare les correspondances aux annotations en commentaires. Celles qui sont reconnues sont ruleid, ok, todoruleid et todook, plus les variantes proruleid, deepruleid et deepok pour les résultats qui exigent le moteur Pro. semgrep --validate --config ./rules vérifie seulement le schéma sans lancer d'analyse.

Faux positifs et coût de maintenance

L'analyse statique produit du bruit, et une équipe qui reçoit cent avertissements par jour cesse de les lire en une semaine. Déployer Semgrep n'est pas une configuration unique, et il vaut mieux le supposer d'emblée que de le découvrir au troisième mois.

Il existe plusieurs mécanismes de suppression et ils diffèrent par leur portée. Le plus étroit est un commentaire dans le code. D'après constants.py, le jeton reconnu est nosem ou nosemgrep, la casse est ignorée, et après un deux-points on peut lister des identifiants de règles séparés par des virgules. Le commentaire fonctionne sur la même ligne que le résultat ou sur la ligne juste au-dessus.

Python
# nosemgrep: request-without-timeout
resp = requests.get(url)

resp = requests.get(url)  # nosem: request-without-timeout,weak-jwt-signing-algorithm

# nosemgrep
resp = requests.get(url)

La dernière variante, sans identifiant, fait taire tout à cet endroit et c'est celle qui n'apprend plus rien à personne un an plus tard. Il vaut la peine d'exiger un identifiant de règle et une raison lors de la revue de code. Tout le mécanisme des commentaires se désactive avec --disable-nosem, ce qui est utile lors d'un audit périodique des suppressions accumulées.

Un niveau au-dessus se trouve le fichier .semgrepignore avec une syntaxe de motifs de chemins, complété par défaut par .gitignore sauf si vous passez --no-git-ignore. Il y a un piège visible dans target_manager.py : pour certains produits, le fichier .semgrepignore est volontairement ignoré, car son contenu typique filtre des répertoires que ces produits doivent justement analyser. Le nom du fichier se change avec --x-semgrepignore-filename et on le saute avec --x-ignore-semgrepignore-files. Le préfixe --x- marque une option expérimentale, donc je ne bâtirais pas un processus durable dessus.

Le niveau le plus large est le choix des règles et des seuils. --exclude-rule retire une règle par identifiant, --exclude et --include filtrent les chemins, et --severity ne laisse passer qu'un niveau choisi. Le plus efficace en pratique est toutefois --baseline-commit : l'analyse ne signale que les résultats absents à un point donné de l'historique. Un dépôt existant ne démarre donc pas avec mille avertissements, tandis que le nouveau code est protégé dès le premier jour.

S'ajoutent des limites de performance sur lesquelles on trébuche facilement. Le budget de temps par défaut par règle et par fichier est de cinq secondes, et un fichier de plus d'un million d'octets est ignoré. Le mode inter-fichiers dans un pipeline d'intégration continue a ses propres valeurs par défaut : une limite de mémoire de 8 192 Mio et une limite de temps de 10 800 secondes, soit trois heures. Sous Linux, la limite de mémoire est en plus calculée comme quatre-vingt-dix pour cent de la valeur de /sys/fs/cgroup/memory.max quand une telle limite existe. Une analyse qui « n'a rien trouvé » est parfois une analyse qui a discrètement sauté la moitié des fichiers, c'est pourquoi --x-ls et la section des fichiers ignorés du rapport sont le premier endroit à vérifier.

Une prévision honnête du coût ressemble à ceci, avec la réserve que les durées ci-dessous sont mon estimation tirée de la pratique et non un chiffre de la documentation. La première exécution sur un dépôt mature prend un bon quart d'heure. Examiner la sortie et fixer une baseline prend quelques jours. Vient ensuite une charge permanente : chaque mise à jour du registre peut ajouter des règles qui produisent du bruit dans votre code, chaque nouvelle règle personnalisée a besoin d'un test et d'une revue, et chaque suppression a besoin d'une justification, sinon un an plus tard personne ne sait si un commentaire nosemgrep marque une vraie exception ou un moment d'impatience.

Semgrep à côté des linters et des scanners de modèles

La frontière entre un linter et un outil de sécurité devient floue, puisque tous deux lisent le code sans l'exécuter. La différence tient à l'objectif et à ce qu'ils sont capables de voir.

CaractéristiqueSemgrepBiomeOxlintLakera Guard, Prompt Security
Objet de l'analysemotifs de code et vulnérabilitésstyle et erreurs du codestyle et erreurs du codeentrées et sorties du modèle
Point d'actionanalyse statiqueanalyse statiqueanalyse statiqueà l'exécution
Règles personnaliséesYAML, format completGritQLJavaScriptconfiguration de politiques
Portée inter-fichiersvariante payante uniquementsans objetsans objetsans objet
Licence du codeLGPL 2.1MIT ou Apache 2.0MITservice fermé
Licence des règlesSemgrep Rules License v1.0la même que le codela même que le codesans objet

Biome et Oxlint veillent sur le style et les erreurs courantes en JavaScript et en TypeScript. Ils sont plus rapides parce que leur périmètre est plus étroit et qu'ils travaillent sur un seul fichier sans modèle de flux de données. Semgrep ne les remplacera pas pour le formatage et ne vérifiera pas les types, alors qu'eux n'exprimeront pas une règle décrivant des données qui passent d'un paramètre de requête à un appel système. Un arrangement raisonnable est le linting à l'enregistrement du fichier et Semgrep dans le pipeline d'intégration continue, avec la baseline fixée sur la branche principale.

Des outils comme Lakera Guard, Prompt Security et Protect AI appartiennent à une autre catégorie, et les mélanger avec Semgrep mène à de mauvaises décisions. Ils inspectent ce qui entre dans un modèle de langage et ce qui en sort, à l'exécution. Semgrep inspecte le code avant même son exécution. Le seul point de contact est que le dépôt des règles de la Community Edition contient un répertoire ai avec 132 règles couvrant les bibliothèques de travail avec des modèles, et c'est de l'analyse du code qui appelle un modèle, pas du trafic vers le modèle.

Un sujet à part est le code écrit par des assistants. Si votre équipe utilise GitHub Copilot, une analyse de motifs dans le pipeline vaut plus qu'avant, car le volume de code qui passe en revue croît plus vite que l'attention des relecteurs. Semgrep 1.174.0 livre aussi son propre serveur MCP dans le module semgrep.mcp et tire la dépendance mcp==1.29.0, donc l'intégration avec les outils d'agents est dans le paquet, bien que je n'aie pas vérifié sa description au-delà de la présence du code.

Erreurs courantes

La première est de supposer que --config auto fonctionne en local et hors ligne. Ce raccourci se développe en l'adresse {semgrep_url}/c/auto, exige une connexion au serveur de l'éditeur et active la télémétrie, car la valeur par défaut --metrics auto se déclenche pour toute configuration récupérée à distance.

La deuxième est d'écrire une règle en mode taint et de conclure que le moteur est cassé parce qu'il ne trouve rien. Sans --pro-intrafile, le suivi s'arrête à la frontière de la fonction, et cela couvre une minorité de cas réels.

La troisième est de copier des règles du dépôt semgrep-rules dans votre propre produit ou votre propre collection publique. La licence de ces règles interdit la redistribution et la proposition comme service, même si le dépôt est public sur GitHub.

La quatrième est un blocage dans une barrière de conformité à cause d'une prétendue licence manquante. Le paquet porte une déclaration correcte LGPL-2.1-or-later, seulement dans le champ License-Expression plutôt que dans les classifieurs ou l'ancien champ License. La solution est de mettre à jour le scanner, pas d'ajouter une exception pour le paquet.

La cinquième est de l'installer à côté d'autres outils dans un même environnement virtuel. Les versions exactes mcp==1.29.0 et ruamel.yaml.clib==0.2.15 entrent en conflit avec d'autres paquets plus souvent qu'on ne le croirait.

La sixième est de lancer une analyse sur tout le dépôt sans baseline. La sortie sur un projet mature se chiffre en centaines de résultats, l'équipe la ferme avec une seule suppression globale, et l'outil est mort. --baseline-commit existe exactement pour cela.

La septième est de mélanger les anciens et les nouveaux noms de sévérité dans un même ensemble de règles. ERROR et HIGH sont deux valeurs distinctes dans le schéma, et le filtre --severity ne connaît aucun lien entre elles.

FAQ

Semgrep est-il gratuit ?

Le moteur et le client en ligne de commande sont sous LGPL 2.1 et utilisables sans compte. L'analyse entre fonctions, l'analyse inter-fichiers, la détection de secrets et trois langages (Apex, Elixir, Gosu) exigent le binaire Pro téléchargé après connexion. La plateforme a une offre gratuite pour au plus dix contributeurs et des offres payantes à partir de 30 USD par contributeur et par mois.

Puis-je utiliser les règles du dépôt semgrep-rules dans mon propre outil ?

Non. La Semgrep Rules License v1.0 n'autorise l'usage des règles que pour vos propres besoins internes d'entreprise et interdit explicitement de les distribuer ou de les mettre à disposition d'autres comme service. Il n'y a pas de seuil de chiffre d'affaires ni de date de conversion en licence ouverte.

En quoi Semgrep diffère-t-il d'un linter ?

Un linter veille sur le style et les erreurs courantes avec un ensemble de règles intégré. Semgrep fait correspondre n'importe quel motif que vous écrivez vous-même dans la syntaxe du langage cible, et il peut suivre le flux de données d'une source jusqu'à l'endroit où elles sont utilisées. En échange il ne formate pas le code et ne vérifie pas les types.

Une analyse envoie-t-elle mon code à Semgrep ?

Le code ne quitte pas la machine lors d'une analyse locale. Les métadonnées de l'analyse sont envoyées, et seulement quand les règles viennent du serveur. --metrics off désactive cela entièrement, et --config ./rules avec des fichiers locaux ne déclenche jamais d'envoi.

Combien de règles ai-je sans compte ?

Le registre fonctionne de façon anonyme pour les packs publics avec les préfixes p/, r/ et s/. L'équivalent sur GitHub de cet ensemble est le dépôt de la Community Edition, où j'ai compté 2 091 règles. Les règles Pro ne sont pas dans ce dépôt et exigent un compte.

Vaut-il la peine d'écrire des règles personnalisées, ou les règles standard suffisent-elles ?

Les règles standard attrapent les vulnérabilités courantes et n'exigent aucun travail. Les règles personnalisées ont du sens là où il s'agit des conventions d'un projet précis : interdire une fonction interne obsolète, exiger qu'un contexte de requête soit transmis, attraper un motif avant un refactoring. C'est la seule partie qu'un scanner prêt à l'emploi ne peut pas remplacer.

Dernières actualités : Semgrep

Toutes les actualités

À lire aussi