CodeQL : à quoi ça sert et pourquoi l'utiliser en 2026

CodeQL est un moteur d'analyse statique sémantique développé par Semmle (racheté par GitHub en 2019) qui sert de fondation à GitHub Code Scanning et GitHub Advanced Security. Sa particularité : il traite le code comme une base de données interrogeable via un langage de requête dédié (QL), ce qui permet de tracer les flux de données à travers fonctions, fichiers et modules. Son usage principal en 2026 couvre trois cas : détection automatisée de vulnérabilités dans les pipelines CI/CD (SAST en continu), variant analysis par les équipes de security research pour trouver toutes les instances d'une classe de bug connue, et enforcement de règles d'architecture (APIs dépréciées, fonctions bannies, authentification obligatoire). Il supporte 12 langages (C, C++, C#, Go, Java, Kotlin, JavaScript, TypeScript, Python, Ruby, Swift, Rust) et s'intègre trivialement aux workflows GitHub. Cet article détaille son fonctionnement interne, ses cas d'usage, ses queries, son positionnement vs Semgrep et SonarQube, et ses limites.

Définition et genèse

CodeQL est né chez Semmle, une entreprise d'Oxford fondée en 2006 autour du langage de requête QL développé par des universitaires. Semmle a été acquise par GitHub en septembre 2019, et CodeQL est depuis devenu le moteur officiel du Code Scanning GitHub.

Timeline CodeQL :
 
  2006  Fondation Semmle à Oxford
  2015  Introduction du langage QL (base logique)
  2019  Rachat de Semmle par GitHub
  2020  Lancement de GitHub Code Scanning (GA)
  2022  Intégration profonde avec GitHub Advanced Security
  2024  Support Rust en GA
  2025  Support renforcé Kotlin, améliorations ML-powered
  2026  12 langages supportés, maturité industrielle

L'objectif initial : permettre aux chercheurs en sécurité de scaler leur expertise - décrire une classe de vulnérabilité une fois, trouver toutes ses occurrences dans n'importe quelle codebase.

Comment ça marche : code as data

La différence fondamentale entre CodeQL et un SAST classique (type Semgrep, Bandit, SonarQube) tient en un mot : sémantique.

Étape 1 - Extraction

CodeQL compile le code source en une base de données relationnelle structurée. Cette extraction capture :

• L'arbre syntaxique complet (AST).
• Les relations inter-fichiers (imports, inclusions, héritage).
• Le graphe d'appel (quelle fonction appelle quelle autre).
• Le flux de données (taint tracking primitive).
• Les types et la résolution de symboles.

Code source (plusieurs milliers de fichiers)
       ↓ codeql database create
Base de données CodeQL (tables SQL-like)
       ↓ codeql query run
Résultats des analyses (SARIF, CSV, JSON)

Étape 2 - Requêtes QL

QL est un langage déclaratif à la syntaxe logique (issu du Datalog). Un exemple simple pour détecter les appels à eval() sur des données utilisateur en Python :

/**
 * @name Unsafe eval on user input
 * @description Using eval on untrusted data can lead to code injection.
 * @kind path-problem
 * @severity error
 * @id py/unsafe-eval
 */
 
import python
import semmle.python.security.dataflow.CodeInjectionQuery
import CodeInjectionFlow::PathGraph
 
from CodeInjectionFlow::PathNode source, CodeInjectionFlow::PathNode sink
where CodeInjectionFlow::flowPath(source, sink)
select sink.getNode(), source, sink, "This eval uses unvalidated data from $@.",
       source.getNode(), "user input"

Cette requête prend en entrée toutes les sources de données utilisateur (source), tous les sinks dangereux (eval, exec, compile), et retourne les chemins où une source atteint un sink sans passage par un sanitizer reconnu. C'est du taint tracking inter-procédural automatisé.

Étape 3 - Résultats

Les résultats sortent en format SARIF (Static Analysis Results Interchange Format) - standard OASIS adopté par GitHub, GitLab, Azure DevOps, VS Code. Ils incluent non seulement le point de découverte, mais aussi le chemin complet de la donnée depuis la source jusqu'au sink, avec tous les nœuds intermédiaires.

Langages supportés en 2026

Langages non supportés nativement qui demandent des alternatives :

• PHP : Psalm, Phan, Semgrep.
• Lua, Dart, Zig, Haskell : Semgrep (couverture partielle).
• Scala, Clojure, Elixir : SonarQube (détection basique).
• Assembleur, shell scripts : outils spécifiques (ShellCheck pour bash).

