Résoudre les alertes de sécurité GitHub à l’aide du mode Agent de GitHub Copilot
Après avoir analysé des alertes d’analyse des secrets en tirant parti du mode Demander, vous êtes prêt à implémenter la correction. Le mode Agent de GitHub Copilot vous permet d’exécuter systématiquement une suppression de secret complexe et une implémentation de stockage sécurisée tout en conservant les fonctionnalités de l’application.
Note
Utilisez toujours le mode Demander de GitHub Copilot pour analyser les alertes d’analyse des secrets et formuler un plan de correction avant d’utiliser le mode Agent pour implémenter des modifications. Cette approche garantit que la correction est complète et conserve les fonctionnalités de l’application.
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 la vue Conversation, le mode Agent implémente les modifications directement dans vos fichiers de code.
Les fonctionnalités en mode Agent sont les suivantes :
- Suppression de secrets codés en dur dans les fichiers de code.
- Implémentation d’une variable d’environnement ou d’un accès secret basé sur la configuration.
- Mise à jour de plusieurs fichiers de manière cohérente avec des modèles sécurisés.
- Ajout de fichiers de configuration et d’exemples nécessaires.
- Refactorisation du code pour utiliser l’injection de dépendances ou la configuration sécurisée.
- Exécution de tests pour vérifier que les modifications maintiennent les fonctionnalités.
Le mode agent est idéal pour implémenter la correction de secrets en plusieurs étapes qui nécessite des modifications coordonnées sur plusieurs fichiers, mises à jour de configuration et vérification des tests. Le mode agent détermine automatiquement le contexte requis et exécute les étapes nécessaires pour atteindre vos objectifs de correction.
Stratégies d’invite efficaces
Le mode Agent implémente les correctifs de sécurité identifiés pendant l’analyse du mode Ask. Les invites efficaces doivent être spécifiques, exploitables et inclure des considérations de sécurité.
Préparation et sécurité
Établissez des mesures de sécurité avant d’apporter des modifications à la gestion des informations d’identification.
Les instructions suivantes permettent de garantir un processus de remédiation sécurisé :
- Créez des tests unitaires qui vérifient le comportement actuel des fonctions de traitement de paiement sélectionnées avant d’apporter des modifications.
- Analysez le code sélectionné et documentez toutes les dépendances sur la clé API codée en dur.
- Créez une branche de sauvegarde avant d’implémenter les modifications de correction des secrets.
Suppression de secrets de base
GitHub Copilot Agent peut être utilisé pour traiter des expositions secrètes simples avec des alternatives sécurisées.
Les invites suivantes attribuent des tâches de suppression de secrets simples à GitHub Copilot Agent :
- « Supprimez la clé API Stripe codée en dur du code sélectionné et remplacez-la par l’accès aux variables d’environnement. »
- Refactoriser la chaîne de connexion de la base de données sélectionnée pour qu'elle soit lue depuis IConfiguration plutôt que d'être codée en dur.
- « Remplacez la clé de stockage Azure codée en dur dans le code sélectionné par l’accès Azure Key Vault . »
- « Supprimez le jeton d’accès personnel GitHub codé en dur et implémentez un accès sécurisé en fonction de la configuration. »
Considérez le scénario suivant :
Vous disposez de l’exemple de code suivant qui contient une clé API Stripe codée en dur :
// Before (hard-coded secret)
public class PaymentProcessor
{
private const string StripeKey = "sk_live_51Abc123...";
public async Task<bool> ProcessPayment(decimal amount)
{
StripeConfiguration.ApiKey = StripeKey;
// Process payment...
}
}
Vous assignez la tâche « Supprimer la clé API Stripe codée en dur du code sélectionné et la remplacer par l'accès via des variables d'environnement » au mode Agent de GitHub Copilot.
Le mode agent analyse le code, supprime les informations d’identification codées en dur et implémente l’accès aux variables d’environnement avec la gestion des erreurs appropriée :
// After (secure environment variable access)
public class PaymentProcessor
{
private readonly string _stripeKey;
public PaymentProcessor()
{
_stripeKey = Environment.GetEnvironmentVariable("STRIPE_API_KEY")
?? throw new InvalidOperationException(
"STRIPE_API_KEY environment variable is not configured. " +
"Please set this environment variable with your Stripe secret key.");
}
public async Task<bool> ProcessPayment(decimal amount)
{
StripeConfiguration.ApiKey = _stripeKey;
// Process payment...
}
}
Modèles de correction complets
GitHub Copilot Agent peut être utilisé pour implémenter des modèles de correction de secrets complets impliquant plusieurs composants ou modifications architecturales.
Les invites suivantes attribuent des tâches de correction complexes à GitHub Copilot Agent :
« Supprimez toutes les informations d’identification codées en dur de la classe PaymentProcessor sélectionnée et refactorisez-la pour utiliser l’injection de dépendances avec IConfiguration. »
« Implémentez la gestion sécurisée des secrets pour la classe de service sélectionnée à l’aide de variables d’environnement pour le développement et Azure Key Vault pour la production. »
« Refactorisez le module d’authentification sélectionné pour éliminer les informations d’identification codées en dur et utiliser ASP.NET système de configuration Core . »
« Supprimez les secrets codés en dur du code sélectionné et créez des exemples de configuration correspondants dans les fichiers appsettings.json et .env.example ».
Considérez le scénario suivant :
Vous disposez de l’exemple de code suivant qui contient une clé API Stripe codée en dur :
// Before (hard-coded secret)
public class PaymentProcessor
{
private const string StripeKey = "sk_live_51Abc123...";
public async Task<bool> ProcessPayment(decimal amount)
{
StripeConfiguration.ApiKey = StripeKey;
// Process payment...
}
}
Vous assignez la tâche « Supprimer toutes les informations d’identification codées en dur de la classe PaymentProcessor sélectionnée et la refactoriser pour utiliser l’injection de dépendances avec IConfiguration » au mode Agent de GitHub Copilot.
Le mode agent refactorise le code pour utiliser le système de configuration de ASP.NET Core :
// Improved configuration-based approach
public class PaymentProcessor
{
private readonly string _stripeKey;
public PaymentProcessor(IConfiguration configuration)
{
_stripeKey = configuration["Stripe:ApiKey"]
?? throw new InvalidOperationException(
"Stripe:ApiKey is not configured. " +
"Set this in appsettings.json, user secrets, or environment variables.");
}
public async Task<bool> ProcessPayment(decimal amount)
{
StripeConfiguration.ApiKey = _stripeKey;
// Process payment...
}
}
// In Program.cs or Startup.cs
services.AddScoped<PaymentProcessor>();
Pour plusieurs types de secrets, le mode Agent corrige systématiquement toutes les informations d’identification :
// Comprehensive configuration-based secret management
public class ApplicationServices
{
private readonly IConfiguration _configuration;
public ApplicationServices(IConfiguration configuration)
{
_configuration = configuration
?? throw new ArgumentNullException(nameof(configuration));
ValidateConfiguration();
}
private void ValidateConfiguration()
{
var requiredSettings = new[]
{
"Stripe:ApiKey",
"ConnectionStrings:DefaultConnection",
"Azure:StorageAccountKey"
};
var missingSettings = requiredSettings
.Where(setting => string.IsNullOrEmpty(_configuration[setting]))
.ToList();
if (missingSettings.Any())
{
throw new InvalidOperationException(
$"Required configuration missing: {string.Join(", ", missingSettings)}");
}
}
public string GetStripeKey() => _configuration["Stripe:ApiKey"];
public string GetConnectionString() => _configuration["ConnectionStrings:DefaultConnection"];
public string GetStorageKey() => _configuration["Azure:StorageAccountKey"];
}
Configuration et documentation
GitHub Copilot Agent peut être utilisé pour générer des modèles de configuration et une documentation pour prendre en charge la gestion sécurisée des secrets.
Les invites suivantes attribuent des tâches de documentation à GitHub Copilot Agent :
- « Créez un fichier appsettings.template.json affichant la structure de configuration requise sans valeurs secrètes réelles. »
- Ajoutez un fichier nommé ".env.example" documentant toutes les variables d'environnement requises pour l'application.
- « Mettez à jour le README.md pour inclure des instructions pour la configuration des clés API et des informations d’identification de base de données . »
- « Ajoutez des commentaires de code expliquant comment configurer les secrets de l’application en toute sécurité. »
Les deux premières tâches peuvent être utilisées pour générer des fichiers de documentation similaires aux exemples suivants :
// appsettings.template.json
{
"Stripe": {
"ApiKey": "your-stripe-secret-key-here",
"PublishableKey": "your-stripe-publishable-key-here"
},
"ConnectionStrings": {
"DefaultConnection": "your-connection-string-here"
}
}
# .env.example
STRIPE_API_KEY=sk_live_your_key_here
STRIPE_PUBLISHABLE_KEY=pk_live_your_key_here
DATABASE_CONNECTION_STRING=Server=your_server;Database=your_db;
Autres modèles de correction courants
Au-delà de l’accès à la configuration de base, certains types d’informations d’identification nécessitent des approches de gestion spécialisées.
Chaînes de connexion de base de données
GitHub Copilot Agent peut refactoriser les chaînes de connexion de base de données pour utiliser des connexions nommées à partir de fichiers de configuration.
Prenons l’exemple suivant où une chaîne de connexion codée en dur est remplacée par un accès basé sur la configuration :
// Pattern: Use named connection strings from configuration
public class DataContext : DbContext
{
public DataContext(DbContextOptions<DataContext> options)
: base(options)
{
}
}
// In Program.cs
services.AddDbContext<DataContext>(options =>
options.UseSqlServer(
configuration.GetConnectionString("DefaultConnection")
?? throw new InvalidOperationException("DefaultConnection not configured")));
Informations d’identification OAuth
GitHub Copilot Agent peut séparer les ID et secrets du client OAuth, ce qui garantit que les informations sensibles sont stockées en toute sécurité.
Prenons l’exemple suivant où les informations d’identification OAuth sont refactorisées pour un stockage sécurisé :
// Pattern: Separate client ID (public) from client secret (private)
public class OAuthConfiguration
{
public string ClientId { get; set; } // Can be in appsettings.json
public string ClientSecret { get; set; } // Must be in secure storage
public void Validate()
{
if (string.IsNullOrEmpty(ClientId))
throw new InvalidOperationException("OAuth ClientId not configured");
if (string.IsNullOrEmpty(ClientSecret))
throw new InvalidOperationException("OAuth ClientSecret not configured");
}
}
services.Configure<OAuthConfiguration>(configuration.GetSection("OAuth"));
Clés de chiffrement
GitHub Copilot Agent peut implémenter le chargement sécurisé des clés de chiffrement à partir de la configuration ou du stockage sécurisé.
Prenons l’exemple suivant où les clés de chiffrement sont chargées en toute sécurité :
// Pattern: Load encryption keys from secure storage
public class EncryptionService
{
private readonly byte[] _encryptionKey;
public EncryptionService(IConfiguration configuration)
{
var keyBase64 = configuration["Encryption:Key"]
?? throw new InvalidOperationException("Encryption key not configured");
_encryptionKey = Convert.FromBase64String(keyBase64);
if (_encryptionKey.Length != 32) // 256-bit key
throw new InvalidOperationException("Encryption key must be 256 bits");
}
}
Considérations relatives aux scénarios complexes
Différents scénarios de correction de secrets nécessitent des approches spécifiques.
Secrets dans plusieurs fichiers
Utilisez le mode Agent pour corriger toutes les occurrences de manière cohérente et implémenter un service de configuration centralisé que tous les composants utilisent.
Secrets avec plusieurs composants
Pour les informations d’identification avec plusieurs parties (ID client + secret, nom d’utilisateur + mot de passe), vérifiez que tous les composants sont déplacés vers le stockage sécurisé et utilisez des sections de configuration pour regrouper les paramètres associés.
Compatibilité descendante
Si vous conservez la compatibilité pendant la migration, effectuez les actions suivantes :
- Implémentez une logique de secours qui vérifie les variables d’environnement si la configuration est manquante.
- Consigner des avertissements lors de l'utilisation de méthodes déconseillées.
- Planifiez une chronologie de migration pour supprimer le code de secours.
Test avec des secrets
Utilisez la configuration fictive dans les tests unitaires, utilisez les informations d’identification de test (lorsqu’elles sont fournies par les services) dans les tests d’intégration et ne validez jamais les informations d’identification de test susceptibles d’accorder un accès réel.
Meilleures pratiques
Suivez ces pratiques pour une correction efficace et sûre.
Corriger de façon incrémentielle
Corrigez un type de secret à la fois, testez après chaque correction et validez les modifications de travail avant de passer au secret suivant. Cette approche facilite l’identification et la résolution des problèmes.
Utiliser le stockage secret approprié
Différents environnements nécessitent différentes approches. Par exemple:
- Secrets utilisateur ou fichiers .env pour le développement local.
- Secrets GitHub ou variables Azure Pipeline pour l’intégration continue/déploiement continu (CI/CD).
- Azure Key Vault pour la préproduction/production.
Flux de travail de correction
L’approche pas à pas suivante montre comment remédier aux alertes de détection de secrets de GitHub :
Changer immédiatement les informations d’identification : connectez-vous au tableau de bord du fournisseur de services, révoquez les informations d’identification exposées et générez un nouveau secret. La rotation des informations d’identification est l’étape de sécurité la plus critique : les informations d’identification exposées doivent être invalidées avant toute modification du code.
Préparer l’espace de travail : Valider ou mettre en attente toutes les modifications en attente et créer une branche Git propre pour la correction.
Analyser les dépendances : utilisez le mode Demander de GitHub Copilot pour analyser la façon dont le secret est utilisé, ce qu’il accède et pour identifier les dépendances de code.
Supprimer des secrets codés en dur : utilisez des invites détaillées pour affecter des tâches au mode Agent de GitHub Copilot. Par exemple, définissez une tâche qui remplace les secrets par des variables d’environnement ou un accès à la configuration.
Implémenter des modèles de configuration : appliquez des incitations de correction complètes pour effectuer une mise à niveau vers des systèmes d'injection de dépendances et de configuration appropriés.
Ajouter une documentation : utilisez les invites de configuration et de documentation pour créer des fichiers de modèle (appsettings.template.json, .env.example) et mettez à jour README avec des instructions de configuration.
Mettre à jour les tests : appliquez des invites de test et de validation pour refactoriser les tests pour la nouvelle approche basée sur la configuration.
Valider les modifications : générez l’application, exécutez tous les tests, testez manuellement les chemins critiques et passez en revue les modifications dans git avant de valider.
Supprimer de l’historique Git : utilisez git-filter-repo pour nettoyer les secrets de l’historique des référentiels.
Avertissement
La suppression des secrets de l’historique Git nécessite une réécriture de l’historique des référentiels et un envoi (push) forcé. Coordonnez-vous avec votre équipe avant de continuer.
Validation et document : passez en revue toutes les modifications, validez votre branche, configurez les nouvelles informations d’identification en toute sécurité dans votre environnement et finalisez la documentation avec des exigences de configuration complètes.