Opengrep - Guide d'analyse statique de code open-source

Opengrep - Guide d’analyse statique de code open-source

Opengrep est un fork gouverné par la communauté du moteur Semgrep, créé après que les features aient été déplacées derrière une licence commerciale. Il effectue un test d’application security statique (SAST) rapide basé sur des patterns sur 30+ langages, en utilisant des règles écrites dans une syntaxe qui ressemble au code analysé — aucune expertise AST requise. La prémisse du fork est que la capacité de scanning de base (y compris des features comme le dataflow multi-fichier) doit rester complètement open-source.

Installation

Méthode	Commande
Script d’installation	`curl -fsSL https://raw.githubusercontent.com/opengrep/opengrep/main/install.sh
Docker	`docker run --rm -v "$PWD:/src" opengrep/opengrep opengrep scan /src`
Binaire	télécharger depuis GitHub Releases
Vérifier	`opengrep --version`

Scanning

Commande	Description
`opengrep scan .`	Scanner le répertoire courant avec les règles par défaut
`opengrep scan --config auto .`	Sélectionner automatiquement les règles pour les langages détectés
`opengrep scan --config rules/ .`	Utiliser un répertoire de règles local
`opengrep scan --config p/security-audit .`	Utiliser un pack de règles
`opengrep scan --json -o out.json .`	Sortie JSON
`opengrep scan --sarif -o out.sarif .`	SARIF pour les plateformes de code scanning

Écrire des règles

Les règles sont en YAML ; le pattern ressemble au code que vous voulez trouver.

rules:
  - id: hardcoded-aws-key
    patterns:
      - pattern: $KEY = "AKIA..."
    message: Possible hardcoded AWS access key
    languages: [python, javascript]
    severity: ERROR

Clé	Objectif
`pattern`	Forme de code à analyser (`$X` = métavariable)
`patterns`	ET de plusieurs conditions
`pattern-either`	OU d’alternatives
`pattern-not`	Exclure une forme (tuer les faux positifs)
`pattern-inside`	Analyser uniquement à l’intérieur d’un contexte
`metavariable-regex`	Contraindre une métavariable
`severity`	INFO / WARNING / ERROR

Essentiels de la syntaxe Pattern

Syntaxe	Analyse
`$X`	N’importe quelle expression unique (métavariable)
`...`	N’importe quelle séquence (args, instructions)
`foo(...)`	N’importe quel appel à `foo`
`$OBJ.method(...)`	Appel de méthode sur n’importe quoi
`"..."`	N’importe quel littéral string

# Trouver eval() sur n'importe quelle entrée non-littérale
- pattern: eval($X)
  pattern-not: eval("...")

Règles Taint / Dataflow

rules:
  - id: sqli-taint
    mode: taint
    pattern-sources:
      - pattern: request.args.get(...)
    pattern-sinks:
      - pattern: cursor.execute($Q)
    message: Untrusted input reaches SQL execution
    languages: [python]
    severity: ERROR

Taint mode suit les données des sources (entrée non-fiable) aux sinks (opérations dangereuses), c’est comme ça qu’on trouve les vrais bugs d’injection plutôt que les faux-semblants syntaxiques.

Intégration CI

# Échouer le build sur les découvertes ERROR-severity
opengrep scan --config auto --error .

# Scanner uniquement les fichiers modifiés dans cette PR
opengrep scan --config auto --baseline-commit origin/main .

Flag	Effet
`--error`	Sortie non-zéro quand des découvertes existent
`--baseline-commit`	Scanning conscient des diffs (découvertes nouvelles uniquement)
`--severity ERROR`	Filtrer par severity
`--exclude`	Ignorer les chemins (vendor, tests)
`--sarif`	Uploader vers GitHub code scanning

Tester les règles

# Les règles s'accompagnent de fichiers de test annotés avec les découvertes attendues
opengrep test rules/

Annotez un fichier de test avec # ruleid: my-rule au-dessus d’une ligne qui devrait être analysée et # ok: my-rule où elle ne devrait pas — puis opengrep test vérifie le comportement de la règle.

Opengrep vs outils apparentés

Aspect	Opengrep	Semgrep	CodeQL
Licence	Entièrement open-source	Open core + commercial	Libre pour OSS, commercial restreint
Syntaxe de règle	Patterns ressemblant au code	Même héritage	Langage de requête QL
Courbe d’apprentissage	Basse	Basse	Haute
Idéal pour	SAST open-source sans feature gating	Plateforme gérée + règles	Requêtes sémantiques profondes

S’associe avec la connaissance Semgrep (les règles sont largement compatibles) et complète Bandit pour les checks spécifiques à Python.