Cas d'usage principaux

Cas 1 - SAST en continu dans le pipeline CI/CD

Usage le plus répandu. CodeQL tourne automatiquement sur chaque PR via GitHub Actions, les résultats remontent dans l'onglet Security du repo et bloquent éventuellement le merge.

# .github/workflows/codeql.yml - configuration minimale
name: CodeQL
 
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  schedule:
    - cron: '0 3 * * 1'  # lundi 3h UTC
 
jobs:
  analyze:
    name: Analyze
    runs-on: ubuntu-latest
    permissions:
      actions: read
      contents: read
      security-events: write
 
    strategy:
      fail-fast: false
      matrix:
        language: [python, javascript-typescript]
 
    steps:
      - uses: actions/checkout@v4
 
      - name: Initialize CodeQL
        uses: github/codeql-action/init@v3
        with:
          languages: ${{ matrix.language }}
          queries: security-extended,security-and-quality
 
      - name: Autobuild
        uses: github/codeql-action/autobuild@v3
 
      - name: Perform CodeQL Analysis
        uses: github/codeql-action/analyze@v3
        with:
          category: "/language:${{ matrix.language }}"

Les résultats apparaissent automatiquement dans :

• L'onglet Security > Code scanning alerts du repo.
• Les commentaires de pull request.
• La file de merge protégée si les règles de branche sont configurées.

Cas 2 - Variant analysis en security research

C'est l'usage original de CodeQL et ce qui distingue le plus de ses concurrents. Un chercheur découvre une vulnérabilité (par exemple une CVE) et écrit une requête QL qui décrit le pattern de la faille. Il exécute ensuite cette requête sur des milliers de projets open source pour trouver toutes les variantes.

Exemples publics documentés par GitHub Security Lab :

CVE-2021-3156 (sudo Baron Samedit)
  Pattern : heap buffer overflow sur parsing argv
  Variants trouvés : 4 autres projets avec le même pattern
 
CVE-2022-22965 (Spring4Shell)
  Pattern : deserialization via ClassLoader
  Variants trouvés : dépendances tierces non patchées
 
CVE-2021-44228 (log4shell)
  Pattern : JNDI lookup sur input utilisateur
  Variants trouvés : plusieurs bibliothèques dérivées

Cette approche permet à une équipe security research de convertir une trouvaille unique en campagne de détection industrielle.

Cas 3 - Enforcement de règles d'architecture

Utilisation moins connue mais puissante : faire tourner CodeQL pour vérifier des propriétés architecturales spécifiques à votre codebase.

Règles typiques implémentables en QL custom :
 
  Aucune fonction sensible sans décorateur @requires_auth
  Aucun appel direct à DB sans passer par le repository layer
  Interdiction d'importer module deprecated_v1
  Vérification que tout PII passe par le module encryption
  Ban de certaines fonctions dangereuses (strcpy, gets, md5.new)

Plus expressif qu'un simple grep ou un linter de style.

CodeQL vs Semgrep vs SonarQube

Les trois outils dominent le SAST en 2026 mais couvrent des cas différents.

Stratégie combinée 2026

La plupart des équipes DevSecOps matures combinent les trois :

Sur chaque pull request (feedback < 2 min) :
  Semgrep       → patterns rapides, ROI immédiat
 
Nightly ou hebdomadaire (analyse profonde) :
  CodeQL        → sémantique, variant analysis
 
Continu avec portail qualité :
  SonarQube     → qualité code + détection basique sécu

Écosystème et queries disponibles

Query packs standards

GitHub maintient des query packs officiels gratuits :

• codeql/python-queries
• codeql/javascript-queries
• codeql/java-queries
• codeql/go-queries
• codeql/cpp-queries
• codeql/ruby-queries
• codeql/rust-queries

Chaque pack contient des centaines de requêtes catégorisées :

security-extended      : toutes les règles de sécurité
security-and-quality   : sécurité + qualité (plus lourd)
code-scanning          : pack de base Code Scanning
experimental           : règles nouvelles en validation

Requêtes communautaires

Le dépôt advanced-security/awesome-codeql agrège :

• Requêtes écrites par GitHub Security Lab.
• Contributions communautaires.
• Requêtes de conférences (Black Hat, DEF CON, Offensivecon).
• Templates réutilisables par langage.

Limites et pièges

Temps d'analyse

Contrairement à Semgrep (secondes), CodeQL demande 5 à 30 minutes par analyse sur un repo moyen. Sur une monorepo, cela peut monter à plusieurs heures. GitHub propose monorepo-code-scanning-action pour limiter l'analyse aux parties changées d'une PR.

