Spring Vault

Beveiliging Top

Ik heb zojuist de nieuwe Learn Spring Security-cursus aangekondigd, inclusief het volledige materiaal gericht op de nieuwe OAuth2-stack in Spring Security 5:

>> BEKIJK DE CURSUS

1. Overzicht

De kluis van HashiCorp is een hulpmiddel om geheimen op te slaan en te beveiligen. Vault lost in het algemeen het beveiligingsprobleem van de softwareontwikkeling op voor het beheren van geheimen. Lees hier ons artikel voor meer informatie.

Spring Vault biedt lente-abstracties aan de kluis van HashiCorp.

In deze zelfstudie bespreken we een voorbeeld van het opslaan en ophalen van geheimen uit de kluis.

2. Maven afhankelijkheden

Laten we om te beginnen eens kijken naar de afhankelijkheden die we nodig hebben om met Spring Vault aan de slag te gaan:

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

De nieuwste versie van spring-gewelf-kern is te vinden op Maven Central.

3. Kluis configureren

Laten we nu de stappen doorlopen die nodig zijn om Vault te configureren.

3.1. Een VaultTemplate

Om onze geheimen veilig te stellen, moeten we een instantiëren VaultTemplate waarvoor we nodig hebben VaultEndpoint en TokenAuthentication gevallen:

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

3.2. Een VaultEndpoint

Er zijn een paar manieren om te instantiëren VaultEndpoint. Laten we er een paar bekijken.

De eerste is om het simpelweg te instantiëren met behulp van een standaardconstructor, waarmee een standaard eindpunt wordt gemaakt dat verwijst naar // localhost: 8200:

VaultEndpoint-eindpunt = nieuw VaultEndpoint ();

Een andere manier is om een VaultEndpoint door de host en poort van Vault op te geven:

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

En tot slot kunnen we het ook maken op basis van de Vault-URL:

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

Er zijn een paar dingen om op te merken: Vault wordt geconfigureerd met een root-token van 00000000-0000-0000-0000-000000000000 om deze applicatie uit te voeren.

In ons voorbeeld hebben we de TokenAuthentication, maar er worden ook andere verificatiemethoden ondersteund.

4. Vault Beans configureren met Spring

Met Spring kunnen we de kluis op een aantal manieren configureren. Een daarvan is door het AbstractVaultConfiguration, en de andere is door te gebruiken EnvironmentVaultConfiguration die gebruik maakt van de omgevingskenmerken van Spring.

We gaan nu beide kanten op.

4.1. Gebruik makend van AbstractVaultConfiguration

Laten we een klasse maken die zich uitbreidt AbstractVaultConfiguration, Spring Vault configureren:

@Configuration openbare klasse VaultConfig breidt AbstractVaultConfiguration uit {@Override openbare ClientAuthentication clientAuthentication () {retourneer nieuwe TokenAuthentication ("00000000-0000-0000-0000-000000000000"); } @Override openbare VaultEndpoint vaultEndpoint () {retourneer VaultEndpoint.create ("host", 8020); }}

Deze benadering is vergelijkbaar met wat we in de vorige sectie hebben gezien. Wat anders is, is dat we Spring Vault hebben gebruikt om Vault-bonen te configureren door de abstracte klasse uit te breiden AbstractVaultConfiguration.

We hoeven alleen de implementatie te bieden om te configureren VaultEndpoint en ClientAuthentication.

4.2. Gebruik makend van EnvironmentVaultConfiguration

We kunnen Spring Vault ook configureren met de EnviromentVaultConfiguration:

@Configuration @PropertySource (waarde = {"vault-config.properties"}) @Import (waarde = EnvironmentVaultConfiguration.class) openbare klasse VaultEnvironmentConfig {}

EnvironmentVaultConfiguration maakt gebruik van Spring's PropertySource om Vault Beans te configureren. We hoeven alleen het eigenschappenbestand te voorzien van enkele acceptabele gegevens.

Meer informatie over alle voorgedefinieerde eigenschappen is te vinden in de officiële documentatie.

Om de kluis te configureren, hebben we ten minste een aantal eigenschappen nodig:

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

5. Geheimen beveiligen

We maken een eenvoudig Inloggegevens klasse die is toegewezen aan gebruikersnaam en wachtwoord:

public class Credentials {private String gebruikersnaam; privé String-wachtwoord; // standaard constructeurs, getters, setters}

Laten we nu eens kijken hoe we onze Inloggegevens object met behulp van de Vault-sjabloon:

Inloggegevens inloggegevens = nieuwe inloggegevens ("gebruikersnaam", "wachtwoord"); vaultTemplate.write ("secret / myapp", referenties);

Nu deze regels zijn voltooid, zijn onze geheimen nu opgeslagen.

Vervolgens zullen we zien hoe u ze kunt openen.

6. Toegang tot geheimen

We hebben toegang tot de beveiligde geheimen met behulp van de lezen() methode in KluisTemplate, wat de VaultResponseSupport als antwoord:

VaultResponseSupport response = vaultTemplate .read ("secret / myapp", Credentials.class); String gebruikersnaam = response.getData (). GetUsername (); String wachtwoord = response.getData (). GetPassword ();

Onze geheime waarden zijn nu klaar.

7. Conclusie

In dit artikel hebben we de basisprincipes van Spring Vault leren kennen met een voorbeeld dat laat zien hoe de Vault werkt in typische scenario's.

Zoals gewoonlijk is de hier gepresenteerde broncode te vinden op GitHub.

Beveiligingsbodem

Ik heb zojuist de nieuwe Learn Spring Security-cursus aangekondigd, inclusief het volledige materiaal gericht op de nieuwe OAuth2-stack in Spring Security 5:

>> BEKIJK DE CURSUS