Resolución de alertas de seguridad de GitHub mediante el modo agente de GitHub Copilot

11 minutos

Después de analizar las alertas de escaneo secreto utilizando el modo Preguntar, estará listo para implementar la corrección. El modo agente de GitHub Copilot le permite ejecutar la eliminación compleja de secretos y la implementación de almacenamiento seguro sistemáticamente al tiempo que mantiene la funcionalidad de la aplicación.

Nota:

Use siempre el modo Preguntar de GitHub Copilot para analizar alertas de análisis de secretos y formular un plan de corrección antes de usar el modo agente para implementar los cambios. Este enfoque garantiza que la corrección sea completa y conserve la funcionalidad de la aplicación.

¿Qué es el modo agente?

El modo agente de GitHub Copilot funciona de forma autónoma para ejecutar tareas de corrección complejas en el código base. A diferencia del modo Ask, que proporciona instrucciones y sugerencias en la vista Chat, el modo agente implementa los cambios directamente en los archivos de código.

Las funcionalidades del modo agente incluyen:

Eliminación de secretos codificados en los archivos de código.
Implementación del acceso a secretos mediante variables de entorno o configuración.
Actualizar varios archivos de forma coherente con patrones seguros.
Agregar ejemplos y archivos de configuración necesarios.
Refactorización de código para usar la inserción de dependencias o la configuración segura.
Ejecutar pruebas para comprobar que los cambios mantienen la funcionalidad.

El modo de agente es ideal para implementar la corrección de secretos de varios pasos que requiere cambios coordinados en varios archivos, actualizaciones de configuración y comprobación de pruebas. El modo de agente determina automáticamente el contexto necesario y ejecuta los pasos necesarios para lograr los objetivos de corrección.

Estrategias de incitación eficaces

El modo de agente implementa las correcciones de seguridad identificadas durante el análisis del modo Preguntar. Las indicaciones eficaces deben ser específicas, accionables e incluyen consideraciones de seguridad.

Preparación y seguridad

Establezca medidas de seguridad antes de realizar cambios en la administración de credenciales.

Las siguientes indicaciones ayudan a garantizar un proceso de corrección seguro:

Cree pruebas unitarias que comprueben el comportamiento actual de las funciones de procesamiento de pagos seleccionadas antes de realizar cambios.
Analice el código seleccionado y documente todas las dependencias en la clave de API codificada de forma rígida.
Cree una rama de respaldo antes de implementar cambios de corrección secretos.

Eliminación básica de secretos

El agente de Copilot de GitHub se puede usar para abordar exposiciones secretas sencillas con alternativas seguras.

Las siguientes indicaciones asignan tareas sencillas de eliminación de secretos al agente de GitHub Copilot:

"Quite la clave de API stripe codificada de forma rígida del código seleccionado y reemplácela por el acceso a variables de entorno".
Refactorice la cadena de conexión de base de datos seleccionada para leer desde IConfiguration en lugar de ser codificada de forma rígida.
"Reemplace la clave de Azure Storage codificada de forma rígida en el código seleccionado por el acceso a Azure Key Vault".
"Quite el token de acceso personal de GitHub codificado de forma rígida e implemente el acceso seguro basado en la configuración".

Considere el caso siguiente:

Tiene el siguiente ejemplo de código que contiene una clave de API stripe codificada de forma rígida:

// 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...
    }
}

Asigne la tarea "Quitar la clave de API de Stripe codificada de forma fija del código seleccionado y reemplazarla con acceso mediante variables de entorno" al modo agente de GitHub Copilot.

El modo de agente analiza el código, quita la credencial codificada de forma rígida e implementa el acceso a variables de entorno con el control de errores adecuado:

// 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...
    }
}

Patrones completos de remediación

El agente de Copilot de GitHub se puede usar para implementar patrones completos de corrección de secretos que implican varios componentes o cambios arquitectónicos.

Las siguientes indicaciones asignan tareas de corrección complejas al agente de Copilot de GitHub:

"Quite todas las credenciales codificadas de forma rígida de la clase PaymentProcessor seleccionada y refactorice para usar la inserción de dependencias con IConfiguration".
"Implemente la administración segura de secretos para la clase de servicio seleccionada mediante variables de entorno para el desarrollo y Azure Key Vault para producción".
"Refactorice el módulo de autenticación seleccionado para eliminar las credenciales codificadas de forma rígida y use ASP.NET sistema de configuración core".
"Quite secretos codificados de forma rígida del código seleccionado y cree ejemplos de configuración correspondientes en appsettings.json y archivos .env.example".

Considere el caso siguiente:

Tiene el siguiente ejemplo de código que contiene una clave de API stripe codificada de forma rígida:

// 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...
    }
}

Usted asigna la tarea "Eliminar todas las credenciales codificadas de manera rígida de la clase PaymentProcessor seleccionada y refactorizarla para usar la inyección de dependencias con IConfiguration" al modo Agente de GitHub Copilot.

El modo de agente refactoriza el código para utilizar el sistema de configuración 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>();

Para varios tipos de secretos, el modo de agente corrige sistemáticamente todas las credenciales:

// 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"];
}

Configuración y documentación

El agente GitHub Copilot se puede usar para generar plantillas de configuración y documentación para apoyar la gestión segura de secretos.

Las siguientes solicitudes asignan tareas de documentación al agente de GitHub Copilot:

