Comprendre les résultats de CodeQL

  • 5 minutes

Dans les unités précédentes, vous avez créé une base de données et analysé le fichier extrait de votre code. Vous pouvez maintenant afficher les résultats et déterminer s’il existe des vulnérabilités de sécurité à résoudre.

Les résultats de requête interprétés sont automatiquement affichés dans le code source de l’extension CodeQL pour Visual Studio Code. Les résultats de sortie générés par l’interface CLI CodeQL peuvent être dans de nombreux formats à utiliser avec différents outils.

Vous pouvez contrôler l’affichage des résultats d’analyse dans le code source en modifiant l’instruction d’une select requête. Vous pouvez rendre les résultats clairs et faciles à comprendre pour d’autres utilisateurs lors du développement de la requête. Lorsque vous écrivez vos propres requêtes dans la console de requête ou dans l’extension CodeQL pour Visual Studio Code, il n’existe aucune contrainte sur ce qui peut être sélectionné.

Si vous souhaitez utiliser une requête pour créer des alertes dans l’analyse du code GitHub ou générer des résultats d’analyse valides à l’aide de l’interface CLI CodeQL, vous devez faire en sorte que l’instruction select rapporte les résultats dans le format requis.

Flux de remédiation avec Copilot Autofix

Une fois que CodeQL identifie un problème, l’étape la plus importante consiste à la résoudre. GitHub intègre la détection avec correction en vous permettant de passer directement d’une alerte à un correctif proposé.

Correction des alertes avec Copilot Autofix

Lorsque vous ouvrez une alerte CodeQL sous l’onglet Sécurité, GitHub affiche des détails sur le problème, notamment le code affecté, la gravité et la façon dont le problème a été introduit.

Pour les alertes prises en charge, vous voyez également Copilot Autofix.

Copilot Autofix analyse l’alerte et génère une correction proposée. Cela inclut les éléments suivants :

  • Modification du code qui résout le problème
  • Explication de la raison pour laquelle le problème se produit
  • Conseils sur la façon dont le correctif résout le problème

Au lieu d’écrire manuellement un correctif à partir de zéro, vous commencez par une modification suggérée.

Un flux de travail classique ressemble à ceci :

  1. CodeQL s’exécute dans votre flux de travail et crée une alerte.
  2. Vous ouvrez l’alerte et examinez le code concerné.
  3. Copilot Autofix génère un correctif suggéré.
  4. Vous passez en revue l’explication et les modifications proposées.
  5. Vous appliquez le correctif, ce qui crée une pull request.
  6. La pull request exécute des vérifications et est examinée avant d’être fusionnée.

Ce flux de travail connecte la détection directement à la correction sans quitter l’interface GitHub.

Copilot Autofix n’applique pas les modifications automatiquement. Vous êtes responsable de l’examen et de l’approbation du correctif. Cela garantit que :

  • Le correctif s’aligne sur votre codebase.
  • Vous pouvez ajuster l’implémentation si nécessaire.
  • Les modifications passent par votre processus de révision existant.

La correction automatique est la plus efficace pour :

  • Modèles de vulnérabilité courants, tels que les risques d’injection ou l’utilisation d’API non sécurisée.
  • Problèmes pouvant être résolus avec une modification claire et localisée du code.

Pour des problèmes plus complexes, la correction automatique peut fournir des conseils, mais vous devrez peut-être modifier le correctif ou implémenter une solution personnalisée.

Correctifs suggérés dans les alertes

Même si la correction automatique n’est pas disponible, certaines alertes incluent des correctifs suggérés.

Ces suggestions :

  • Mettez en surbrillance la partie du code qui doit changer.
  • Fournissez des conseils sur la façon de résoudre le problème.

Vous pouvez utiliser ces suggestions comme point de départ lors de l’écriture de votre correctif.

Correction des dépendances avec Dependabot

Toutes les vulnérabilités ne proviennent pas de votre code. Certains sont introduits par le biais de dépendances.

Dependabot permet de résoudre ces problèmes automatiquement en procédant comme suit :

  • Détection des dépendances vulnérables.
  • Création de pull requests avec des versions mises à jour.
  • Vous permettant d’examiner et de fusionner les correctifs.

