HashiCorp Vault : gestion des secrets

Dans le monde moderne du développement logiciel, la gestion sécurisée des secrets (mots de passe, clés API, certificats) est devenue un enjeu critique. HashiCorp Vault s'impose comme une solution de référence pour centraliser et sécuriser ces données sensibles dans un environnement DevOps. Découvrons comment l'intégrer efficacement dans vos applications .NET.

Les fondamentaux de HashiCorp Vault

HashiCorp Vault est un gestionnaire de secrets qui permet de stocker et d'accéder de manière sécurisée aux données sensibles via une API REST. Il offre plusieurs fonctionnalités essentielles :

• Stockage chiffré des secrets
• Gestion fine des accès (RBAC)
• Rotation automatique des credentials
• Audit logging

Installation et configuration

Pour commencer, installons le package NuGet nécessaire :

dotnet add package VaultSharp

Configuration de base dans appsettings.json :

{
  "Vault": {
    "Address": "http://localhost:8200",
    "Token": "dev-token-for-testing"
  }
}

Intégration avec .NET

Voici un exemple complet d'intégration avec une application ASP.NET Core :

public class VaultService : IVaultService
{
    private readonly IVaultClient _vaultClient;

    public VaultService(IConfiguration configuration)
    {
        // Configuration du client Vault
        var vaultClientSettings = new VaultClientSettings(
            configuration["Vault:Address"],
            configuration["Vault:Token"]
        );
        
        _vaultClient = new VaultClient(vaultClientSettings);
    }
    public async Task<string> GetSecretAsync(string path)
    {
        try
        {
            var secret = await _vaultClient.V1.Secrets.KV.V2.ReadSecretAsync(path);
            return secret.Data.Data["value"].ToString();
        }
        catch (VaultApiException ex)
        {
            // Gestion appropriée des erreurs
            throw new SecretNotFoundException($"Secret not found at path: {path}", ex);
        }
    }
}

Bonnes pratiques de sécurité

• Utilisez toujours HTTPS en production
• Implémentez une stratégie de rotation des tokens
• Limitez les permissions au strict nécessaire
• Activez l'audit logging

Patterns d'utilisation courants

Pattern 1: Injection de secrets dans les containers

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration((context, config) =>
        {
            config.AddVault(options =>
            {
                options.Address = "http://vault:8200";
                options.Token = Environment.GetEnvironmentVariable("VAULT_TOKEN");
            });
        });

Pattern 2: Rotation automatique des credentials

public class CredentialRotationService : IHostedService
{
    private readonly IVaultClient _vaultClient;
    private Timer _timer;

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        _timer = new Timer(DoRotation, null, TimeSpan.Zero, 
            TimeSpan.FromHours(24));
    }
    private async void DoRotation(object state)
    {
        // Logique de rotation des credentials
        await _vaultClient.V1.System.RevokeLeaseAsync("lease_id");
    }
}

Tests et validation

[Fact]
public async Task GetSecret_ShouldReturnValue_WhenSecretExists()
{
    // Arrange
    var mockVaultClient = new Mock<IVaultClient>();
    var expectedSecret = "test-secret";
    
    mockVaultClient
        .Setup(x => x.V1.Secrets.KV.V2.ReadSecretAsync(It.IsAny<string>()))
        .ReturnsAsync(new Secret<SecretData>
        {
            Data = new SecretData { Data = new Dictionary<string, object>
            {
                { "value", expectedSecret }
            }}
        });

    var service = new VaultService(mockVaultClient.Object);
    // Act
    var result = await service.GetSecretAsync("test/path");
    // Assert
    Assert.Equal(expectedSecret, result);
}

Considérations de performance

• Implementez un cache local pour les secrets fréquemment utilisés
• Utilisez un circuit breaker pour gérer les pannes
• Monitoring des métriques de performance

public class CachedVaultService : IVaultService
{
    private readonly IMemoryCache _cache;
    private readonly IVaultService _vaultService;

    public async Task<string> GetSecretAsync(string path)
    {
        return await _cache.GetOrCreateAsync(
            path,
            async entry =>
            {
                entry.SetAbsoluteExpiration(TimeSpan.FromMinutes(5));
                return await _vaultService.GetSecretAsync(path);
            });
    }
}

Conclusion

HashiCorp Vault est un outil puissant pour la gestion des secrets dans un environnement DevOps moderne. Son intégration avec .NET est simple et robuste, permettant une gestion sécurisée des données sensibles. Les patterns et bonnes pratiques présentés vous permettront de l'utiliser efficacement dans vos projets.

Points clés à retenir :

• Utilisez toujours HTTPS et une authentification forte en production
• Implémentez la rotation automatique des secrets
• Mettez en place un monitoring approprié
• Testez rigoureusement votre intégration