"Cree un archivo appsettings.template.json que muestre la estructura de configuración necesaria sin valores secretos reales".
"Agregue un archivo ".env.example" que documente todas las variables de entorno necesarias para la aplicación".
"Actualice el README.md para incluir instrucciones para configurar las claves de API y las credenciales de base de datos".
"Agregar comentarios de código que explican cómo configurar los secretos de la aplicación de forma segura".

Las dos primeras tareas se pueden usar para generar archivos de documentación similares a los ejemplos siguientes:

// 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;

Otros patrones de corrección comunes

Más allá del acceso básico a la configuración, determinados tipos de credenciales requieren enfoques de control especializados.

Cadenas de conexión de base de datos

El Agente Copilot de GitHub puede refactorizar las cadenas de conexión de bases de datos para usar conexiones nombradas de los archivos de configuración.

Tenga en cuenta el ejemplo siguiente en el que se reemplaza una cadena de conexión codificada de forma rígida por el acceso basado en la configuración:

// 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")));

Credenciales de OAuth

El agente de Copilot de GitHub puede separar los identificadores y secretos del cliente de OAuth, lo que garantiza que la información confidencial se almacena de forma segura.

Considere el ejemplo siguiente en el que las credenciales de OAuth se refactorizarán para el almacenamiento seguro:

// 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"));

Claves de cifrado

El agente de Copilot de GitHub puede implementar la carga segura de claves de cifrado desde la configuración o el almacenamiento seguro.

Tenga en cuenta el ejemplo siguiente en el que las claves de cifrado se cargan de forma segura:

// 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");
    }
}

Consideraciones para escenarios complejos

Los distintos escenarios de corrección de secretos requieren enfoques específicos.

Secretos en varios archivos

Use el modo agente para corregir todas las apariciones de forma coherente e implementar un servicio de configuración centralizado que usan todos los componentes.

Secretos con varios componentes

En el caso de las credenciales con varias partes (id. de cliente + secreto, nombre de usuario y contraseña), asegúrese de que todos los componentes se mueven al almacenamiento seguro y usan secciones de configuración para agrupar la configuración relacionada.

Compatibilidad con versiones anteriores

Si mantiene la compatibilidad durante la migración, realice las siguientes acciones:

Implemente la lógica de respaldo que verifique las variables de entorno en caso de que falte la configuración.
Registra advertencias al usar métodos en desuso.
Planee un cronograma de migración para quitar el código de contingencia.

Pruebas con secretos

Use la configuración ficticia en pruebas unitarias, use credenciales de prueba (cuando se proporcionan por servicios) en pruebas de integración y nunca confirme las credenciales de prueba que podrían conceder acceso real.

procedimientos recomendados

Siga estos procedimientos para una corrección eficaz y segura.

Corregir incrementalmente

Corrija un tipo de secreto a la vez, pruebe después de cada corrección y confirme los cambios de trabajo antes de pasar al siguiente secreto. Este enfoque facilita la identificación y resolución de problemas.

Uso del almacenamiento secreto adecuado

Los distintos entornos requieren enfoques diferentes. Por ejemplo:

Secretos de usuario o archivos .env para el desarrollo local.
Secretos de GitHub o variables de Azure Pipeline para la integración continua/implementación continua (CI/CD).
Azure Key Vault para entornos de prueba o producción.

Flujo de trabajo de corrección

El siguiente enfoque paso a paso muestra cómo corregir alertas de análisis de secretos de GitHub:

Rotar las credenciales inmediatamente: inicie sesión en el panel del proveedor de servicios, revoque la credencial expuesta y genere un nuevo secreto. La rotación de credenciales es el paso de seguridad más crítico: las credenciales expuestas deben invalidarse antes de que cambie el código.
Preparación del área de trabajo: confirme o guarde todos los cambios pendientes y cree una rama de Git limpia para la corrección.
Analizar dependencias: use el modo Preguntar de GitHub Copilot para analizar cómo se usa el secreto, lo que accede y para identificar las dependencias de código.
Quitar secretos codificados de forma rígida: use avisos detallados para asignar tareas al modo agente de GitHub Copilot. Por ejemplo, defina una tarea que reemplace los secretos por variables de entorno o acceso de configuración.
Implementar patrones de configuración: Aplique directrices completas de corrección para actualizar a los sistemas de inyección de dependencias y configuración adecuados.
Agregar documentación: use las indicaciones de configuración y documentación para crear archivos de plantilla (appsettings.template.json, .env.example) y actualizar README con instrucciones de configuración.
Actualizar pruebas: aplique solicitudes de prueba y validación para refactorizar las pruebas para el nuevo enfoque basado en la configuración.
Validar cambios: Compila la aplicación, ejecuta todas las pruebas, prueba manualmente las rutas críticas y revisa las diferencias en Git antes de confirmar.
Eliminar del historial de Git: utilice git-filter-repo para limpiar los secretos del historial del repositorio.

Advertencia

Para eliminar secretos del historial de Git es necesario reescribir el historial del repositorio y realizar una inserción forzada. Coordinar con el equipo antes de continuar.
Confirmación y documento: revise todos los cambios, confirme en la rama, configure la nueva credencial de forma segura en su entorno y finalice la documentación con requisitos de configuración completos.

Comentarios

¿Le ha resultado útil esta página?