Ces pull requests suivent le même flux de travail qu’Autofix :

  1. Une modification est proposée.
  2. Les vérifications sont exécutées.
  3. La mise à jour a été examinée et fusionnée.

Cela rend la correction des dépendances cohérente avec la façon dont vous corrigez les problèmes de code d’application.

Automatisation des flux de travail de correction

Vous pouvez utiliser GitHub Actions pour automatiser la gestion des correctifs.

Par exemple, les flux de travail peuvent :

  • Exécutez des tests sur les pull requests Autofix ou Dependabot.
  • Appliquez des étiquettes en fonction de la gravité.
  • Exiger des approbations pour les modifications à haut risque.
  • Fusionnez automatiquement les mises à jour à faible risque.

Ces flux de travail garantissent que la correction est la suivante :

  • Cohérent au sein de l’équipe.
  • Validé avant la fusion.
  • Intégré à votre processus de développement.

De la détection à la résolution

Dans un workflow complet :

  1. CodeQL détecte une vulnérabilité.
  2. Copilot Autofix suggère un correctif.
  3. Une pull request est créée.
  4. GitHub Actions valident la modification.
  5. Le correctif est examiné et fusionné.

En combinant l’analyse CodeQL avec Copilot correction automatique, Dependabot et automatisation des flux de travail, vous créez un système qui trouve non seulement des problèmes, mais qui aide également à les résoudre efficacement.

Traiter les alertes d'analyse de code

Vous pouvez configurer l’analyse du code pour vérifier le code dans un référentiel. Vous pouvez utiliser l’analyse CodeQL par défaut, une analyse non-Microsoft ou d’autres types d’analyse. Les alertes résultantes sont affichées les unes avec les autres dans le référentiel.

L’analyse CodeQL par défaut de GitHub peut inclure plus de propriétés pour les alertes que les résultats des outils non-Microsoft ou des requêtes personnalisées. Dans un workflow par défaut, l’analyse du code analyse régulièrement votre code sur la branche par défaut et pendant les pull requests.

Chaque alerte inclut les informations suivantes :

  • Problème avec le code et le nom de l’outil qui l’a identifié.
  • Ligne de code qui a déclenché l’alerte.
  • Propriétés de l’alerte, telles que la gravité.
  • Gravité de la menace pour la sécurité.
  • Le point où le problème a été introduit.
  • La nature du problème.

Les informations incluent également comment résoudre le problème lorsque l’analyse CodeQL identifie une alerte. En outre, l’analyse du code via CodeQL peut détecter les problèmes de flux de données dans votre code.

Capture d’écran des alertes d’analyse CodeQL dans GHAS.

En plus de résoudre manuellement les vulnérabilités, vous pouvez automatiser la correction des dépendances à l’aide des mises à jour de sécurité de Dependabot.

Lorsque Dependabot détecte une dépendance vulnérable, il crée une pull request pour mettre à jour la dépendance. Ces pull requests peuvent être intégrées dans des flux de travail automatisés pour rationaliser la remédiation.

Automatisation de la correction des dépendances avec Dependabot

Un workflow d’automatisation classique suit ce modèle :

  1. Dependabot crée une pull request pour mettre à jour une dépendance vulnérable.
  2. Un flux de travail GitHub Actions est déclenché sur l’événementpull_request.
  3. Le flux de travail vérifie si la pull request a été créée par dependabot[bot].
  4. Les métadonnées relatives à la mise à jour (par exemple, le type de dépendance ou la modification de version) peuvent être utilisées pour déterminer l’action suivante.
  5. Le flux de travail exécute des vérifications de validation, applique des étiquettes ou active la fusion automatique pour les mises à jour à faible risque.

L’exemple suivant montre un flux de travail de GitHub Actions simple qui s’exécute uniquement pour les requêtes pull Dependabot. Il valide la mise à jour et peut activer la fusion automatique après la réussite des vérifications.

name: Dependabot remediation

on:
  pull_request:
    branches:
      - main

permissions:
  pull-requests: write

jobs:
  dependabot:
    if: github.event.pull_request.user.login == 'dependabot[bot]'
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Run tests
        run: npm test

      - name: Enable auto-merge for approved updates
        if: ${{ success() }}
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          PR_URL: ${{ github.event.pull_request.html_url }}
        run: gh pr merge --auto --merge "$PR_URL"

