jasypt spring boot
v3.0.5
Intégration Jasypt pour Spring Boot 2.x et 3.0.0
Jasypt Spring Boot fournit la prise en charge du chiffrement pour les sources de propriétés dans les applications Spring Boot.
Il existe 3 façons d'intégrer jasypt-spring-boot dans votre projet :
jasypt-spring-boot-starter à votre chemin de classe si vous utilisez @SpringBootApplication ou @EnableAutoConfiguration vous activerez les propriétés chiffrables dans l'ensemble de l'environnement Spring.jasypt-spring-boot à votre chemin de classe et ajout @EnableEncryptableProperties à votre classe de configuration principale pour activer les propriétés chiffrables dans l'ensemble de l'environnement Springjasypt-spring-boot à votre chemin de classe et déclaration de sources de propriétés chiffrables individuelles avec @EncrytablePropertySource Utilisez l’une des 3 méthodes suivantes (brièvement expliquées ci-dessus) :
Ajoutez simplement la dépendance du pot de démarrage à votre projet si votre application Spring Boot utilise @SpringBootApplication ou @EnableAutoConfiguration et les propriétés chiffrables seront activées dans l'ensemble de l'environnement Spring (cela signifie toute propriété système, propriété d'environnement, argument de ligne de commande, application.properties, application -*.properties, les propriétés yaml et toute autre source de propriétés peuvent contenir des propriétés chiffrées) :
< dependency >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-spring-boot-starter</ artifactId >
< version >3.0.5</ version >
</ dependency > SI vous n'utilisez pas les annotations @SpringBootApplication ou @EnableAutoConfiguration Auto Configuration, ajoutez cette dépendance à votre projet :
< dependency >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-spring-boot</ artifactId >
< version >3.0.5</ version >
</ dependency > Et puis ajoutez @EnableEncryptableProperties à votre classe de configuration. Par exemple:
@ Configuration
@ EnableEncryptableProperties
public class MyApplication {
...
}Et les propriétés chiffrables seront activées dans l'ensemble de l'environnement Spring (cela signifie que toute propriété système, propriété d'environnement, argument de ligne de commande, application.properties, propriétés yaml et toute autre source de propriétés personnalisées peuvent contenir des propriétés chiffrées)
SI vous n'utilisez pas les annotations @SpringBootApplication ou @EnableAutoConfiguration Auto Configuration et que vous ne souhaitez pas activer les propriétés chiffrables dans l'ensemble de l'environnement Spring, il existe une troisième option. Ajoutez d'abord la dépendance suivante à votre projet :
< dependency >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-spring-boot</ artifactId >
< version >3.0.5</ version >
</ dependency > Et puis ajoutez autant d'annotations @EncryptablePropertySource que vous le souhaitez dans vos fichiers de configuration. Tout comme vous le faites avec l'annotation @PropertySource de Spring. Par exemple:
@ Configuration
@ EncryptablePropertySource ( name = "EncryptedProperties" , value = "classpath:encrypted.properties" )
public class MyApplication {
...
} Idéalement, il existe également une annotation @EncryptablePropertySources que l'on pourrait utiliser pour regrouper des annotations de type @EncryptablePropertySource comme ceci :
@ Configuration
@ EncryptablePropertySources ({ @ EncryptablePropertySource ( "classpath:encrypted.properties" ),
@ EncryptablePropertySource ( "classpath:encrypted2.properties" )})
public class MyApplication {
...
} Notez également qu'à partir de la version 1.8, @EncryptablePropertySource prend en charge les fichiers YAML.
À partir de la version 1.7 1.15, une quatrième méthode d'activation des propriétés chiffrables existe pour certains cas particuliers. Une classe ConfigurableEnvironment personnalisée est fournie : EncryptableEnvironmentStandardEncryptableEnvironment et StandardEncryptableServletEnvironment qui peuvent être utilisés avec SpringApplicationBuilder pour définir l'environnement personnalisé de cette façon :
new SpringApplicationBuilder ()
. environment ( new StandardEncryptableEnvironment ())
. sources ( YourApplicationClass . class ). run ( args ); Cette méthode nécessiterait uniquement l'utilisation d'une dépendance pour jasypt-spring-boot . Aucune dépendance au pot de démarrage n’est requise. Cette méthode est utile pour un accès anticipé aux propriétés chiffrées lors du bootstrap. Bien que cela ne soit pas requis dans la plupart des scénarios, cela peut être utile lors de la personnalisation du comportement d'initialisation de Spring Boot ou de l'intégration de certaines fonctionnalités configurées très tôt, telles que la configuration de la journalisation. Pour un exemple concret, cette méthode d'activation des propriétés chiffrables est la seule qui fonctionne avec le remplacement des propriétés Spring dans les fichiers logback-spring.xml , à l'aide de la balise springProperty . Par exemple:
< 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 > Ce mécanisme pourrait être utilisé par exemple (comme illustré) pour initialiser Database Logging Appender qui nécessite la transmission d'informations d'identification sensibles. Alternativement, si un StringEncryptor personnalisé doit être fourni, une méthode de création statique est fournie StandardEncryptableEnvironment#builder pour la personnalisation (d'autres personnalisations sont possibles) :
StandardEncryptableEnvironment
. builder ()
. encryptor ( new MyEncryptor ())
. build ()Cela déclenchera le chargement d'une configuration qui fait essentiellement 2 choses :
StringEncryptor par défaut qui peut être configuré via des propriétés normales, des propriétés système ou des arguments de ligne de commande. Lorsque vous utilisez les MÉTHODES 1 et 2, vous pouvez définir des propriétés cryptées dans n'importe quelle PropertySource contenue dans l'environnement. Par exemple, en utilisant l'annotation @PropertySource :
@ SpringBootApplication
@ EnableEncryptableProperties
@ PropertySource ( name = "EncryptedProperties" , value = "classpath:encrypted.properties" )
public class MyApplication {
...
}Et votre fichier chiffré.properties ressemblerait à ceci :
secret.property =ENC(nrmZtkF7T0kjG/VodDvBw93Ct8EgjCA+) Maintenant, lorsque vous faites environment.getProperty("secret.property") ou utilisez @Value("${secret.property}") vous obtenez la version déchiffrée de secret.property .
Lorsque vous utilisez la MÉTHODE 3 ( @EncryptablePropertySource ), vous pouvez accéder aux propriétés chiffrées de la même manière, la seule différence est que vous devez placer les propriétés dans la ressource qui a été déclarée dans l'annotation @EncryptablePropertySource afin que les propriétés puissent être déchiffrées correctement.
Jasypt utilise un StringEncryptor pour décrypter les propriétés. Pour les 3 méthodes, si aucun StringEncryptor personnalisé (voir la section Custom Encryptor pour plus de détails) n'est trouvé dans le contexte Spring, un est créé automatiquement et peut être configuré via les propriétés suivantes (Système, fichier de propriétés, arguments de ligne de commande, variable d'environnement, etc.):
| Clé | Requis | Valeur par défaut |
| jasypt.encryptor.password | Vrai | - |
| jasypt.encryptor.algorithme | FAUX | PBEWITHHMACSHA512ANDAES_256 |
| jasypt.encryptor.key-obtention-iterations | FAUX | 1000 |
| jasypt.encryptor.pool-size | FAUX | 1 |
| jasypt.encryptor.provider-name | FAUX | SoleilJCE |
| jasypt.encryptor.provider-class-name | FAUX | nul |
| jasypt.encryptor.salt-generator-classname | FAUX | org.jasypt.salt.RandomSaltGenerator |
| jasypt.encryptor.iv-generator-classname | FAUX | org.jasypt.iv.RandomIvGenerator |
| jasypt.encryptor.string-output-type | FAUX | base64 |
| jasypt.encryptor.proxy-property-sources | FAUX | FAUX |
| jasypt.encryptor.skip-property-sources | FAUX | liste vide |
La seule propriété requise est le mot de passe de cryptage, le reste peut utiliser les valeurs par défaut. Bien que toutes ces propriétés puissent être déclarées dans un fichier de propriétés, le mot de passe du chiffreur ne doit pas être stocké dans un fichier de propriétés, il doit plutôt être transmis en tant que propriété système, argument de ligne de commande ou variable d'environnement et dans la mesure où son nom est jasypt.encryptor.password ça marchera.
La dernière propriété, jasypt.encryptor.proxyPropertySources est utilisée pour indiquer jasyp-spring-boot comment les valeurs de propriété vont être interceptées pour le déchiffrement. La valeur par défaut, false utilise des implémentations de wrapper personnalisées de PropertySource , EnumerablePropertySource et MapPropertySource . Lorsque true est spécifié pour cette propriété, le mécanisme d'interception utilisera les proxys CGLib sur chaque implémentation spécifique PropertySource . Cela peut être utile dans certains scénarios où le type du PropertySource d'origine doit être conservé.
Pour une configuration personnalisée du chiffreur et de la source du mot de passe du chiffreur, vous pouvez toujours définir votre propre bean StringEncryptor dans votre contexte Spring, et le chiffreur par défaut sera ignoré. Par exemple:
@ 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 ;
} Notez que le nom du bean est requis, car jasypt-spring-boot détecte les String Encyptors personnalisés par leur nom à partir de la version 1.5 . Le nom du bean par défaut est :
jasyptStringEncryptor
Mais on peut aussi contourner cela en définissant la propriété :
jasypt.encryptor.bean
Ainsi, par exemple, si vous définissez jasypt.encryptor.bean=encryptorBean , vous définirez votre chiffreur personnalisé avec ce nom :
@ Bean ( "encryptorBean" )
public StringEncryptor stringEncryptor () {
...
} Depuis jasypt-spring-boot-1.10 il existe de nouveaux points d'extension. EncryptablePropertySource utilise désormais EncryptablePropertyResolver pour résoudre toutes les propriétés :
public interface EncryptablePropertyResolver {
String resolvePropertyValue ( String value );
} Les implémentations de cette interface sont responsables à la fois de la détection et du déchiffrement des propriétés. L'implémentation par défaut, DefaultPropertyResolver utilise le StringEncryptor mentionné précédemment et un nouveau EncryptablePropertyDetector .
EncryptablePropertyDetector personnalisé Vous pouvez remplacer l'implémentation par défaut en fournissant un Bean de type EncryptablePropertyDetector avec le nom encryptablePropertyDetector ou si vous souhaitez fournir votre propre nom de bean, remplacez la propriété jasypt.encryptor.property.detector-bean et spécifiez le nom que vous souhaitez donner au bean. En fournissant cela, vous serez responsable de la détection des propriétés chiffrées. Exemple:
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 et suffix de propriété chiffrée personnalisée Si tout ce que vous voulez faire est d'avoir un préfixe/suffixe différent pour les propriétés chiffrées, vous pouvez continuer à utiliser toutes les implémentations par défaut et simplement remplacer les propriétés suivantes dans application.properties (ou application.yml ) :
jasypt :
encryptor :
property :
prefix : " ENC@[ "
suffix : " ] "EncryptablePropertyResolver personnalisé Vous pouvez remplacer l'implémentation par défaut en fournissant un Bean de type EncryptablePropertyResolver avec le nom encryptablePropertyResolver ou si vous souhaitez fournir votre propre nom de bean, remplacez la propriété jasypt.encryptor.property.resolver-bean et spécifiez le nom que vous souhaitez donner au bean. En fournissant cela, vous serez responsable de la détection et du déchiffrement des propriétés cryptées. Exemple:
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 ());
} Notez qu'en remplaçant EncryptablePropertyResolver , toute autre configuration ou remplacement que vous pourriez avoir pour les préfixes, suffixes, EncryptablePropertyDetector et StringEncryptor cessera de fonctionner puisque c'est le résolveur par défaut qui les utilise. Vous devrez câbler tout cela vous-même. Heureusement, vous n'avez pas besoin de remplacer ce bean dans la plupart des cas, les options précédentes devraient suffire.
Mais comme vous pouvez le voir dans l'implémentation, la détection et le déchiffrement des propriétés chiffrées sont internes à MyEncryptablePropertyResolver
jasypt-spring-boot:2.1.0 introduit une nouvelle fonctionnalité pour spécifier les filtres de propriétés. Le filtre fait partie de l'API EncryptablePropertyResolver et vous permet de déterminer les propriétés ou sources de propriétés à envisager pour le déchiffrement. C'est-à-dire, avant même d'examiner la valeur réelle de la propriété, de la rechercher ou d'essayer de la décrypter. Par exemple, par défaut, toutes les propriétés dont le nom commence par jasypt.encryptor sont exclues de l'examen. Cela permet d'éviter les dépendances circulaires au moment du chargement lorsque les beans de bibliothèque sont configurés.
Par défaut, DefaultPropertyResolver utilise DefaultPropertyFilter , qui vous permet de spécifier les listes de modèles de chaîne suivantes :
EncryptablePropertyFilter personnalisé Vous pouvez remplacer l'implémentation par défaut en fournissant un Bean de type EncryptablePropertyFilter avec le nom encryptablePropertyFilter ou si vous souhaitez fournir votre propre nom de bean, remplacez la propriété jasypt.encryptor.property.filter-bean et spécifiez le nom que vous souhaitez donner au bean. En fournissant cela, vous serez responsable de la détection des propriétés et/ou des sources de propriétés que vous souhaitez envisager pour le décryptage. Exemple:
class MyEncryptablePropertyFilter implements EncryptablePropertyFilter {
public boolean shouldInclude ( PropertySource <?> source , String name ) {
return name . startsWith ( 'encrypted.' );
}
} @ Bean ( name = "encryptablePropertyFilter" )
EncryptablePropertyFilter encryptablePropertyFilter () {
return new MyEncryptablePropertyFilter ();
} Notez que pour que ce mécanisme fonctionne, vous ne devez pas fournir de EncryptablePropertyResolver personnalisé et utiliser le résolveur par défaut à la place. Si vous fournissez un résolveur personnalisé, vous êtes responsable de l'ensemble du processus de détection et de déchiffrement des propriétés.
PropertySource pour les empêcher d'être introspectéesDéfinissez une liste de noms de classes complets, séparés par des virgules, à ignorer de l'introspection. Ces classes ne seront pas encapsulées/proxyées par ce plugin et donc les propriétés qu'elles contiennent ne seront pas prises en charge par le cryptage/déchiffrement :
jasypt.encryptor.skip-property-sources =org.springframework.boot.env.RandomValuePropertySource,org.springframework.boot.ansi.AnsiPropertySource Les propriétés chiffrées sont mises en cache dans votre application et dans certains scénarios, comme lors de l'utilisation d'une configuration externalisée à partir d'un serveur de configuration, les propriétés doivent être actualisées lorsqu'elles sont modifiées. Pour cela, jasypt-spring-boot enregistre un RefreshScopeRefreshedEventListener qui écoute les événements suivants par défaut pour vider le cache des propriétés chiffrées :
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"
);Si vous devez enregistrer des événements supplémentaires pour lesquels vous souhaitez déclencher une invalidation du cache chiffré, vous pouvez les ajouter à l'aide de la propriété suivante (séparés par une virgule si plusieurs sont nécessaires) :
jasypt.encryptor.refreshed-event-classes =org.springframework.boot.context.event.ApplicationStartedEventUn plugin Maven est fourni avec un certain nombre d'utilitaires utiles.
Pour utiliser le plugin, ajoutez simplement ce qui suit à votre pom.xml :
< build >
< plugins >
< plugin >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-maven-plugin</ artifactId >
< version >3.0.5</ version >
</ plugin >
</ plugins >
</ build >Lorsque vous utilisez ce plugin, le moyen le plus simple de fournir votre mot de passe de cryptage est via une propriété système, c'est-à-dire -Djasypt.encryptor.password="le mot de passe".
Par défaut, le plugin prendra en compte la configuration du chiffrement dans les fichiers de configuration de démarrage Spring standard sous ./src/main/resources. Vous pouvez également utiliser des propriétés système ou des variables d'environnement pour fournir cette configuration.
Gardez à l'esprit que le reste du code et des ressources de votre application ne sont pas disponibles pour le plugin car les plugins Maven ne partagent pas de chemin de classe avec les projets. Si votre application fournit une configuration de chiffrement via un bean StringEncryptor, celle-ci ne sera pas récupérée.
En général, il est recommandé de s’appuyer uniquement sur la configuration sécurisée par défaut.
Pour chiffrer une exécution à valeur unique :
mvn jasypt:encrypt-value -Djasypt.encryptor.password= " the password " -Djasypt.plugin.value= " theValueYouWantToEncrypt " Pour chiffrer les espaces réservés dans src/main/resources/application.properties , enveloppez simplement n'importe quelle chaîne avec DEC(...) . Par exemple:
sensitive.password =DEC(secret value)
regular.property =examplePuis exécutez :
mvn jasypt:encrypt -Djasypt.encryptor.password= " the password "Ce qui modifierait ce fichier sur place, ce qui donnerait :
sensitive.password =ENC(encrypted)
regular.property =exampleLe nom et l'emplacement du fichier peuvent être personnalisés.
Pour déchiffrer une exécution à valeur unique :
mvn jasypt:decrypt-value -Djasypt.encryptor.password= " the password " -Djasypt.plugin.value= " DbG1GppXOsFa2G69PnmADvQFI3esceEhJYbaEIKCcEO5C85JEqGAhfcjFMGnoRFf " Pour déchiffrer les espaces réservés dans src/main/resources/application.properties , enveloppez simplement n'importe quelle chaîne avec ENC(...) . Par exemple:
sensitive.password =ENC(encrypted)
regular.property =exampleCela peut être décrypté comme suit :
mvn jasypt:decrypt -Djasypt.encryptor.password= " the password "Ce qui afficherait le contenu décrypté à l'écran :
sensitive.password =DEC(decrypted)
regular.property =exampleNotez que la sortie à l'écran, plutôt que l'édition du fichier sur place, est conçue pour réduire la validation accidentelle des valeurs déchiffrées dans le contrôle de version. Lors du décryptage, vous souhaiterez probablement simplement vérifier quelle valeur a été chiffrée, plutôt que de vouloir décrypter cette valeur de manière permanente.
La modification de la configuration des propriétés chiffrées existantes est légèrement délicate en utilisant les objectifs de chiffrement/déchiffrement. Vous devez exécuter l'objectif de décryptage en utilisant l'ancienne configuration, puis recopier la sortie déchiffrée dans le fichier d'origine, puis exécuter l'objectif de chiffrement avec la nouvelle configuration.
L'objectif de re-chiffrement simplifie cela en rechiffrant un fichier en place. 2 jeux de configuration doivent être fournis. La nouvelle configuration est fournie de la même manière que vous configureriez les autres objectifs Maven. L'ancienne configuration est fournie via les propriétés système préfixées par "jasypt.plugin.old" au lieu de "jasypt.encryptor".
Par exemple, pour chiffrer à nouveau application.properties qui était précédemment chiffré avec le mot de passe OLD, puis chiffrer avec le nouveau mot de passe NEW :
mvn jasypt:reencrypt -Djasypt.plugin.old.password=OLD -Djasypt.encryptor.password=NEWRemarque : Toutes les anciennes configurations doivent être transmises en tant que propriétés système. Les variables d'environnement et les fichiers de configuration Spring Boot ne sont pas pris en charge.
Parfois, la configuration de chiffrement par défaut peut changer entre les versions de jasypt-spring-boot. Vous pouvez automatiquement mettre à niveau vos propriétés chiffrées vers les nouvelles valeurs par défaut avec l'objectif de mise à niveau. Cela décryptera votre fichier application.properties en utilisant l'ancienne configuration par défaut et le chiffrera à nouveau en utilisant la nouvelle configuration par défaut.
mvn jasypt:upgrade -Djasypt.encryptor.password=EXAMPLE Vous pouvez également transmettre la propriété système -Djasypt.plugin.old.major-version pour spécifier la version à partir de laquelle vous effectuez la mise à niveau. Il s'agira toujours par défaut de la dernière version majeure où la configuration a été modifiée. Actuellement, la seule version majeure dans laquelle les valeurs par défaut ont changé est la version 2, il n'est donc pas nécessaire de définir cette propriété, mais elle est là pour une utilisation future.
Vous pouvez également décrypter un fichier de propriétés, charger toutes ses propriétés en mémoire et les rendre accessibles à Maven. Ceci est utile lorsque vous souhaitez rendre les propriétés chiffrées disponibles pour d'autres plugins Maven.
Vous pouvez enchaîner les objectifs des plugins ultérieurs directement après celui-ci. Par exemple, avec la voie de migration :
mvn jasypt:load flyway:migrate -Djasypt.encryptor.password= " the password " Vous pouvez également spécifier un préfixe pour chaque propriété avec -Djasypt.plugin.keyPrefix=example. . Cela permet d'éviter des conflits potentiels avec d'autres propriétés Maven.
Pour tous les utilitaires ci-dessus, le chemin du fichier que vous cryptez/déchiffrez est par défaut file:src/main/resources/application.properties .
Cela peut être modifié à l'aide de la propriété système -Djasypt.plugin.path .
Vous pouvez chiffrer un fichier dans votre répertoire de ressources de test :
mvn jasypt:encrypt -Djasypt.plugin.path= " file:src/main/test/application.properties " -Djasypt.encryptor.password= " the password "Ou avec un autre nom :
mvn jasypt:encrypt -Djasypt.plugin.path= " file:src/main/resources/flyway.properties " -Djasypt.encryptor.password= " the password "Ou avec un type de fichier différent (le plugin prend en charge n'importe quel format de fichier texte brut, y compris YAML) :
mvn jasypt:encrypt -Djasypt.plugin.path= " file:src/main/resources/application.yaml " -Djasypt.encryptor.password= " the password "Notez que l'objectif de chargement ne prend en charge que les fichiers .property
Vous pouvez remplacer n'importe quelle configuration Spring que vous prenez en charge dans votre application lors de l'exécution du plugin, par exemple en sélectionnant un profil Spring donné :
mvn jasypt:encrypt -Dspring.profiles.active=cloud -Djasypt.encryptor.password= " the password " Pour chiffrer/déchiffrer les propriétés dans les projets multi-modules, désactivez la récursion avec -N ou --non-recursive sur la commande maven :
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 introduit une nouvelle fonctionnalité pour chiffrer/déchiffrer les propriétés en utilisant un chiffrement asymétrique avec une paire de clés privées/publiques aux formats DER ou PEM.
Voici les propriétés de configuration que vous pouvez utiliser pour configurer le déchiffrement asymétrique des propriétés :
| Clé | Valeur par défaut | Description |
| jasypt.encryptor.privateKeyString | nul | clé privée pour le décryptage au format String |
| jasypt.encryptor.privateKeyLocation | nul | emplacement de la clé privée pour le décryptage au format de ressource Spring |
| jasypt.encryptor.privateKeyFormat | DER | Format de clé. DER ou PEM |
Vous devez utiliser privateKeyString ou privateKeyLocation , le format String est prioritaire s'il est défini. Pour spécifier une clé privée au format DER avec privateKeyString , veuillez encoder les octets clés en base64 .
Notez que jasypt.encryptor.password est toujours prioritaire pour le cryptage PBE sur la configuration asymétrique.
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
Il n'existe aucun programme/commande pour chiffrer les propriétés à l'aide de clés asymétriques, mais vous pouvez utiliser l'extrait de code suivant pour chiffrer vos propriétés :
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 );
}
} Depuis la version 3.0.5, le cryptage AES 256-GCM est pris en charge. Pour utiliser ce type de cryptage, définissez la propriété jasypt.encryptor.gcm-secret-key-string , jasypt.encryptor.gcm-secret-key-location ou jasypt.encryptor.gcm-secret-key-password .
L'algorithme sous-jacent utilisé est AES/GCM/NoPadding , alors assurez-vous qu'il est installé dans votre JDK.
Le SimpleGCMByteEncryptor utilise un IVGenerator pour chiffrer les propriétés. Vous pouvez configurer cela avec la propriété jasypt.encryptor.iv-generator-classname si vous ne souhaitez pas utiliser l'implémentation par défaut RandomIvGenerator
Lorsque vous utilisez une clé via jasypt.encryptor.gcm-secret-key-string ou jasypt.encryptor.gcm-secret-key-location , assurez-vous d'encoder votre clé en base64. La valeur de la chaîne base64 peut être définie sur jasypt.encryptor.gcm-secret-key-string , ou simplement la sauvegarder dans un fichier et utiliser un localisateur de ressources Spring pour ce fichier dans la propriété jasypt.encryptor.gcm-secret-key-location . Par exemple:
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 Vous pouvez éventuellement créer votre propre bean StringEncryptor :
@ Bean ( "encryptorBean" )
public StringEncryptor stringEncryptor () {
SimpleGCMConfig config = new SimpleGCMConfig ();
config . setSecretKey ( "PNG5egJcwiBrd+E8go1tb9PdPvuRSmLSV3jjXBmWlIU=" );
return new SimpleGCMStringEncryptor ( config );
}Vous pouvez également utiliser un mot de passe pour crypter/déchiffrer les propriétés à l'aide d'AES 256-GCM. Le mot de passe est utilisé pour générer une clé au démarrage, vous devez donc/pouvez définir quelques propriétés, à savoir :
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 " Assurez-vous que ces paramètres sont les mêmes si vous chiffrez vos secrets avec des outils externes. Vous pouvez éventuellement créer votre propre bean StringEncryptor :
@ 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 );
}Vous pouvez utiliser le plugin Maven ou suivre une stratégie similaire comme expliqué dans les propriétés de chiffrement d'Asymétrique Encryption.
Le référentiel jasypt-spring-boot-demo-samples contient des exemples d'applications Spring Boot fonctionnelles. L'application de démonstration principale jasypt-spring-boot-demo définit explicitement une propriété système avec le mot de passe de cryptage avant l'exécution de l'application. Pour avoir un scénario un peu plus réaliste, essayez de supprimer la ligne où la propriété système est définie, créez l'application avec maven et exécutez :
java -jar target/jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar --jasypt.encryptor.password=password
Et vous transmettrez le mot de passe de cryptage comme argument de ligne de commande. Exécutez-le comme ceci :
java -Djasypt.encryptor.password=password -jar target/jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar
Et vous transmettrez le mot de passe de cryptage en tant que propriété système.
Si vous devez transmettre cette propriété en tant que variable d'environnement, vous pouvez le faire en créant application.properties ou application.yml et en ajoutant :
jasypt.encryptor.password=${JASYPT_ENCRYPTOR_PASSWORD:}
ou en YAML
jasypt:
encryptor:
password: ${JASYPT_ENCRYPTOR_PASSWORD:}
En gros, cela consiste à définir la propriété jasypt.encryptor.password pointant vers une propriété différente JASYPT_ENCRYPTOR_PASSWORD que vous pouvez définir avec une variable d'environnement et que vous pouvez également remplacer via les propriétés système. Cette technique peut également être utilisée pour traduire le nom/les valeurs de propriété de toute autre bibliothèque dont vous avez besoin. Ceci est également disponible dans l'application Démo. Vous pouvez donc exécuter l'application de démonstration comme ceci :
JASYPT_ENCRYPTOR_PASSWORD=password java -jar target/jasypt-spring-boot-demo-1.5-SNAPSHOT.jar
Remarque : lorsque vous utilisez Gradle comme outil de construction, la tâche processResources échoue à cause du caractère « $ ». Pour résoudre ce problème, il vous suffit de masquer cette variable comme ceci « $ ».
Bien que jasypt-spring-boot-demo soit une démo complète qui présente toutes les façons possibles de chiffrer/déchiffrer les propriétés, il existe d'autres démos multiples qui présentent des scénarios isolés.
