jasypt spring boot
v3.0.5
Jasypt- Integration für Spring Boot 2.x und 3.0.0
Jasypt Spring Boot bietet Verschlüsselungsunterstützung für Eigenschaftsquellen in Spring Boot-Anwendungen.
Es gibt drei Möglichkeiten jasypt-spring-boot in Ihr Projekt zu integrieren:
@SpringBootApplication oder @EnableAutoConfiguration verwenden, fügen Sie einfach das Starter-JAR jasypt-spring-boot-starter zu Ihrem Klassenpfad hinzu, um verschlüsselbare Eigenschaften in der gesamten Spring-Umgebung zu aktivierenjasypt-spring-boot zu Ihrem Klassenpfad und @EnableEncryptableProperties zu Ihrer Hauptkonfigurationsklasse hinzu, um verschlüsselbare Eigenschaften in der gesamten Spring-Umgebung zu aktivierenjasypt-spring-boot zu Ihrem Klassenpfad und Deklarieren einzelner verschlüsselbarer Eigenschaftsquellen mit @EncrytablePropertySource Nutzen Sie eine der folgenden 3 Methoden (oben kurz erklärt):
Fügen Sie einfach die Starter-JAR-Abhängigkeit zu Ihrem Projekt hinzu, wenn Ihre Spring Boot-Anwendung @SpringBootApplication oder @EnableAutoConfiguration verwendet und verschlüsselbare Eigenschaften in der gesamten Spring-Umgebung aktiviert werden (das bedeutet alle Systemeigenschaft, Umgebungseigenschaft, Befehlszeilenargument, application.properties, Anwendung). -*.properties, Yaml-Eigenschaften und alle anderen Eigenschaftsquellen können verschlüsselte Eigenschaften enthalten):
< dependency >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-spring-boot-starter</ artifactId >
< version >3.0.5</ version >
</ dependency > Wenn Sie keine @SpringBootApplication oder @EnableAutoConfiguration -Anmerkungen zur automatischen Konfiguration verwenden, fügen Sie diese Abhängigkeit zu Ihrem Projekt hinzu:
< dependency >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-spring-boot</ artifactId >
< version >3.0.5</ version >
</ dependency > Und fügen Sie dann @EnableEncryptableProperties zu Ihrer Konfigurationsklasse hinzu. Zum Beispiel:
@ Configuration
@ EnableEncryptableProperties
public class MyApplication {
...
}Und verschlüsselbare Eigenschaften werden in der gesamten Spring-Umgebung aktiviert (das bedeutet, dass jede Systemeigenschaft, Umgebungseigenschaft, Befehlszeilenargument, application.properties, Yaml-Eigenschaften und alle anderen benutzerdefinierten Eigenschaftsquellen verschlüsselte Eigenschaften enthalten können).
Wenn Sie keine @SpringBootApplication oder @EnableAutoConfiguration -Autokonfigurationsanmerkungen verwenden und nicht verschlüsselbare Eigenschaften in der gesamten Spring-Umgebung aktivieren möchten, gibt es eine dritte Option. Fügen Sie Ihrem Projekt zunächst die folgende Abhängigkeit hinzu:
< dependency >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-spring-boot</ artifactId >
< version >3.0.5</ version >
</ dependency > Fügen Sie dann in Ihren Konfigurationsdateien so viele @EncryptablePropertySource -Anmerkungen hinzu, wie Sie möchten. Genau wie Sie es mit @PropertySource -Annotation von Spring tun. Zum Beispiel:
@ Configuration
@ EncryptablePropertySource ( name = "EncryptedProperties" , value = "classpath:encrypted.properties" )
public class MyApplication {
...
} Praktischerweise gibt es auch eine @EncryptablePropertySources -Annotation, mit der man Annotationen vom Typ @EncryptablePropertySource wie folgt gruppieren kann:
@ Configuration
@ EncryptablePropertySources ({ @ EncryptablePropertySource ( "classpath:encrypted.properties" ),
@ EncryptablePropertySource ( "classpath:encrypted2.properties" )})
public class MyApplication {
...
} Beachten Sie außerdem, dass @EncryptablePropertySource ab Version 1.8 YAML-Dateien unterstützt
Ab Version 1.7 1.15 gibt es für einige Sonderfälle eine vierte Methode zur Aktivierung verschlüsselbarer Eigenschaften. Es wird eine benutzerdefinierte ConfigurableEnvironment -Klasse bereitgestellt: EncryptableEnvironmentStandardEncryptableEnvironment und StandardEncryptableServletEnvironment , die mit SpringApplicationBuilder verwendet werden können, um die benutzerdefinierte Umgebung auf diese Weise zu definieren:
new SpringApplicationBuilder ()
. environment ( new StandardEncryptableEnvironment ())
. sources ( YourApplicationClass . class ). run ( args ); Diese Methode würde nur die Verwendung einer Abhängigkeit für jasypt-spring-boot erfordern. Es ist keine Starter-JAR-Abhängigkeit erforderlich. Diese Methode ist nützlich für den frühen Zugriff auf verschlüsselte Eigenschaften beim Bootstrap. Obwohl dies in den meisten Szenarios nicht erforderlich ist, kann es hilfreich sein, das Init-Verhalten von Spring Boot anzupassen oder bestimmte Funktionen zu integrieren, die sehr früh konfiguriert werden, wie z. B. die Protokollierungskonfiguration. Ein konkretes Beispiel: Diese Methode zum Aktivieren verschlüsselbarer Eigenschaften ist die einzige, die mit der Ersetzung von Spring Properties in logback-spring.xml -Dateien mithilfe des springProperty Tags funktioniert. Zum Beispiel:
< springProperty name = " user " source = " db.user " />
< springProperty name = " password " source = " db.password " />
< appender name = " db " class = " ch.qos.logback.classic.db.DBAppender " >
< connectionSource
class = " ch.qos.logback.core.db.DriverManagerConnectionSource " >
< driverClass >org.postgresql.Driver</ driverClass >
< url >jdbc:postgresql://localhost:5432/simple</ url >
< user >${user}</ user >
< password >${password}</ password >
</ connectionSource >
</ appender > Dieser Mechanismus könnte beispielsweise (wie gezeigt) verwendet werden, um Datenbankprotokollierungs-Appender zu initialisieren, die die Übergabe vertraulicher Anmeldeinformationen erfordern. Wenn alternativ ein benutzerdefinierter StringEncryptor bereitgestellt werden muss, wird eine statische Builder-Methode StandardEncryptableEnvironment#builder zur Anpassung bereitgestellt (andere Anpassungen sind möglich):
StandardEncryptableEnvironment
. builder ()
. encryptor ( new MyEncryptor ())
. build ()Dadurch wird das Laden einer Konfiguration ausgelöst, die im Wesentlichen zwei Dinge bewirkt:
StringEncryptor , der über reguläre Eigenschaften, Systemeigenschaften oder Befehlszeilenargumente konfiguriert werden kann. Wenn Sie die Methoden 1 und 2 verwenden, können Sie verschlüsselte Eigenschaften in jeder in der Umgebung enthaltenen PropertySource definieren. Verwenden Sie beispielsweise die Annotation @PropertySource:
@ SpringBootApplication
@ EnableEncryptableProperties
@ PropertySource ( name = "EncryptedProperties" , value = "classpath:encrypted.properties" )
public class MyApplication {
...
}Und Ihre verschlüsselte.properties-Datei würde in etwa so aussehen:
secret.property =ENC(nrmZtkF7T0kjG/VodDvBw93Ct8EgjCA+) Wenn Sie nun environment.getProperty("secret.property") ausführen oder @Value("${secret.property}") verwenden, erhalten Sie die entschlüsselte Version von secret.property .
Wenn Sie METHODE 3 ( @EncryptablePropertySource ) verwenden, können Sie auf die gleiche Weise auf die verschlüsselten Eigenschaften zugreifen. Der einzige Unterschied besteht darin, dass Sie die Eigenschaften in die Ressource einfügen müssen, die in der Annotation @EncryptablePropertySource deklariert wurde, damit die Eigenschaften ordnungsgemäß entschlüsselt werden können.
Jasypt verwendet einen StringEncryptor zum Entschlüsseln von Eigenschaften. Wenn für alle drei Methoden kein benutzerdefinierter StringEncryptor (Einzelheiten finden Sie im Abschnitt „Benutzerdefinierter Encryptor“) im Spring-Kontext gefunden wird, wird automatisch einer erstellt, der über die folgenden Eigenschaften konfiguriert werden kann (System, Eigenschaftendatei, Befehlszeilenargumente, Umgebungsvariable, usw.):
| Schlüssel | Erforderlich | Standardwert |
| jasypt.encryptor.password | WAHR | - |
| jasypt.encryptor.algorithm | FALSCH | PBEWITHHMACSHA512ANDAES_256 |
| jasypt.encryptor.key-obtention-iterations | FALSCH | 1000 |
| jasypt.encryptor.pool-size | FALSCH | 1 |
| jasypt.encryptor.provider-name | FALSCH | SunJCE |
| jasypt.encryptor.provider-class-name | FALSCH | null |
| jasypt.encryptor.salt-generator-classname | FALSCH | org.jasypt.salt.RandomSaltGenerator |
| jasypt.encryptor.iv-generator-klassenname | FALSCH | org.jasypt.iv.RandomIvGenerator |
| jasypt.encryptor.string-output-type | FALSCH | base64 |
| jasypt.encryptor.proxy-property-sources | FALSCH | FALSCH |
| jasypt.encryptor.skip-property-sources | FALSCH | leere Liste |
Die einzige erforderliche Eigenschaft ist das Verschlüsselungskennwort, für den Rest können Standardwerte verwendet werden. Während alle diese Eigenschaften in einer Eigenschaftendatei deklariert werden könnten, sollte das Verschlüsselungskennwort nicht in einer Eigenschaftendatei gespeichert werden, sondern vielmehr als Systemeigenschaft, Befehlszeilenargument oder Umgebungsvariable übergeben werden, sofern der Name jasypt.encryptor.password lautet jasypt.encryptor.password es wird funktionieren.
Die letzte Eigenschaft, jasypt.encryptor.proxyPropertySources wird verwendet, um jasyp-spring-boot anzugeben, wie Eigenschaftswerte zur Entschlüsselung abgefangen werden. Der Standardwert false verwendet benutzerdefinierte Wrapper-Implementierungen von PropertySource , EnumerablePropertySource und MapPropertySource . Wenn für diese Eigenschaft true angegeben ist, verwendet der Abfangmechanismus CGLib-Proxys für jede spezifische PropertySource -Implementierung. Dies kann in einigen Szenarios nützlich sein, in denen der Typ der ursprünglichen PropertySource beibehalten werden muss.
Zur benutzerdefinierten Konfiguration des Verschlüsselungsgeräts und der Quelle des Verschlüsselungskennworts können Sie jederzeit Ihre eigene StringEncryptor-Bean in Ihrem Spring-Kontext definieren. Der Standardverschlüsselungsgerät wird dann ignoriert. Zum Beispiel:
@ Bean ( "jasyptStringEncryptor" )
public StringEncryptor stringEncryptor () {
PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor ();
SimpleStringPBEConfig config = new SimpleStringPBEConfig ();
config . setPassword ( "password" );
config . setAlgorithm ( "PBEWITHHMACSHA512ANDAES_256" );
config . setKeyObtentionIterations ( "1000" );
config . setPoolSize ( "1" );
config . setProviderName ( "SunJCE" );
config . setSaltGeneratorClassName ( "org.jasypt.salt.RandomSaltGenerator" );
config . setIvGeneratorClassName ( "org.jasypt.iv.RandomIvGenerator" );
config . setStringOutputType ( "base64" );
encryptor . setConfig ( config );
return encryptor ;
} Beachten Sie, dass der Bean-Name erforderlich ist, da jasypt-spring-boot benutzerdefinierte String Encyptors ab Version 1.5 anhand des Namens erkennt. Der Standard-Bean-Name lautet:
jasyptStringEncryptor
Man kann dies aber auch überschreiben, indem man eine Eigenschaft definiert:
jasypt.encryptor.bean
Wenn Sie beispielsweise jasypt.encryptor.bean=encryptorBean definieren, würden Sie Ihren benutzerdefinierten Verschlüsselungsmechanismus mit diesem Namen definieren:
@ Bean ( "encryptorBean" )
public StringEncryptor stringEncryptor () {
...
} Ab jasypt-spring-boot-1.10 gibt es neue Erweiterungspunkte. EncryptablePropertySource verwendet jetzt EncryptablePropertyResolver um alle Eigenschaften aufzulösen:
public interface EncryptablePropertyResolver {
String resolvePropertyValue ( String value );
} Implementierungen dieser Schnittstelle sind sowohl für die Erkennung als auch für die Entschlüsselung von Eigenschaften verantwortlich. Die Standardimplementierung DefaultPropertyResolver verwendet den zuvor erwähnten StringEncryptor und einen neuen EncryptablePropertyDetector .
EncryptablePropertyDetector bereit Sie können die Standardimplementierung überschreiben, indem Sie eine Bean vom Typ EncryptablePropertyDetector mit dem Namen encryptablePropertyDetector bereitstellen. Wenn Sie Ihren eigenen Bean-Namen angeben möchten, überschreiben Sie die Eigenschaft jasypt.encryptor.property.detector-bean und geben Sie den Namen an, den Sie der Bean geben möchten. Wenn Sie dies bereitstellen, sind Sie für die Erkennung verschlüsselter Eigenschaften verantwortlich. Beispiel:
private static class MyEncryptablePropertyDetector implements EncryptablePropertyDetector {
@ Override
public boolean isEncrypted ( String value ) {
if ( value != null ) {
return value . startsWith ( "ENC@" );
}
return false ;
}
@ Override
public String unwrapEncryptedValue ( String value ) {
return value . substring ( "ENC@" . length ());
}
} @ Bean ( name = "encryptablePropertyDetector" )
public EncryptablePropertyDetector encryptablePropertyDetector () {
return new MyEncryptablePropertyDetector ();
}prefix und suffix für eine benutzerdefinierte verschlüsselte Eigenschaft an Wenn Sie lediglich unterschiedliche Präfixe/Suffixe für verschlüsselte Eigenschaften verwenden möchten, können Sie weiterhin alle Standardimplementierungen verwenden und einfach die folgenden Eigenschaften in application.properties (oder application.yml ) überschreiben:
jasypt :
encryptor :
property :
prefix : " ENC@[ "
suffix : " ] "EncryptablePropertyResolver bereit Sie können die Standardimplementierung überschreiben, indem Sie eine Bean vom Typ EncryptablePropertyResolver mit dem Namen encryptablePropertyResolver bereitstellen. Wenn Sie Ihren eigenen Bean-Namen angeben möchten, überschreiben Sie die Eigenschaft jasypt.encryptor.property.resolver-bean und geben Sie den Namen an, den Sie der Bean geben möchten. Wenn Sie diese bereitstellen, sind Sie für die Erkennung und Entschlüsselung verschlüsselter Eigenschaften verantwortlich. Beispiel:
class MyEncryptablePropertyResolver implements EncryptablePropertyResolver {
private final PooledPBEStringEncryptor encryptor ;
public MyEncryptablePropertyResolver ( char [] password ) {
this . encryptor = new PooledPBEStringEncryptor ();
SimpleStringPBEConfig config = new SimpleStringPBEConfig ();
config . setPasswordCharArray ( password );
config . setAlgorithm ( "PBEWITHHMACSHA512ANDAES_256" );
config . setKeyObtentionIterations ( "1000" );
config . setPoolSize ( 1 );
config . setProviderName ( "SunJCE" );
config . setSaltGeneratorClassName ( "org.jasypt.salt.RandomSaltGenerator" );
config . setIvGeneratorClassName ( "org.jasypt.iv.RandomIvGenerator" );
config . setStringOutputType ( "base64" );
encryptor . setConfig ( config );
}
@ Override
public String resolvePropertyValue ( String value ) {
if ( value != null && value . startsWith ( "{cipher}" )) {
return encryptor . decrypt ( value . substring ( "{cipher}" . length ()));
}
return value ;
}
} @ Bean ( name = "encryptablePropertyResolver" )
EncryptablePropertyResolver encryptablePropertyResolver ( @ Value ( "${jasypt.encryptor.password}" ) String password ) {
return new MyEncryptablePropertyResolver ( password . toCharArray ());
} Beachten Sie, dass durch das Überschreiben EncryptablePropertyResolver alle anderen Konfigurationen oder Überschreibungen, die Sie möglicherweise für Präfixe, Suffixe, EncryptablePropertyDetector und StringEncryptor haben, nicht mehr funktionieren, da sie vom Standard-Resolver verwendet werden. Sie müssten das ganze Zeug selbst verkabeln. Glücklicherweise müssen Sie diese Bean in den meisten Fällen nicht überschreiben, die vorherigen Optionen sollten ausreichen.
Aber wie Sie in der Implementierung sehen können, erfolgt die Erkennung und Entschlüsselung der verschlüsselten Eigenschaften intern von MyEncryptablePropertyResolver
jasypt-spring-boot:2.1.0 führt eine neue Funktion zum Festlegen von Eigenschaftsfiltern ein. Der Filter ist Teil der EncryptablePropertyResolver -API und ermöglicht Ihnen zu bestimmen, welche Eigenschaften oder Eigenschaftsquellen für die Entschlüsselung in Betracht gezogen werden sollen. Dies geschieht, bevor überhaupt der tatsächliche Eigenschaftswert untersucht wird, um ihn zu suchen oder zu entschlüsseln. Beispielsweise werden standardmäßig alle Eigenschaften, deren Namen mit jasypt.encryptor beginnen, von der Prüfung ausgeschlossen. Dadurch sollen zirkuläre Abhängigkeiten beim Laden vermieden werden, wenn die Bibliotheks-Beans konfiguriert werden.
Standardmäßig verwendet DefaultPropertyResolver DefaultPropertyFilter , mit dem Sie die folgenden Zeichenfolgenmusterlisten angeben können:
EncryptablePropertyFilter bereit Sie können die Standardimplementierung überschreiben, indem Sie eine Bean vom Typ EncryptablePropertyFilter mit dem Namen encryptablePropertyFilter bereitstellen. Wenn Sie Ihren eigenen Bean-Namen angeben möchten, überschreiben Sie die Eigenschaft jasypt.encryptor.property.filter-bean und geben Sie den Namen an, den Sie der Bean geben möchten. Wenn Sie dies bereitstellen, sind Sie dafür verantwortlich, Eigenschaften und/oder Eigenschaftsquellen zu erkennen, die Sie zur Entschlüsselung in Betracht ziehen möchten. Beispiel:
class MyEncryptablePropertyFilter implements EncryptablePropertyFilter {
public boolean shouldInclude ( PropertySource <?> source , String name ) {
return name . startsWith ( 'encrypted.' );
}
} @ Bean ( name = "encryptablePropertyFilter" )
EncryptablePropertyFilter encryptablePropertyFilter () {
return new MyEncryptablePropertyFilter ();
} Beachten Sie, dass Sie, damit dieser Mechanismus funktioniert, keinen benutzerdefinierten EncryptablePropertyResolver bereitstellen und stattdessen den Standard-Resolver verwenden sollten. Wenn Sie einen benutzerdefinierten Resolver bereitstellen, sind Sie für den gesamten Prozess der Erkennung und Entschlüsselung von Eigenschaften verantwortlich.
PropertySource Klassen aus der Introspektion herausDefinieren Sie eine durch Kommas getrennte Liste vollständig qualifizierter Klassennamen, die bei der Selbstbeobachtung übersprungen werden sollen. Diese Klassen werden von diesem Plugin nicht umschlossen/proxiert und daher werden die darin enthaltenen Eigenschaften nicht von der Verschlüsselung/Entschlüsselung unterstützt:
jasypt.encryptor.skip-property-sources =org.springframework.boot.env.RandomValuePropertySource,org.springframework.boot.ansi.AnsiPropertySource Verschlüsselte Eigenschaften werden in Ihrer Anwendung zwischengespeichert und in bestimmten Szenarien, z. B. bei Verwendung einer externalisierten Konfiguration von einem Konfigurationsserver, müssen die Eigenschaften aktualisiert werden, wenn sie sich ändern. Zu diesem Zweck registriert jasypt-spring-boot einen RefreshScopeRefreshedEventListener , der standardmäßig die folgenden Ereignisse abhört, um den Cache für verschlüsselte Eigenschaften zu leeren:
public static final List < String > EVENT_CLASS_NAMES = Arrays . asList (
"org.springframework.cloud.context.scope.refresh.RefreshScopeRefreshedEvent" ,
"org.springframework.cloud.context.environment.EnvironmentChangeEvent" ,
"org.springframework.boot.web.servlet.context.ServletWebServerInitializedEvent"
);Sollten Sie zusätzliche Ereignisse registrieren müssen, die eine Invalidierung des verschlüsselten Caches auslösen möchten, können Sie diese mithilfe der folgenden Eigenschaft hinzufügen (durch Komma trennen, wenn mehr als eines erforderlich ist):
jasypt.encryptor.refreshed-event-classes =org.springframework.boot.context.event.ApplicationStartedEventEin Maven-Plugin wird mit einer Reihe hilfreicher Dienstprogramme bereitgestellt.
Um das Plugin zu verwenden, fügen Sie einfach Folgendes zu Ihrer pom.xml hinzu:
< build >
< plugins >
< plugin >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-maven-plugin</ artifactId >
< version >3.0.5</ version >
</ plugin >
</ plugins >
</ build >Wenn Sie dieses Plugin verwenden, können Sie Ihr Verschlüsselungskennwort am einfachsten über eine Systemeigenschaft bereitstellen, z. B. -Djasypt.encryptor.password="das Kennwort".
Standardmäßig berücksichtigt das Plugin die Verschlüsselungskonfiguration in den Standard-Spring-Boot-Konfigurationsdateien unter ./src/main/resources. Sie können diese Konfiguration auch über Systemeigenschaften oder Umgebungsvariablen bereitstellen.
Beachten Sie, dass der Rest Ihres Anwendungscodes und Ihrer Ressourcen für das Plugin nicht verfügbar ist, da Maven-Plugins keinen gemeinsamen Klassenpfad mit Projekten haben. Wenn Ihre Anwendung eine Verschlüsselungskonfiguration über eine StringEncryptor-Bean bereitstellt, wird diese nicht übernommen.
Generell empfiehlt es sich, sich einfach auf die sichere Standardkonfiguration zu verlassen.
So verschlüsseln Sie einen Einzelwertlauf:
mvn jasypt:encrypt-value -Djasypt.encryptor.password= " the password " -Djasypt.plugin.value= " theValueYouWantToEncrypt " Um Platzhalter in src/main/resources/application.properties zu verschlüsseln, umschließen Sie einfach eine beliebige Zeichenfolge mit DEC(...) . Zum Beispiel:
sensitive.password =DEC(secret value)
regular.property =exampleFühren Sie dann Folgendes aus:
mvn jasypt:encrypt -Djasypt.encryptor.password= " the password "Dadurch würde diese Datei an Ort und Stelle bearbeitet, was zu Folgendem führen würde:
sensitive.password =ENC(encrypted)
regular.property =exampleDer Dateiname und der Speicherort können angepasst werden.
Um einen einzelnen Wert zu entschlüsseln, führen Sie Folgendes aus:
mvn jasypt:decrypt-value -Djasypt.encryptor.password= " the password " -Djasypt.plugin.value= " DbG1GppXOsFa2G69PnmADvQFI3esceEhJYbaEIKCcEO5C85JEqGAhfcjFMGnoRFf " Um Platzhalter in src/main/resources/application.properties zu entschlüsseln, umschließen Sie einfach eine beliebige Zeichenfolge mit ENC(...) . Zum Beispiel:
sensitive.password =ENC(encrypted)
regular.property =exampleDies lässt sich wie folgt entschlüsseln:
mvn jasypt:decrypt -Djasypt.encryptor.password= " the password "Was den entschlüsselten Inhalt auf dem Bildschirm ausgeben würde:
sensitive.password =DEC(decrypted)
regular.property =exampleBeachten Sie, dass die Ausgabe auf dem Bildschirm, statt die Datei direkt zu bearbeiten, darauf abzielt, die versehentliche Übergabe entschlüsselter Werte an die Versionskontrolle zu reduzieren. Beim Entschlüsseln möchten Sie höchstwahrscheinlich nur überprüfen, welcher Wert verschlüsselt wurde, und diesen Wert nicht dauerhaft entschlüsseln.
Das Ändern der Konfiguration für vorhandene verschlüsselte Eigenschaften ist bei Verwendung der Verschlüsselungs-/Entschlüsselungsziele etwas umständlich. Sie müssen das Entschlüsselungsziel mit der alten Konfiguration ausführen, dann die entschlüsselte Ausgabe zurück in die Originaldatei kopieren und dann das Verschlüsselungsziel mit der neuen Konfiguration ausführen.
Das Ziel der erneuten Verschlüsselung vereinfacht dies, indem eine Datei an Ort und Stelle erneut verschlüsselt wird. Es müssen 2 Konfigurationssätze bereitgestellt werden. Die neue Konfiguration wird auf die gleiche Weise bereitgestellt, wie Sie die anderen Maven-Ziele konfigurieren würden. Die alte Konfiguration wird über Systemeigenschaften mit dem Präfix „jasypt.plugin.old“ anstelle von „jasypt.encryptor“ bereitgestellt.
Um beispielsweise application.properties erneut zu verschlüsseln, das zuvor mit dem Passwort ALT verschlüsselt wurde, und dann mit dem neuen Passwort NEU zu verschlüsseln:
mvn jasypt:reencrypt -Djasypt.plugin.old.password=OLD -Djasypt.encryptor.password=NEWHinweis: Alle alten Konfigurationen müssen als Systemeigenschaften übergeben werden. Umgebungsvariablen und Spring Boot-Konfigurationsdateien werden nicht unterstützt.
Manchmal kann sich die Standardverschlüsselungskonfiguration zwischen den Versionen von jasypt-spring-boot ändern. Mit dem Upgrade-Ziel können Sie Ihre verschlüsselten Eigenschaften automatisch auf die neuen Standardwerte aktualisieren. Dadurch wird Ihre application.properties-Datei mit der alten Standardkonfiguration entschlüsselt und mit der neuen Standardkonfiguration erneut verschlüsselt.
mvn jasypt:upgrade -Djasypt.encryptor.password=EXAMPLE Sie können auch die Systemeigenschaft -Djasypt.plugin.old.major-version übergeben, um die Version anzugeben, von der Sie aktualisieren. Standardmäßig wird immer die letzte Hauptversion verwendet, in der sich die Konfiguration geändert hat. Derzeit ist Version 2 die einzige Hauptversion, bei der sich die Standardeinstellungen geändert haben. Daher besteht keine Notwendigkeit, diese Eigenschaft festzulegen, sie ist jedoch für die zukünftige Verwendung vorhanden.
Sie können eine Eigenschaftendatei auch entschlüsseln, alle ihre Eigenschaften in den Speicher laden und sie für Maven zugänglich machen. Dies ist nützlich, wenn Sie anderen Maven-Plugins verschlüsselte Eigenschaften zur Verfügung stellen möchten.
Sie können die Ziele der späteren Plugins direkt nach diesem verketten. Zum Beispiel mit Flyway:
mvn jasypt:load flyway:migrate -Djasypt.encryptor.password= " the password " Sie können mit -Djasypt.plugin.keyPrefix=example. . Dies hilft, mögliche Konflikte mit anderen Maven-Eigenschaften zu vermeiden.
Für alle oben genannten Dienstprogramme lautet der Pfad der Datei, die Sie verschlüsseln/entschlüsseln, standardmäßig file:src/main/resources/application.properties .
Dies kann mit der Systemeigenschaft -Djasypt.plugin.path geändert werden.
Sie können eine Datei in Ihrem Testressourcenverzeichnis verschlüsseln:
mvn jasypt:encrypt -Djasypt.plugin.path= " file:src/main/test/application.properties " -Djasypt.encryptor.password= " the password "Oder mit einem anderen Namen:
mvn jasypt:encrypt -Djasypt.plugin.path= " file:src/main/resources/flyway.properties " -Djasypt.encryptor.password= " the password "Oder mit einem anderen Dateityp (das Plugin unterstützt jedes Nur-Text-Dateiformat einschließlich YAML):
mvn jasypt:encrypt -Djasypt.plugin.path= " file:src/main/resources/application.yaml " -Djasypt.encryptor.password= " the password "Beachten Sie, dass das Ladeziel nur .property-Dateien unterstützt
Sie können jede Spring-Konfiguration, die Sie in Ihrer Anwendung unterstützen, beim Ausführen des Plugins überschreiben, indem Sie beispielsweise ein bestimmtes Spring-Profil auswählen:
mvn jasypt:encrypt -Dspring.profiles.active=cloud -Djasypt.encryptor.password= " the password " Um Eigenschaften in Projekten mit mehreren Modulen zu verschlüsseln/entschlüsseln, deaktivieren Sie die Rekursion mit -N oder --non-recursive im Maven-Befehl:
mvn jasypt:upgrade -Djasypt.plugin.path=file:server/src/test/resources/application-test.properties -Djasypt.encryptor.password=supersecret -N jasypt-spring-boot:2.1.1 führt eine neue Funktion zum Verschlüsseln/Entschlüsseln von Eigenschaften mithilfe asymmetrischer Verschlüsselung mit einem Paar privater/öffentlicher Schlüssel im DER- oder PEM-Format ein.
Im Folgenden finden Sie die Konfigurationseigenschaften, mit denen Sie die asymmetrische Entschlüsselung von Eigenschaften konfigurieren können.
| Schlüssel | Standardwert | Beschreibung |
| jasypt.encryptor.privateKeyString | null | Privater Schlüssel zur Entschlüsselung im String-Format |
| jasypt.encryptor.privateKeyLocation | null | Speicherort des privaten Schlüssels für die Entschlüsselung im Spring-Ressourcenformat |
| jasypt.encryptor.privateKeyFormat | DER | Schlüsselformat. DER oder PEM |
Sie sollten entweder privateKeyString oder privateKeyLocation verwenden. Das String-Format hat Vorrang, wenn es festgelegt ist. Um einen privaten Schlüssel im DER-Format mit privateKeyString anzugeben, kodieren Sie bitte die Schlüsselbytes in base64 .
Beachten Sie , dass jasypt.encryptor.password bei der PBE-Verschlüsselung immer noch Vorrang vor der asymmetrischen Konfiguration hat.
jasypt :
encryptor :
privateKeyString: MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCtB/IYK8E52CYMZTpyIY9U0HqMewyKnRvSo6s+9VNIn/HSh9+MoBGiADa2MaPKvetS3CD3CgwGq/+LIQ1HQYGchRrSORizOcIp7KBx+Wc1riatV/tcpcuFLC1j6QJ7d2I+T7RA98Sx8X39orqlYFQVysTw/aTawX/yajx0UlTW3rNAY+ykeQ0CBHowtTxKM9nGcxLoQbvbYx1iG9JgAqye7TYejOpviOH+BpD8To2S8zcOSojIhixEfayay0gURv0IKJN2LP86wkpAuAbL+mohUq1qLeWdTEBrIRXjlnrWs1M66w0l/6JwaFnGOqEB6haMzE4JWZULYYpr2yKyoGCRAgMBAAECggEAQxURhs1v3D0wgx27ywO3zeoFmPEbq6G9Z6yMd5wk7cMUvcpvoNVuAKCUlY4pMjDvSvCM1znN78g/CnGF9FoxJb106Iu6R8HcxOQ4T/ehS+54kDvL999PSBIYhuOPUs62B/Jer9FfMJ2veuXb9sGh19EFCWlMwILEV/dX+MDyo1qQaNzbzyyyaXP8XDBRDsvPL6fPxL4r6YHywfcPdBfTc71/cEPksG8ts6um8uAVYbLIDYcsWopjVZY/nUwsz49xBCyRcyPnlEUJedyF8HANfVEO2zlSyRshn/F+rrjD6aKBV/yVWfTEyTSxZrBPl4I4Tv89EG5CwuuGaSagxfQpAQKBgQDXEe7FqXSaGk9xzuPazXy8okCX5pT6545EmqTP7/JtkMSBHh/xw8GPp+JfrEJEAJJl/ISbdsOAbU+9KAXuPmkicFKbodBtBa46wprGBQ8XkR4JQoBFj1SJf7Gj9ozmDycozO2Oy8a1QXKhHUPkbPQ0+w3efwoYdfE67ZodpFNhswKBgQDN9eaYrEL7YyD7951WiK0joq0BVBLK3rwO5+4g9IEEQjhP8jSo1DP+zS495t5ruuuuPsIeodA79jI8Ty+lpYqqCGJTE6muqLMJDiy7KlMpe0NZjXrdSh6edywSz3YMX1eAP5U31pLk0itMDTf2idGcZfrtxTLrpRffumowdJ5qqwKBgF+XZ+JRHDN2aEM0atAQr1WEZGNfqG4Qx4o0lfaaNs1+H+knw5kIohrAyvwtK1LgUjGkWChlVCXb8CoqBODMupwFAqKL/IDImpUhc/t5uiiGZqxE85B3UWK/7+vppNyIdaZL13a1mf9sNI/p2whHaQ+3WoW/P3R5z5uaifqM1EbDAoGAN584JnUnJcLwrnuBx1PkBmKxfFFbPeSHPzNNsSK3ERJdKOINbKbaX+7DlT4bRVbWvVj/jcw/c2Ia0QTFpmOdnivjefIuehffOgvU8rsMeIBsgOvfiZGx0TP3+CCFDfRVqjIBt3HAfAFyZfiP64nuzOERslL2XINafjZW5T0pZz8CgYAJ3UbEMbKdvIuK+uTl54R1Vt6FO9T5bgtHR4luPKoBv1ttvSC6BlalgxA0Ts/AQ9tCsUK2JxisUcVgMjxBVvG0lfq/EHpL0Wmn59SHvNwtHU2qx3Ne6M0nQtneCCfR78OcnqQ7+L+3YCMqYGJHNFSard+dewfKoPnWw0WyGFEWCg==
jasypt :
encryptor :
privateKeyLocation : classpath:private_key.der
jasypt :
encryptor :
privateKeyFormat : PEM
privateKeyString : |-
-----BEGIN PRIVATE KEY-----
MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCtB/IYK8E52CYM
ZTpyIY9U0HqMewyKnRvSo6s+9VNIn/HSh9+MoBGiADa2MaPKvetS3CD3CgwGq/+L
IQ1HQYGchRrSORizOcIp7KBx+Wc1riatV/tcpcuFLC1j6QJ7d2I+T7RA98Sx8X39
orqlYFQVysTw/aTawX/yajx0UlTW3rNAY+ykeQ0CBHowtTxKM9nGcxLoQbvbYx1i
G9JgAqye7TYejOpviOH+BpD8To2S8zcOSojIhixEfayay0gURv0IKJN2LP86wkpA
uAbL+mohUq1qLeWdTEBrIRXjlnrWs1M66w0l/6JwaFnGOqEB6haMzE4JWZULYYpr
2yKyoGCRAgMBAAECggEAQxURhs1v3D0wgx27ywO3zeoFmPEbq6G9Z6yMd5wk7cMU
vcpvoNVuAKCUlY4pMjDvSvCM1znN78g/CnGF9FoxJb106Iu6R8HcxOQ4T/ehS+54
kDvL999PSBIYhuOPUs62B/Jer9FfMJ2veuXb9sGh19EFCWlMwILEV/dX+MDyo1qQ
aNzbzyyyaXP8XDBRDsvPL6fPxL4r6YHywfcPdBfTc71/cEPksG8ts6um8uAVYbLI
DYcsWopjVZY/nUwsz49xBCyRcyPnlEUJedyF8HANfVEO2zlSyRshn/F+rrjD6aKB
V/yVWfTEyTSxZrBPl4I4Tv89EG5CwuuGaSagxfQpAQKBgQDXEe7FqXSaGk9xzuPa
zXy8okCX5pT6545EmqTP7/JtkMSBHh/xw8GPp+JfrEJEAJJl/ISbdsOAbU+9KAXu
PmkicFKbodBtBa46wprGBQ8XkR4JQoBFj1SJf7Gj9ozmDycozO2Oy8a1QXKhHUPk
bPQ0+w3efwoYdfE67ZodpFNhswKBgQDN9eaYrEL7YyD7951WiK0joq0BVBLK3rwO
5+4g9IEEQjhP8jSo1DP+zS495t5ruuuuPsIeodA79jI8Ty+lpYqqCGJTE6muqLMJ
Diy7KlMpe0NZjXrdSh6edywSz3YMX1eAP5U31pLk0itMDTf2idGcZfrtxTLrpRff
umowdJ5qqwKBgF+XZ+JRHDN2aEM0atAQr1WEZGNfqG4Qx4o0lfaaNs1+H+knw5kI
ohrAyvwtK1LgUjGkWChlVCXb8CoqBODMupwFAqKL/IDImpUhc/t5uiiGZqxE85B3
UWK/7+vppNyIdaZL13a1mf9sNI/p2whHaQ+3WoW/P3R5z5uaifqM1EbDAoGAN584
JnUnJcLwrnuBx1PkBmKxfFFbPeSHPzNNsSK3ERJdKOINbKbaX+7DlT4bRVbWvVj/
jcw/c2Ia0QTFpmOdnivjefIuehffOgvU8rsMeIBsgOvfiZGx0TP3+CCFDfRVqjIB
t3HAfAFyZfiP64nuzOERslL2XINafjZW5T0pZz8CgYAJ3UbEMbKdvIuK+uTl54R1
Vt6FO9T5bgtHR4luPKoBv1ttvSC6BlalgxA0Ts/AQ9tCsUK2JxisUcVgMjxBVvG0
lfq/EHpL0Wmn59SHvNwtHU2qx3Ne6M0nQtneCCfR78OcnqQ7+L+3YCMqYGJHNFSa
rd+dewfKoPnWw0WyGFEWCg==
-----END PRIVATE KEY-----
jasypt :
encryptor :
privateKeyFormat : PEM
privateKeyLocation : classpath:private_key.pem
Es gibt kein Programm/Befehl zum Verschlüsseln von Eigenschaften mit asymmetrischen Schlüsseln, aber Sie können das folgende Codefragment verwenden, um Ihre Eigenschaften zu verschlüsseln:
import com . ulisesbocchio . jasyptspringboot . encryptor . SimpleAsymmetricConfig ;
import com . ulisesbocchio . jasyptspringboot . encryptor . SimpleAsymmetricStringEncryptor ;
import org . jasypt . encryption . StringEncryptor ;
public class PropertyEncryptor {
public static void main ( String [] args ) {
SimpleAsymmetricConfig config = new SimpleAsymmetricConfig ();
config . setPublicKey ( "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArQfyGCvBOdgmDGU6ciGPVNB6jHsMip0b0qOrPvVTSJ/x0offjKARogA2tjGjyr3rUtwg9woMBqv/iyENR0GBnIUa0jkYsznCKeygcflnNa4mrVf7XKXLhSwtY+kCe3diPk+0QPfEsfF9/aK6pWBUFcrE8P2k2sF/8mo8dFJU1t6zQGPspHkNAgR6MLU8SjPZxnMS6EG722MdYhvSYAKsnu02Hozqb4jh/gaQ/E6NkvM3DkqIyIYsRH2smstIFEb9CCiTdiz/OsJKQLgGy/pqIVKtai3lnUxAayEV45Z61rNTOusNJf+icGhZxjqhAeoWjMxOCVmVC2GKa9sisqBgkQIDAQAB" );
StringEncryptor encryptor = new SimpleAsymmetricStringEncryptor ( config );
String message = "chupacabras" ;
String encrypted = encryptor . encrypt ( message );
System . out . printf ( "Encrypted message %s n " , encrypted );
}
} import com . ulisesbocchio . jasyptspringboot . encryptor . SimpleAsymmetricConfig ;
import com . ulisesbocchio . jasyptspringboot . encryptor . SimpleAsymmetricStringEncryptor ;
import org . jasypt . encryption . StringEncryptor ;
import static com . ulisesbocchio . jasyptspringboot . util . AsymmetricCryptography . KeyFormat . PEM ;
public class PropertyEncryptor {
public static void main ( String [] args ) {
SimpleAsymmetricConfig config = new SimpleAsymmetricConfig ();
config . setKeyFormat ( PEM );
config . setPublicKey ( "-----BEGIN PUBLIC KEY----- n " +
"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArQfyGCvBOdgmDGU6ciGP n " +
"VNB6jHsMip0b0qOrPvVTSJ/x0offjKARogA2tjGjyr3rUtwg9woMBqv/iyENR0GB n " +
"nIUa0jkYsznCKeygcflnNa4mrVf7XKXLhSwtY+kCe3diPk+0QPfEsfF9/aK6pWBU n " +
"FcrE8P2k2sF/8mo8dFJU1t6zQGPspHkNAgR6MLU8SjPZxnMS6EG722MdYhvSYAKs n " +
"nu02Hozqb4jh/gaQ/E6NkvM3DkqIyIYsRH2smstIFEb9CCiTdiz/OsJKQLgGy/pq n " +
"IVKtai3lnUxAayEV45Z61rNTOusNJf+icGhZxjqhAeoWjMxOCVmVC2GKa9sisqBg n " +
"kQIDAQAB n " +
"-----END PUBLIC KEY----- n " );
StringEncryptor encryptor = new SimpleAsymmetricStringEncryptor ( config );
String message = "chupacabras" ;
String encrypted = encryptor . encrypt ( message );
System . out . printf ( "Encrypted message %s n " , encrypted );
}
} Ab Version 3.0.5 wird die AES 256-GCM-Verschlüsselung unterstützt. Um diese Art der Verschlüsselung zu verwenden, legen Sie die Eigenschaft jasypt.encryptor.gcm-secret-key-string , jasypt.encryptor.gcm-secret-key-location oder jasypt.encryptor.gcm-secret-key-password fest.
Der zugrunde liegende Algorithmus ist AES/GCM/NoPadding Stellen Sie daher sicher, dass dieser in Ihrem JDK installiert ist.
Der SimpleGCMByteEncryptor verwendet einen IVGenerator zum Verschlüsseln von Eigenschaften. Sie können dies mit der Eigenschaft jasypt.encryptor.iv-generator-classname konfigurieren, wenn Sie nicht die Standardimplementierung RandomIvGenerator verwenden möchten
Wenn Sie einen Schlüssel über jasypt.encryptor.gcm-secret-key-string oder jasypt.encryptor.gcm-secret-key-location verwenden, stellen Sie sicher, dass Sie Ihren Schlüssel in Base64 kodieren. Der Base64-String-Wert könnte auf jasypt.encryptor.gcm-secret-key-string festgelegt werden oder einfach in einer Datei gespeichert und ein Spring-Ressourcen-Locator für diese Datei in der Eigenschaft jasypt.encryptor.gcm-secret-key-location verwendet werden. Zum Beispiel:
jasypt.encryptor.gcm-secret-key-string = " PNG5egJcwiBrd+E8go1tb9PdPvuRSmLSV3jjXBmWlIU= "
# OR
jasypt.encryptor.gcm-secret-key-location =classpath:secret_key.b64
# OR
jasypt.encryptor.gcm-secret-key-location =file:/full/path/secret_key.b64
# OR
jasypt.encryptor.gcm-secret-key-location =file:relative/path/secret_key.b64 Optional können Sie Ihre eigene StringEncryptor Bean erstellen:
@ Bean ( "encryptorBean" )
public StringEncryptor stringEncryptor () {
SimpleGCMConfig config = new SimpleGCMConfig ();
config . setSecretKey ( "PNG5egJcwiBrd+E8go1tb9PdPvuRSmLSV3jjXBmWlIU=" );
return new SimpleGCMStringEncryptor ( config );
}Alternativ können Sie zum Verschlüsseln/Entschlüsseln von Eigenschaften mithilfe von AES 256-GCM ein Kennwort verwenden. Das Passwort wird verwendet, um beim Start einen Schlüssel zu generieren. Daher müssen/können Sie einige Eigenschaften festlegen:
jasypt.encryptor.gcm-secret-key-password = " chupacabras "
# Optional, defaults to "1000"
jasypt.encryptor.key-obtention-iterations = " 1000 "
# Optional, defaults to 0, no salt. If provided, specify the salt string in ba64 format
jasypt.encryptor.gcm-secret-key-salt = " HrqoFr44GtkAhhYN+jP8Ag== "
# Optional, defaults to PBKDF2WithHmacSHA256
jasypt.encryptor.gcm-secret-key-algorithm = " PBKDF2WithHmacSHA256 " Stellen Sie sicher, dass diese Parameter identisch sind, wenn Sie Ihre Geheimnisse mit externen Tools verschlüsseln. Optional können Sie Ihre eigene StringEncryptor Bean erstellen:
@ Bean ( "encryptorBean" )
public StringEncryptor stringEncryptor () {
SimpleGCMConfig config = new SimpleGCMConfig ();
config . setSecretKeyPassword ( "chupacabras" );
config . setSecretKeyIterations ( 1000 );
config . setSecretKeySalt ( "HrqoFr44GtkAhhYN+jP8Ag==" );
config . setSecretKeyAlgorithm ( "PBKDF2WithHmacSHA256" );
return new SimpleGCMStringEncryptor ( config );
}Sie können das Maven-Plugin verwenden oder einer ähnlichen Strategie folgen, wie in den Verschlüsselungseigenschaften von Asymmetric Encryption erläutert
Das jasypt-spring-boot-demo-samples-Repository enthält Beispiele für funktionierende Spring Boot-Apps. Die Haupt-Demo-App „jasypt-spring-boot-demo“ legt explizit eine Systemeigenschaft mit dem Verschlüsselungskennwort fest, bevor die App ausgeführt wird. Um ein etwas realistischeres Szenario zu erhalten, entfernen Sie die Zeile, in der die Systemeigenschaft festgelegt ist, erstellen Sie die App mit Maven und führen Sie Folgendes aus:
java -jar target/jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar --jasypt.encryptor.password=password
Und Sie übergeben das Verschlüsselungskennwort als Befehlszeilenargument. Führen Sie es folgendermaßen aus:
java -Djasypt.encryptor.password=password -jar target/jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar
Und Sie übergeben das Verschlüsselungskennwort als Systemeigenschaft.
Wenn Sie diese Eigenschaft als Umgebungsvariable übergeben müssen, können Sie dies erreichen, indem Sie application.properties oder application.yml erstellen und Folgendes hinzufügen:
jasypt.encryptor.password=${JASYPT_ENCRYPTOR_PASSWORD:}
oder in YAML
jasypt:
encryptor:
password: ${JASYPT_ENCRYPTOR_PASSWORD:}
Im Wesentlichen definiert dies die Eigenschaft jasypt.encryptor.password , die auf eine andere Eigenschaft JASYPT_ENCRYPTOR_PASSWORD verweist, die Sie mit einer Umgebungsvariablen festlegen und die Sie auch über Systemeigenschaften überschreiben können. Diese Technik kann auch zum Übersetzen von Eigenschaftsnamen/-werten für jede andere benötigte Bibliothek verwendet werden. Dies ist auch in der Demo-App verfügbar. Sie können die Demo-App also wie folgt ausführen:
JASYPT_ENCRYPTOR_PASSWORD=password java -jar target/jasypt-spring-boot-demo-1.5-SNAPSHOT.jar
Hinweis: Wenn Sie Gradle als Build-Tool verwenden, schlägt die Aufgabe „processResources“ aufgrund des „$“-Zeichens fehl. Um dieses Problem zu lösen, müssen Sie diese Variable lediglich wie folgt „$“ scapen.
Während jasypt-spring-boot-demo eine umfassende Demo ist, die alle möglichen Möglichkeiten zum Verschlüsseln/Entschlüsseln von Eigenschaften zeigt, gibt es mehrere andere Demos, die isolierte Szenarien demonstrieren.