Faux positifs sur code récent ou exotique

CodeQL excelle sur le code mainstream mais peut hallucinations sur :

• Frameworks très récents ou internes (pas de modèle de sink/source).
• Métaprogrammation dynamique lourde (Python decorators complexes, Ruby metaprogramming).
• Code généré automatiquement.

Configuration build nécessaire pour langages compilés

Pour C, C++, C#, Go, Java, Kotlin, Swift, Rust, CodeQL doit builder le projet pour extraire la base de données. autobuild fonctionne pour les cas standards, mais les builds custom (scripts maison, toolchains internes) demandent souvent une configuration manuelle.

Licence commerciale hors GitHub

Le CLI CodeQL et les queries sont open source (licence CodeQL Research Terms & Conditions + MIT pour les queries). Mais l'usage commercial hors GitHub est soumis à la licence GitHub. Pour les équipes qui utilisent GitLab ou Bitbucket en production, le détour par une licence GitHub Advanced Security ou une alternative est souvent nécessaire.

Courbe d'apprentissage QL

Écrire ses propres queries demande 2-4 semaines d'investissement initial. QL est puissant mais exotique : syntaxe logique, typage fort, bibliothèque vaste. Pour 80 % des équipes, se contenter des query packs standards est largement suffisant.

Installation et premier scan local

# macOS via Homebrew
brew install codeql
 
# Linux
wget https://github.com/github/codeql-cli-binaries/releases/latest/download/codeql-linux64.zip
unzip codeql-linux64.zip && export PATH=$PWD/codeql:$PATH
 
# Téléchargement query packs
codeql pack download codeql/python-queries
 
# Créer une base CodeQL sur un projet Python
cd my-python-project
codeql database create codeql-db --language=python
 
# Exécuter les requêtes standards
codeql database analyze codeql-db \
  codeql/python-queries \
  --format=sarif-latest \
  --output=results.sarif
 
# Visualiser dans VS Code avec l'extension CodeQL
code results.sarif

Stack recommandée DevSecOps incluant CodeQL

Sur chaque PR (rapide, bloquant possible) :
  Semgrep p/owasp-top-ten        → patterns, ~30 s
  gitleaks                       → secrets, ~10 s
  Dependabot / Renovate          → dépendances, ~1 min
  Trivy sur image                → CVE conteneur, ~1 min
 
Nightly ou hebdomadaire (profond) :
  CodeQL analyze security-extended → sémantique, 5-30 min
  Snyk full scan                 → SCA deep + container
  OSV-Scanner                    → CVE dépendances
 
Quarterly ou ad hoc :
  Custom CodeQL queries          → variant analysis sur CVE
  Pentest manuel                 → logique métier

Points clés à retenir

• CodeQL est un SAST sémantique open source (licence restreinte commerciale hors GitHub) développé par Semmle puis GitHub. Il compile le code en base de données interrogeable via QL et trace les flux de données inter-procéduraux.
• 12 langages en 2026 : C, C++, C#, Go, Java, Kotlin, JavaScript, TypeScript, Python, Ruby, Swift, Rust.
• 3 cas d'usage principaux : SAST en CI/CD via GitHub Code Scanning, variant analysis par security research (scaling d'une CVE à toutes ses variantes), enforcement de règles d'architecture custom.
• Différenciateur majeur vs Semgrep : taint tracking profond inter-procédural. CodeQL trace un eval(transform(user_input)) là où Semgrep s'arrête au pattern direct.
• Limites : 5-30 minutes de temps d'analyse, build complet requis pour langages compilés, licence commerciale restrictive hors GitHub, courbe QL raide pour écrire des queries custom.
• Stack recommandée 2026 : Semgrep + gitleaks + Dependabot + Trivy sur chaque PR (rapide) + CodeQL nightly + pentest manuel annuel.
• Gratuit pour repos publics GitHub et security research. Commercial repos privés via GitHub Advanced Security (inclus Enterprise ou ~49 USD / committer actif / mois).

Pour comprendre le positionnement SAST vs DAST et quand utiliser CodeQL dans un pipeline complet, voir SAST vs DAST : comparaison complète. Pour savoir où intégrer CodeQL dans un pipeline complet avec scan conteneur et SBOM, lire scan de conteneurs : pourquoi et comment et différence entre DevOps et DevSecOps. Pour un parcours d'apprentissage complet qui inclut CodeQL, la roadmap DevSecOps 2026 détaille les 4 étapes.