Corriger les problèmes à l’aide du mode Agent de GitHub Copilot

  • 9 minutes

Après avoir analysé les problèmes de sécurité à l’aide du mode Ask, vous êtes prêt à implémenter des correctifs. Le mode Agent de GitHub Copilot vous permet d’exécuter des tâches de correction complexes en toute sécurité tout en garantissant que les fonctionnalités sont conservées et que la qualité du code est améliorée.

Note

Utilisez toujours le mode Demander de GitHub Copilot pour analyser les problèmes de sécurité et formuler un plan de correction avant d’utiliser le mode Agent pour implémenter des modifications. Cette approche garantit que la refactorisation est effectuée de manière réfléchie et sécurisée.

Qu’est-ce que le mode Agent ?

Le mode Agent de GitHub Copilot fonctionne de manière autonome pour exécuter des tâches de correction complexes dans votre codebase. Contrairement au mode Demander, qui fournit des conseils et des suggestions dans le panneau de conversation, le mode Agent implémente les mises à jour suggérées en tant que modifications directement dans vos fichiers de code.

Les fonctionnalités en mode Agent sont les suivantes :

  • Modification de fichiers avec des modifications de code précises.
  • Application simultanée de modifications sur plusieurs fichiers.
  • Exécution de tests pour vérifier les modifications.
  • Exécution de commandes basées sur vos instructions.
  • Présentation du contexte et des dépendances du projet.
  • Maintien de la cohérence dans la base de code.

Le mode agent est idéal pour implémenter des correctifs de sécurité en plusieurs étapes qui nécessitent une gestion minutieuse des dépendances, des cas de périphérie et des tests. Le mode agent définit automatiquement le contexte requis et exécute les étapes nécessaires pour atteindre vos objectifs de correction.

Corriger les problèmes de sécurité à l’aide du mode Agent

Vous pouvez utiliser le mode Agent pour implémenter les correctifs de sécurité identifiés lors de votre analyse du mode Demander. Le mode Agent peut exécuter automatiquement plusieurs étapes de correction tout en préservant les fonctionnalités d’origine et en améliorant la sécurité du code.

Stratégies de correction des problèmes de sécurité

Voici les stratégies clés d’utilisation du mode Agent pour résoudre les problèmes de sécurité :

  • Corriger les vulnérabilités d’injection : indiquez au mode Agent de remplacer la concaténation de chaîne par des requêtes paramétrables ou des instructions préparées.

  • Implémenter un chiffrement sécurisé : Permettez au mode Agent d'améliorer les algorithmes de hachage faibles en utilisant des alternatives sécurisées telles que bcrypt ou Argon2.

  • Nettoyage des logs : utilisez le mode Agent pour supprimer les données sensibles des logs tout en préservant des informations de diagnostic essentielles.

  • Valider les chemins d’accès aux fichiers : laissez le mode Agent ajouter une validation de chemin d’accès appropriée qui empêche les attaques de traversée de répertoire.

  • Ajouter une validation d’entrée : le mode Agent implémente la validation et l’assainissement complets des entrées.

  • Garantir la sécurité : demandez au mode Agent de vérifier que les correctifs conservent toutes les vérifications de sécurité existantes et n’introduisent pas de nouvelles vulnérabilités.

  • Gérer les fonctionnalités : utilisez le mode Agent pour préserver toute la logique métier et la gestion des erreurs existantes tout en améliorant la sécurité.

Le mode agent invite à corriger les problèmes de sécurité

Lorsque vous utilisez le mode Agent pour corriger les problèmes de sécurité, vos invites doivent être spécifiques, exploitables et inclure des considérations de sécurité. Voici des exemples de texte en langage naturel que vous pouvez inclure dans votre invite lors de la correction des problèmes de sécurité :

Préparation et sécurité

Ces indications vous aident à mettre en place des mesures de sécurité avant d’apporter des modifications liées à la sécurité à votre base de code.

  • « Avant d’effectuer des correctifs de sécurité, créez des tests unitaires qui vérifient le comportement actuel des fonctions sélectionnées. »
  • « Analysez le code sélectionné pour les dépendances et assurez-vous que les correctifs conservent toutes les fonctionnalités existantes. »
  • « Créez une branche de sauvegarde et exécutez des tests existants avant d’implémenter des correctifs de sécurité dans le code sélectionné . »

Opérations de correction de base