Cette approche aide les équipes à réduire les efforts manuels tout en s’assurant que les mises à jour des dépendances sont validées avant d’être fusionnées.

Dans les scénarios de production, la fusion automatique est généralement limitée aux mises à jour à faible risque, telles que les mises à jour correctives et combinées avec les règles de protection de branche, les vérifications d’état requises et les stratégies de révision.

Notification des équipes sur l’activité de correction

Pour améliorer la visibilité des mises à jour des dépendances, les équipes intègrent souvent Dependabot aux systèmes de notification externes.

Outre les notifications GitHub, vous pouvez utiliser :

  • Intégrations Slack ou Microsoft Teams pour une meilleure visibilité au sein de l’équipe.
  • GitHub webhooks pour les intégrations personnalisées et les pipelines d’automatisation.

Par exemple, un flux de travail ou un webhook peut notifier une équipe quand :

  • Une pull request Dependabot est ouverte.
  • Échec des vérifications de validation.
  • Une mise à jour de sécurité a été intégrée.

Ces notifications aident les équipes à répondre rapidement lorsque la correction nécessite une attention particulière.

Alertes de flux de données

L’analyse du flux de données détecte des problèmes de sécurité potentiels dans le code, notamment :

  • L’utilisation de données de manière à compromettre la sécurité.
  • Passage d’arguments dangereux à des fonctions.
  • Fuite d’informations sensibles.

GitHub vous montre comment les données se déplacent dans le code lorsqu'une analyse du code signale des alertes sur le flux de données. Vous pouvez utiliser ces alertes de flux de données pour identifier les zones de votre code qui fuitent des informations sensibles. Ces connaissances peuvent vous aider à identifier le point d’entrée pour les attaques par des utilisateurs malveillants.

Niveaux de gravité

Tous les résultats de l’analyse de code dont le niveau de gravité est Erreur entraînent l’échec de la vérification par défaut.

Les niveaux de gravité des alertes sont les suivants :

  • Error
  • Warning
  • Note

Vous pouvez spécifier le niveau de gravité auquel les demandes de tirage qui déclenchent des alertes d'analyse de code doivent échouer.

Niveaux de gravité de sécurité

Les requêtes de sécurité générées par l’analyse du code affichent des niveaux de gravité de sécurité pour les alertes.

Les niveaux de gravité de sécurité sont les suivants :

  • Essentiel
  • Élevé
  • Moyenne
  • Faible

GitHub utilise des données CVSS (Common Vulnerability Scoring System) pour calculer la gravité de sécurité d’une alerte.

Les résultats de l’analyse du code ayant une gravité de sécurité critique ou élevée provoquent un échec de vérification par défaut. Vous pouvez spécifier le niveau de gravité de sécurité qui doit entraîner un échec de vérification des résultats de l’analyse du code.

Fermer une alerte d’analyse du code

Vous avez deux façons de fermer une alerte :

  • Corrigez le problème dans le code.
  • Ignorer ou supprimer l’alerte.

Ignorer une alerte d’analyse du code

Le rejet d'une alerte est un moyen de fermer une alerte qui, selon vous, ne doit pas être corrigée. Par exemple, vous pouvez ignorer une alerte pour une erreur dans le code utilisé uniquement pour les tests. Vous pouvez également ignorer une alerte si l’effort nécessaire pour corriger l’erreur est supérieur à l’avantage potentiel d’améliorer le code.

Vous pouvez ignorer les alertes des annotations d’analyse du code dans le code ou de la liste récapitulative sous l’onglet Sécurité . Pour ignorer une alerte dans la liste, sélectionnez le menu Ignorer l’alerte , sélectionnez une raison de licenciement, puis sélectionnez le bouton Ignorer l’alerte .

Animation montrant le menu déroulant et le bouton permettant d’ignorer une alerte d’analyse du code.

Lorsque vous ignorez une alerte :

  • L’alerte est ignorée dans toutes les branches.
  • L’alerte est supprimée du nombre d’alertes actuel pour votre projet.
  • L’alerte est déplacée vers la liste fermée dans le résumé des alertes. Vous pouvez le rouvrir à partir de là si nécessaire.
  • La raison pour laquelle vous avez fermé l’alerte est enregistrée.
  • La prochaine fois que l’analyse du code s’exécute, le même code ne génère pas d’alerte.