Caveau de printemps

Haut de sécurité

Je viens d'annoncer le nouveau cours Learn Spring Security, y compris le matériel complet axé sur la nouvelle pile OAuth2 dans Spring Security 5:

>> VOIR LE COURS

1. Vue d'ensemble

Le coffre-fort de HashiCorp est un outil pour stocker et sécuriser les secrets. Vault, en général, résout le problème de sécurité du développement logiciel lié à la gestion des secrets. Pour en savoir plus, consultez notre article ici.

Spring Vault fournit des abstractions de printemps au coffre-fort de HashiCorp.

Dans ce didacticiel, nous allons passer en revue un exemple sur la façon de stocker et de récupérer des secrets à partir du coffre-fort.

2. Dépendances de Maven

Pour commencer, examinons les dépendances dont nous avons besoin pour commencer à travailler avec Spring Vault:

  org.springframework.vault spring-vault-core 2.1.1.RELEASE   

La dernière version de spring-vault-core est disponible sur Maven Central.

3. Configuration de Vault

Passons maintenant en revue les étapes nécessaires pour configurer Vault.

3.1. Création d'un VaultTemplate

Pour sécuriser nos secrets, nous devrons instancier un VaultTemplate pour lequel nous avons besoin des instances VaultEndpoint et TokenAuthentication :

VaultTemplate vaultTemplate = new VaultTemplate(new VaultEndpoint(), new TokenAuthentication("00000000-0000-0000-0000-000000000000"));

3.2. Création d'un VaultEndpoint

Il existe plusieurs façons d'instancier VaultEndpoint . Jetons un coup d'œil à certains d'entre eux.

La première consiste simplement à l'instancier en utilisant un constructeur par défaut, qui créera un point de terminaison par défaut pointant vers // localhost: 8200:

VaultEndpoint endpoint = new VaultEndpoint();

Une autre méthode consiste à créer un VaultEndpoint en spécifiant l'hôte et le port de Vault:

VaultEndpoint endpoint = VaultEndpoint.create("host", port);

Et enfin, nous pouvons également le créer à partir de l'URL du coffre-fort:

VaultEndpoint endpoint = VaultEndpoint.from(new URI("vault uri"));

Il y a quelques points à noter ici - Vault sera configuré avec un jeton racine de 00000000-0000-0000-0000-000000000000 pour exécuter cette application.

Dans notre exemple, nous avons utilisé TokenAuthentication , mais d'autres méthodes d'authentification sont également prises en charge.

4. Configuration de Vault Beans à l'aide de Spring

Avec Spring, nous pouvons configurer Vault de plusieurs manières. L'un consiste à étendre AbstractVaultConfiguration et l'autre à utiliser EnvironmentVaultConfiguration qui utilise les propriétés d'environnement de Spring.

Nous allons maintenant passer dans les deux sens.

4.1. Utilisation de AbstractVaultConfiguration

Créons une classe qui étend AbstractVaultConfiguration, pour configurer Spring Vault:

@Configuration public class VaultConfig extends AbstractVaultConfiguration { @Override public ClientAuthentication clientAuthentication() { return new TokenAuthentication("00000000-0000-0000-0000-000000000000"); } @Override public VaultEndpoint vaultEndpoint() { return VaultEndpoint.create("host", 8020); } }

Cette approche est similaire à ce que nous avons vu dans la section précédente. Ce qui est différent, c'est que nous avons utilisé Spring Vault pour configurer les beans Vault en étendant la classe abstraite AbstractVaultConfiguration.

Nous devons juste fournir l'implémentation pour configurer VaultEndpoint et ClientAuthentication .

4.2. Utilisation de EnvironmentVaultConfiguration

Nous pouvons également configurer Spring Vault à l'aide d' EnviromentVaultConfiguration :

@Configuration @PropertySource(value = { "vault-config.properties" }) @Import(value = EnvironmentVaultConfiguration.class) public class VaultEnvironmentConfig { }

EnvironmentVaultConfiguration utilise PropertySource de Spring pour configurer les beans Vault. Nous avons juste besoin de fournir au fichier de propriétés des entrées acceptables.

Plus d'informations sur toutes les propriétés prédéfinies peuvent être trouvées dans la documentation officielle.

Pour configurer le coffre-fort, nous avons besoin d'au moins deux propriétés:

vault.uri=//localhost:8200 vault.token=00000000-0000-0000-0000-000000000000

5. Sécurisation des secrets

Nous allons créer une classe Credentials simple qui correspond au nom d'utilisateur et au mot de passe:

public class Credentials { private String username; private String password; // standard constructors, getters, setters }

Voyons maintenant comment nous pouvons sécuriser notre objet Credentials à l'aide du VaultTemplate:

Credentials credentials = new Credentials("username", "password"); vaultTemplate.write("secret/myapp", credentials);

Une fois ces lignes terminées, nos secrets sont maintenant stockés.

Ensuite, nous verrons comment y accéder.

6. Accéder aux secrets

Nous pouvons accéder aux secrets sécurisés à l'aide de la méthode read () dans VaultTemplate, qui renvoie VaultResponseSupport en tant que réponse:

VaultResponseSupport response = vaultTemplate .read("secret/myapp", Credentials.class); String username = response.getData().getUsername(); String password = response.getData().getPassword();

Nos valeurs secrètes sont maintenant prêtes.

7. Conclusion

Dans cet article, nous avons découvert les bases de Spring Vault avec un exemple montrant comment le coffre-fort fonctionne dans des scénarios typiques .

Comme d'habitude, le code source présenté ici se trouve à l'adresse over sur GitHub.

Fond de sécurité

Je viens d'annoncer le nouveau cours Learn Spring Security, y compris le matériel complet axé sur la nouvelle pile OAuth2 dans Spring Security 5:

>> VOIR LE COURS