Utilisez ces consignes pour aborder les vulnérabilités de sécurité courantes avec des correctifs simples.

  • « Refactoriser la requête SQL sélectionnée pour utiliser des requêtes paramétrables au lieu de concaténation de chaînes . »
  • « Remplace le hachage de mot de passe MD5 sélectionné par bcrypt, en veillant à générer un saler approprié. »
  • « Supprimez les informations sensibles des entrées de journalisation sélectionnées en maintenant la valeur de diagnostic. »
  • « Ajoutez la validation du chemin d’accès aux opérations de fichier sélectionnées pour empêcher les attaques de traversée du répertoire. »

Modèles de correction avancés

Ces invites guident le mode Agent via des améliorations de sécurité plus complexes qui impliquent plusieurs composants ou modifications architecturales.

  • « Refactoriser la fonction d’authentification sélectionnée pour utiliser l’authentification sécurisée basée sur des jetons avec expiration appropriée. »
  • « Implémentez une validation complète des entrées pour les fonctions de traitement des données utilisateur sélectionnées. »
  • « Remplacez l’implémentation de chiffrement faible sélectionnée par le chiffrement AES-256 en suivant les meilleures pratiques. »
  • « Refactoriser la gestion des erreurs sélectionnée pour fournir des messages conviviaux lors de la journalisation des erreurs détaillées en toute sécurité. »

Qualité et validation

Utilisez ces messages pour vous assurer que les correctifs de sécurité répondent aux normes de qualité et n’introduisent pas de régressions.

  • « Après avoir implémenté des correctifs de sécurité, exécutez tous les tests et vérifiez que les fonctionnalités restent identiques. »
  • « Assurez-vous que le code fixe suit les directives de sécurité C# de Microsoft et les conventions de codage. »
  • « Vérifiez que les correctifs de sécurité n’introduisent pas de régressions de performances. »
  • « Créez des tests unitaires axés sur la sécurité pour vérifier que les vulnérabilités sont entièrement traitées. »

Flux de travail en mode Agent pour corriger les problèmes de sécurité

Suivez ce flux de travail systématique pour corriger les problèmes de sécurité à l’aide du mode Agent :

Étape 1 : Préparer votre espace de travail

Commencer par un espace de travail propre vous permet de suivre les modifications avec précision et de revenir en arrière si nécessaire.

Vérifiez que vous travaillez dans une branche Git nettoyée avec tous les travaux existants validés. Accédez au fichier contenant la vulnérabilité de sécurité analysée en mode Ask et préparez votre plan de correction à référencer.

Étape 2 : Configurer des mesures de sécurité

Créez des tests de référence avant d’apporter des modifications à votre code. Une fois les mises à jour du code terminées, utilisez des tests de base pour vérifier que les fonctionnalités restent intactes.

Avant d’apporter des modifications, créez des tests pour vérifier le comportement actuel.

Exemple d’invite : « Créer des tests unitaires complets pour la SearchProducts fonction afin de vérifier le comportement actuel avant d’implémenter des correctifs de sécurité ».

Le mode Agent crée des tests qui capturent le comportement actuel, fournissant une base de référence pour la validation.

Étape 3 : Commencer par les correctifs de sécurité critiques

La résolution des vulnérabilités les plus risquées garantit d’abord que les problèmes les plus dangereux sont résolus rapidement.

Commencez par les vulnérabilités les plus prioritaires.

Exemple d’invite : « Refactoriser la SearchProducts méthode pour utiliser des requêtes paramétrables au lieu de concaténation de chaîne. Vérifiez que tous les vecteurs d’injection SQL sont éliminés. »

Le mode agent analyse le code, remplace la concaténation de chaîne vulnérable par des requêtes paramétrables et ajoute la validation d’entrée pour éliminer la vulnérabilité d’injection SQL.

Étape 4 : Implémenter un chiffrement sécurisé

La mise à niveau du chiffrement faible protège les données sensibles, telles que les mots de passe, d’être compromis même si le stockage est enfreint.

Poursuivez avec les améliorations de chiffrement.

Exemple d’invite : « Remplace le hachage de mot de passe MD5 dans la méthode HashPassword par une implémentation bcrypt, y compris la génération de saler appropriée. »

Le mode agent met à niveau des algorithmes de hachage faibles pour sécuriser des alternatives telles que bcrypt, ajoute la validation de mot de passe et crée une méthode de vérification.

Étape 5 : Nettoyer la journalisation et la gestion des erreurs

La suppression des informations sensibles des journaux empêche l’exposition des données tout en conservant les fonctionnalités de diagnostic nécessaires au débogage.

Résolvez les problèmes de divulgation d’informations.

Exemple d’invite : « Supprime les informations sensibles des instructions de journalisation dans le module d’authentification tout en conservant la valeur de diagnostic ».

Le mode Agent supprime les données sensibles des journaux et remplace les messages d’erreur détaillés par des alternatives conviviales tout en préservant les informations de diagnostic dans les journaux sécurisés.

Étape 6 : Ajouter la validation du chemin d’accès

La validation des chemins d’accès aux fichiers empêche les attaquants d’accéder aux fichiers en dehors de l’étendue du répertoire prévu.

Implémentez la sécurité du chemin d’accès aux fichiers.

Exemple d’invite : « Ajoutez une validation exhaustive du chemin d’accès à la méthode SaveFile pour empêcher les attaques de traversée de répertoire ».

Le mode agent implémente la validation du chemin à l’aide Path.GetFileName()de , vérifie que les chemins restent dans les répertoires prévus et ajoute des vérifications pour les caractères non valides.

Étape 7 : Valider les modifications

Le test après chaque correctif majeur garantit que la vulnérabilité est résolue et qu’aucun nouveau problème n’a été introduit.

Après chaque correctif de sécurité majeur, validez les modifications.

Exemple d’invite : « Exécutez tous les tests unitaires et créez des tests spécifiques à la sécurité pour vérifier que la vulnérabilité d’injection SQL est entièrement corrigée ».

Le mode agent exécute des tests existants et crée d’autres tests de sécurité qui tentent des attaques par injection SQL pour vérifier que la vulnérabilité est résolue.

Étape 8 : Passer en revue et itérer

Résoudre les échecs de test et affiner les implémentations garantit que toutes les exigences sont remplies avant de prendre en compte la correction terminée.

Si des problèmes sont détectés, fournissez des instructions spécifiques pour les affinements.

Exemple d’invite : « Le test de validation de la longueur du mot de passe échoue. Mettez à jour la validation pour autoriser les mots de passe compris entre 8 et 128 caractères. »

Le mode agent analyse les tests défaillants et apporte des corrections nécessaires pour garantir que toutes les exigences sont remplies.

Cette approche structurée garantit que la correction est effectuée en toute sécurité et systématiquement, avec la validation à chaque étape.

Considérations relatives à la sécurité et à la qualité

Lorsque vous utilisez le mode Agent pour la correction de la sécurité, tenez toujours compte des implications en matière de sécurité et de qualité :

Bonnes pratiques de sécurité

Le suivi de ces pratiques de sécurité garantit que vos correctifs sont complets et n’introduisent pas de nouvelles vulnérabilités.

Tenez compte des pratiques de sécurité suivantes lors de la correction des vulnérabilités :

  • Valider soigneusement : vérifiez que toutes les validations d’entrée sont complètes et gèrent les cas de périphérie.
  • Conserver l’autorisation : vérifiez que les correctifs de sécurité ne contournent pas les vérifications d’authentification ou d’autorisation.
  • Maintenir la défense en profondeur : assurez-vous que plusieurs couches de sécurité restent intactes.
  • Passer en revue les dépendances : vérifiez que les correctifs de sécurité n’introduisent pas de dépendances vulnérables.
  • Test étendu : incluez à la fois des cas de test de sécurité positifs et négatifs.

Normes de qualité du code

Le maintien de la qualité du code en même temps que les améliorations de sécurité garantit que votre codebase reste maintenable et professionnel.

Conservez une qualité de code élevée en suivant les instructions suivantes :

  • Conventions suivantes : assurez-vous que le code fixe suit les conventions de codage C# de Microsoft.
  • Gérez la lisibilité : vérifiez que les correctifs de sécurité ne compromissent pas la clarté du code.
  • Modifications du document : ajoutez des commentaires expliquant le code critique de sécurité.
  • Documentation de mise à jour : vérifiez que README, les stratégies de sécurité et les documents d’API reflètent les modifications.
  • Tenez compte des performances : vérifiez que les améliorations de sécurité ne dégradent pas considérablement les performances.

Recommandations en matière de sécurité en mode agent

Le mode agent est puissant, mais nécessite une surveillance minutieuse.

Avant la remédiation

Prendre ces précautions avant de commencer la correction réduit le risque de perdre du travail ou d’introduire des changements cassants.

  • Travaillez toujours dans une branche de fonctionnalité.
  • Vérifiez que la couverture complète des tests existe.
  • Passez en revue le plan de correction à partir de l’analyse du mode Ask.
  • Comprendre la vulnérabilité de sécurité et ses effets potentiels.
  • Sauvegardez toutes les données ou configurations critiques.

Pendant la remédiation

Le suivi de ces pratiques lors de la correction vous permet de détecter et de résoudre les problèmes au fur et à mesure qu’ils surviennent plutôt que de les découvrir ultérieurement.

  • Apportez des modifications incrémentielles plutôt que des transformations volumineuses.
  • Validez chaque étape avant de passer à la suivante.
  • Passez en revue le code généré pour la correction et la sécurité.
  • Testez fréquemment pour détecter les problèmes tôt.
  • Surveillez les effets secondaires inattendus.

Après la correction

Ces étapes postérieures à la correction vérifient que vos correctifs sont terminés, corrects et prêts pour le déploiement.

  • Exécutez des tests complets, notamment des tests de sécurité.
  • Effectuez une révision du code avec les membres de l’équipe.
  • Valider les caractéristiques de sécurité à l’aide d’outils de sécurité.
  • Mettez à jour le problème GitHub avec les détails du correctif.
  • Documentez les leçons apprises pour une référence future.

Traitez le mode Agent comme un puissant assistant

Bien que le mode Agent puisse effectuer des tâches de correction complexes, il nécessite une supervision humaine :

  • Passez en revue toutes les modifications avant de les accepter.
  • Vérifiez que les vulnérabilités de sécurité sont entièrement traitées.
  • Vérifiez qu’aucune nouvelle vulnérabilité n’est introduite.
  • Testez soigneusement pour détecter les problèmes subtils.
  • Vérifiez la conformité avec les stratégies de sécurité.

Le mode agent accélère la correction de la sécurité, mais ne remplace pas la nécessité d’un examen et d’un test minutieux.

Intégration au flux de travail Git

Incorporez les modifications du mode Agent dans votre workflow Git en toute transparence à l’aide des outils intégrés de Visual Studio Code.

Valider les modifications à l’aide de la vue de contrôle de code source

La vue de contrôle de code source intégrée de Visual Studio Code simplifie le processus de validation et d’envoi de correctifs de sécurité à votre référentiel.

La vue contrôle de code source de Visual Studio Code offre un moyen intégré d’examiner et de valider vos correctifs de sécurité :

  1. Ouvrez la vue Contrôle de code source en sélectionnant l’icône Contrôle de code source dans la barre d’activité ou en appuyant sur Ctrl+Maj+G.

  2. Passez en revue les modifications répertoriées sous « Modifications » pour vérifier que tous les correctifs de sécurité sont inclus.

  3. Mettez en scène des fichiers en pointant dessus et en sélectionnant l’icône + ou en mettant en scène toutes les modifications à l’aide de l’icône + en regard de « Modifications ».

  4. Entrez un message de validation descriptif dans la zone de message qui fait référence au problème GitHub :

    Fix SQL injection vulnerability in SearchProducts

- Replace string concatenation with parameterized queries
- Add input validation for search terms
- Implement security tests for injection attempts

Fixes #42

    Note

    Pour lier vos validations aux problèmes GitHub, incluez le numéro de problème dans votre message de validation en utilisant la syntaxe Fixes #issue-number. Cette syntaxe ferme automatiquement le problème lorsque le commit est fusionné.

  5. Sélectionnez le bouton Valider pour valider vos modifications.

  6. Sélectionnez le bouton Synchroniser les modifications pour pousser votre branche vers le référentiel distant.

Vous pouvez également utiliser des commandes Git dans le terminal intégré :

# Stage all changes
git add .

# Commit with a descriptive message referencing the GitHub issue
git commit -m "Fix SQL injection vulnerability in SearchProducts

- Replace string concatenation with parameterized queries
- Add input validation for search terms
- Implement security tests for injection attempts

Fixes #42"

# Push changes to the remote repository
git push origin your-branch-name

Résumé

L’utilisation du mode Agent de GitHub Copilot permet aux développeurs de corriger efficacement les problèmes de sécurité tout en conservant la qualité et les fonctionnalités du code. En combinant les insights analytiques à partir du mode Ask avec les fonctionnalités d’exécution du mode Agent, vous pouvez résoudre systématiquement les vulnérabilités dans votre codebase. La clé du succès consiste à fournir des instructions claires, à maintenir les pratiques de sécurité, à valider soigneusement toutes les modifications et à garantir une documentation appropriée. Le mode Agent de GitHub Copilot est un assistant puissant qui accélère la correction. Toutefois, la supervision humaine reste essentielle pour garantir que les correctifs de sécurité sont complets, corrects et n’introduisent pas de nouvelles vulnérabilités.