jasypt spring boot
v3.0.5
Integração Jasypt para Spring boot 2.xe 3.0.0
Jasypt Spring Boot fornece suporte de criptografia para fontes de propriedade em aplicativos Spring Boot.
Existem 3 maneiras de integrar jasypt-spring-boot em seu projeto:
jasypt-spring-boot-starter ao seu classpath se estiver usando @SpringBootApplication ou @EnableAutoConfiguration para ativar propriedades criptografáveis em todo o Spring Environmentjasypt-spring-boot ao seu classpath e adicionando @EnableEncryptableProperties à sua classe de configuração principal para habilitar propriedades criptografáveis em todo o Spring Environmentjasypt-spring-boot ao seu classpath e declarando fontes de propriedades criptografáveis individuais com @EncrytablePropertySource Use um dos três métodos a seguir (resumidamente explicados acima):
Basta adicionar a dependência do jar inicial ao seu projeto se seu aplicativo Spring Boot usar @SpringBootApplication ou @EnableAutoConfiguration e as propriedades criptografáveis serão habilitadas em todo o Spring Environment (isso significa qualquer propriedade do sistema, propriedade do ambiente, argumento da linha de comando, application.properties, application -*.properties, propriedades yaml e quaisquer outras fontes de propriedade podem conter propriedades criptografadas):
< dependency >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-spring-boot-starter</ artifactId >
< version >3.0.5</ version >
</ dependency > SE você não usar as anotações de configuração automática @SpringBootApplication ou @EnableAutoConfiguration adicione esta dependência ao seu projeto:
< dependency >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-spring-boot</ artifactId >
< version >3.0.5</ version >
</ dependency > E então adicione @EnableEncryptableProperties à sua classe de configuração. Por exemplo:
@ Configuration
@ EnableEncryptableProperties
public class MyApplication {
...
}E as propriedades criptografáveis serão habilitadas em todo o Spring Environment (isso significa que qualquer propriedade do sistema, propriedade do ambiente, argumento da linha de comando, application.properties, propriedades yaml e quaisquer outras fontes de propriedades personalizadas podem conter propriedades criptografadas)
SE você não usar anotações de configuração automática @SpringBootApplication ou @EnableAutoConfiguration e não quiser habilitar propriedades criptografáveis em todo o ambiente Spring, há uma terceira opção. Primeiro adicione a seguinte dependência ao seu projeto:
< dependency >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-spring-boot</ artifactId >
< version >3.0.5</ version >
</ dependency > E, em seguida, adicione quantas anotações @EncryptablePropertySource desejar em seus arquivos de configuração. Assim como você faz com a anotação @PropertySource do Spring. Por exemplo:
@ Configuration
@ EncryptablePropertySource ( name = "EncryptedProperties" , value = "classpath:encrypted.properties" )
public class MyApplication {
...
} Convenientemente, há também uma anotação @EncryptablePropertySources que pode ser usada para agrupar anotações do tipo @EncryptablePropertySource assim:
@ Configuration
@ EncryptablePropertySources ({ @ EncryptablePropertySource ( "classpath:encrypted.properties" ),
@ EncryptablePropertySource ( "classpath:encrypted2.properties" )})
public class MyApplication {
...
} Além disso, observe que a partir da versão 1.8, @EncryptablePropertySource oferece suporte a arquivos YAML
A partir da versão 1.7 1.15, existe um quarto método para habilitar propriedades criptografáveis para alguns casos especiais. Uma classe ConfigurableEnvironment personalizada é fornecida: EncryptableEnvironmentStandardEncryptableEnvironment e StandardEncryptableServletEnvironment que podem ser usados com SpringApplicationBuilder para definir o ambiente customizado desta forma:
new SpringApplicationBuilder ()
. environment ( new StandardEncryptableEnvironment ())
. sources ( YourApplicationClass . class ). run ( args ); Este método exigiria apenas o uso de uma dependência para jasypt-spring-boot . Nenhuma dependência do jar inicial é necessária. Este método é útil para acesso antecipado de propriedades criptografadas no bootstrap. Embora não seja obrigatório na maioria dos cenários, pode ser útil ao personalizar o comportamento de inicialização do Spring Boot ou integrar-se a determinados recursos configurados muito cedo, como a configuração do Logging. Para um exemplo concreto, este método de habilitar propriedades criptografáveis é o único que funciona com a substituição de Spring Properties em arquivos logback-spring.xml , usando a tag springProperty . Por exemplo:
< 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 > Este mecanismo pode ser usado, por exemplo (conforme mostrado), para inicializar o Database Logging Appender que exige a passagem de credenciais confidenciais. Como alternativa, se for necessário fornecer um StringEncryptor personalizado, um método construtor estático será fornecido StandardEncryptableEnvironment#builder para personalização (outras personalizações são possíveis):
StandardEncryptableEnvironment
. builder ()
. encryptor ( new MyEncryptor ())
. build ()Isso acionará o carregamento de alguma configuração que basicamente faz duas coisas:
StringEncryptor padrão que pode ser configurado por meio de propriedades regulares, propriedades do sistema ou argumentos de linha de comando. Ao utilizar os MÉTODOS 1 e 2 você pode definir propriedades criptografadas em qualquer um dos PropertySource contidos no Ambiente. Por exemplo, usando a anotação @PropertySource:
@ SpringBootApplication
@ EnableEncryptableProperties
@ PropertySource ( name = "EncryptedProperties" , value = "classpath:encrypted.properties" )
public class MyApplication {
...
}E seu arquivo criptografado.properties ficaria mais ou menos assim:
secret.property =ENC(nrmZtkF7T0kjG/VodDvBw93Ct8EgjCA+) Agora, quando você faz environment.getProperty("secret.property") ou usa @Value("${secret.property}") o que você obtém é a versão descriptografada de secret.property .
Ao utilizar o MÉTODO 3 ( @EncryptablePropertySource ) então você pode acessar as propriedades criptografadas da mesma forma, a única diferença é que você deve colocar as propriedades no recurso que foi declarado dentro da anotação @EncryptablePropertySource para que as propriedades possam ser descriptografadas corretamente.
Jasypt usa um StringEncryptor para descriptografar propriedades. Para todos os 3 métodos, se nenhum StringEncryptor personalizado (consulte a seção Custom Encryptor para obter detalhes) for encontrado no Spring Context, um será criado automaticamente e poderá ser configurado por meio das seguintes propriedades (Sistema, arquivo de propriedades, argumentos de linha de comando, variável de ambiente, etc.):
| Chave | Obrigatório | Valor padrão |
| jasypt.encryptor.password | Verdadeiro | - |
| jasypt.encryptor.algorithm | Falso | PBEWITHHMACSHA512ANDAES_256 |
| jasypt.encryptor.key-obtenção-iterações | Falso | 1000 |
| jasypt.encryptor.pool-size | Falso | 1 |
| jasypt.encryptor.nome do provedor | Falso | Sun JCE |
| jasypt.encryptor.provider-class-name | Falso | nulo |
| jasypt.encryptor.salt-generator-classname | Falso | org.jasypt.salt.RandomSaltGenerator |
| jasypt.encryptor.iv-generator-classname | Falso | org.jasypt.iv.RandomIvGenerator |
| jasypt.encryptor.string-output-type | Falso | base64 |
| jasypt.encryptor.proxy-property-sources | Falso | falso |
| jasypt.encryptor.skip-property-sources | Falso | lista vazia |
A única propriedade necessária é a senha de criptografia, o restante pode ser deixado para usar os valores padrão. Embora todas essas propriedades possam ser declaradas em um arquivo de propriedades, a senha do criptografador não deve ser armazenada em um arquivo de propriedades, mas sim passada como propriedade do sistema, argumento de linha de comando ou variável de ambiente e desde que seu nome seja jasypt.encryptor.password funcionará.
A última propriedade, jasypt.encryptor.proxyPropertySources é usada para indicar jasyp-spring-boot como os valores das propriedades serão interceptados para descriptografia. O valor padrão false usa implementações de wrapper customizadas de PropertySource , EnumerablePropertySource e MapPropertySource . Quando true for especificado para esta propriedade, o mecanismo de interceptação usará proxies CGLib em cada implementação específica PropertySource . Isto pode ser útil em alguns cenários onde o tipo do PropertySource original deve ser preservado.
Para configuração customizada do criptografador e da origem da senha do criptografador, você sempre pode definir seu próprio bean StringEncryptor em seu Spring Context, e o criptografador padrão será ignorado. Por exemplo:
@ 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 ;
} Observe que o nome do bean é obrigatório, pois jasypt-spring-boot detecta String Encyptors personalizados por nome a partir da versão 1.5 . O nome do bean padrão é:
jasyptStringEncryptor
Mas também é possível substituir isso definindo a propriedade:
jasypt.encryptor.bean
Então, por exemplo, se você definir jasypt.encryptor.bean=encryptorBean então você definiria seu criptografador personalizado com esse nome:
@ Bean ( "encryptorBean" )
public StringEncryptor stringEncryptor () {
...
} A partir do jasypt-spring-boot-1.10 existem novos pontos de extensão. EncryptablePropertySource agora usa EncryptablePropertyResolver para resolver todas as propriedades:
public interface EncryptablePropertyResolver {
String resolvePropertyValue ( String value );
} As implementações desta interface são responsáveis por detectar e descriptografar propriedades. A implementação padrão, DefaultPropertyResolver usa o StringEncryptor mencionado anteriormente e um novo EncryptablePropertyDetector .
EncryptablePropertyDetector personalizado Você pode substituir a implementação padrão fornecendo um Bean do tipo EncryptablePropertyDetector com o nome encryptablePropertyDetector ou se quiser fornecer seu próprio nome de bean, substitua a propriedade jasypt.encryptor.property.detector-bean e especifique o nome que deseja dar ao bean. Ao fornecer isso, você será responsável por detectar propriedades criptografadas. Exemplo:
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 e suffix de propriedade criptografada personalizada Se tudo o que você deseja fazer é ter um prefixo/sufixo diferente para propriedades criptografadas, você pode continuar usando todas as implementações padrão e apenas substituir as seguintes propriedades em application.properties (ou application.yml ):
jasypt :
encryptor :
property :
prefix : " ENC@[ "
suffix : " ] "EncryptablePropertyResolver personalizado Você pode substituir a implementação padrão fornecendo um Bean do tipo EncryptablePropertyResolver com o nome encryptablePropertyResolver ou se quiser fornecer seu próprio nome de bean, substitua a propriedade jasypt.encryptor.property.resolver-bean e especifique o nome que deseja dar ao bean. Ao fornecer isso, você será responsável por detectar e descriptografar propriedades criptografadas. Exemplo:
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 ());
} Observe que, ao substituir EncryptablePropertyResolver , qualquer outra configuração ou substituição que você possa ter para prefixos, sufixos, EncryptablePropertyDetector e StringEncryptor deixará de funcionar, pois o resolvedor padrão é o que os utiliza. Você teria que conectar tudo isso sozinho. Felizmente, você não precisa substituir esse bean na maioria dos casos; as opções anteriores devem ser suficientes.
Mas como você pode ver na implementação, a detecção e descriptografia das propriedades criptografadas são internas ao MyEncryptablePropertyResolver
jasypt-spring-boot:2.1.0 introduz um novo recurso para especificar filtros de propriedade. O filtro faz parte da API EncryptablePropertyResolver e permite determinar quais propriedades ou fontes de propriedade contemplar para descriptografia. Isto é, antes mesmo de examinar o valor real da propriedade para procurá-lo ou tentar descriptografá-lo. Por exemplo, por padrão, todas as propriedades cujo nome começa com jasypt.encryptor são excluídas do exame. Isso evita dependências circulares no tempo de carregamento quando os beans da biblioteca são configurados.
Por padrão, o DefaultPropertyResolver usa DefaultPropertyFilter , que permite especificar as seguintes listas de padrões de string:
EncryptablePropertyFilter personalizado Você pode substituir a implementação padrão fornecendo um Bean do tipo EncryptablePropertyFilter com o nome encryptablePropertyFilter ou se quiser fornecer seu próprio nome de bean, substitua a propriedade jasypt.encryptor.property.filter-bean e especifique o nome que deseja dar ao bean. Ao fornecer isso, você será responsável por detectar propriedades e/ou fontes de propriedades que deseja contemplar para descriptografia. Exemplo:
class MyEncryptablePropertyFilter implements EncryptablePropertyFilter {
public boolean shouldInclude ( PropertySource <?> source , String name ) {
return name . startsWith ( 'encrypted.' );
}
} @ Bean ( name = "encryptablePropertyFilter" )
EncryptablePropertyFilter encryptablePropertyFilter () {
return new MyEncryptablePropertyFilter ();
} Observe que para que esse mecanismo funcione, você não deve fornecer um EncryptablePropertyResolver personalizado e, em vez disso, usar o resolvedor padrão. Se você fornecer um resolvedor personalizado, será responsável por todo o processo de detecção e descriptografia de propriedades.
PropertySourceDefina uma lista separada por vírgulas de nomes de classes totalmente qualificados a serem ignorados na introspecção. Estas classes não serão encapsuladas/proxy por este plugin e, portanto, as propriedades contidas nelas não suportarão criptografia/descriptografia:
jasypt.encryptor.skip-property-sources =org.springframework.boot.env.RandomValuePropertySource,org.springframework.boot.ansi.AnsiPropertySource As propriedades criptografadas são armazenadas em cache no seu aplicativo e em determinados cenários, como ao usar a configuração externalizada de um servidor de configuração, as propriedades precisam ser atualizadas quando forem alteradas. Para este jasypt-spring-boot registra um RefreshScopeRefreshedEventListener que escuta os seguintes eventos por padrão para limpar o cache de propriedades criptografadas:
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"
);Caso você precise registrar eventos extras que gostaria de acionar uma invalidação de cache criptografado, você pode adicioná-los usando a seguinte propriedade (separada por vírgula se mais de uma for necessária):
jasypt.encryptor.refreshed-event-classes =org.springframework.boot.context.event.ApplicationStartedEventUm plugin Maven é fornecido com vários utilitários úteis.
Para usar o plugin, basta adicionar o seguinte ao seu pom.xml:
< build >
< plugins >
< plugin >
< groupId >com.github.ulisesbocchio</ groupId >
< artifactId >jasypt-maven-plugin</ artifactId >
< version >3.0.5</ version >
</ plugin >
</ plugins >
</ build >Ao usar este plugin, a maneira mais fácil de fornecer sua senha de criptografia é através de uma propriedade do sistema, ou seja, -Djasypt.encryptor.password="a senha".
Por padrão, o plugin considerará a configuração de criptografia nos arquivos de configuração de inicialização padrão do Spring em ./src/main/resources. Você também pode usar propriedades do sistema ou variáveis de ambiente para fornecer essa configuração.
Lembre-se de que o restante do código e dos recursos do seu aplicativo não está disponível para o plug-in porque os plug-ins do Maven não compartilham um caminho de classe com os projetos. Se o seu aplicativo fornecer configuração de criptografia por meio de um bean StringEncryptor, isso não será detectado.
Em geral, é recomendado confiar apenas na configuração padrão segura.
Para criptografar um único valor, execute:
mvn jasypt:encrypt-value -Djasypt.encryptor.password= " the password " -Djasypt.plugin.value= " theValueYouWantToEncrypt " Para criptografar espaços reservados em src/main/resources/application.properties , simplesmente envolva qualquer string com DEC(...) . Por exemplo:
sensitive.password =DEC(secret value)
regular.property =exampleEntão execute:
mvn jasypt:encrypt -Djasypt.encryptor.password= " the password "O que editaria esse arquivo no local, resultando em:
sensitive.password =ENC(encrypted)
regular.property =exampleO nome e o local do arquivo podem ser personalizados.
Para descriptografar um único valor, execute:
mvn jasypt:decrypt-value -Djasypt.encryptor.password= " the password " -Djasypt.plugin.value= " DbG1GppXOsFa2G69PnmADvQFI3esceEhJYbaEIKCcEO5C85JEqGAhfcjFMGnoRFf " Para descriptografar espaços reservados em src/main/resources/application.properties , simplesmente envolva qualquer string com ENC(...) . Por exemplo:
sensitive.password =ENC(encrypted)
regular.property =exampleIsso pode ser descriptografado da seguinte forma:
mvn jasypt:decrypt -Djasypt.encryptor.password= " the password "O que geraria o conteúdo descriptografado na tela:
sensitive.password =DEC(decrypted)
regular.property =exampleObserve que a saída para a tela, em vez de editar o arquivo no local, foi projetada para reduzir a confirmação acidental de valores descriptografados para o controle de versão. Ao descriptografar, você provavelmente deseja apenas verificar qual valor foi criptografado, em vez de descriptografar permanentemente esse valor.
Alterar a configuração das propriedades criptografadas existentes é um pouco estranho usando os objetivos de criptografar/descriptografar. Você deve executar a meta de descriptografia usando a configuração antiga, depois copiar a saída descriptografada de volta para o arquivo original e, em seguida, executar a meta de criptografia com a nova configuração.
O objetivo de recriptografar simplifica isso criptografando novamente um arquivo no local. 2 conjuntos de configuração devem ser fornecidos. A nova configuração é fornecida da mesma forma que você configuraria os outros objetivos do maven. A configuração antiga é fornecida por meio de propriedades do sistema prefixadas com "jasypt.plugin.old" em vez de "jasypt.encryptor".
Por exemplo, para criptografar novamente application.properties que foi criptografado anteriormente com a senha ANTIGA e depois criptografar com a nova senha NOVA:
mvn jasypt:reencrypt -Djasypt.plugin.old.password=OLD -Djasypt.encryptor.password=NEWNota: Todas as configurações antigas devem ser passadas como propriedades do sistema. Variáveis de ambiente e arquivos de configuração do Spring Boot não são suportados.
Às vezes, a configuração de criptografia padrão pode mudar entre as versões do jasypt-spring-boot. Você pode atualizar automaticamente suas propriedades criptografadas para os novos padrões com a meta de atualização. Isso descriptografará seu arquivo application.properties usando a configuração padrão antiga e criptografará novamente usando a nova configuração padrão.
mvn jasypt:upgrade -Djasypt.encryptor.password=EXAMPLE Você também pode passar a propriedade do sistema -Djasypt.plugin.old.major-version para especificar a versão da qual você está atualizando. O padrão sempre será a última versão principal em que a configuração foi alterada. Atualmente, a única versão principal onde os padrões foram alterados é a versão 2, portanto não há necessidade de definir esta propriedade, mas ela está disponível para uso futuro.
Você também pode descriptografar um arquivo de propriedades e carregar todas as suas propriedades na memória e torná-las acessíveis ao Maven. Isso é útil quando você deseja disponibilizar propriedades criptografadas para outros plug-ins do Maven.
Você pode encadear os objetivos dos plug-ins posteriores diretamente após este. Por exemplo, com flyway:
mvn jasypt:load flyway:migrate -Djasypt.encryptor.password= " the password " Também é possível especificar um prefixo para cada propriedade com -Djasypt.plugin.keyPrefix=example. . Isso ajuda a evitar possíveis conflitos com outras propriedades do Maven.
Para todos os utilitários acima, o caminho do arquivo que você está criptografando/descriptografando é padronizado como file:src/main/resources/application.properties .
Isso pode ser alterado usando a propriedade de sistema -Djasypt.plugin.path .
Você pode criptografar um arquivo no diretório de recursos de teste:
mvn jasypt:encrypt -Djasypt.plugin.path= " file:src/main/test/application.properties " -Djasypt.encryptor.password= " the password "Ou com um nome diferente:
mvn jasypt:encrypt -Djasypt.plugin.path= " file:src/main/resources/flyway.properties " -Djasypt.encryptor.password= " the password "Ou com um tipo de arquivo diferente (o plugin suporta qualquer formato de arquivo de texto simples, incluindo YAML):
mvn jasypt:encrypt -Djasypt.plugin.path= " file:src/main/resources/application.yaml " -Djasypt.encryptor.password= " the password "Observe que a meta de carregamento suporta apenas arquivos .property
Você pode substituir qualquer configuração do Spring suportada em seu aplicativo ao executar o plug-in, por exemplo, selecionando um determinado perfil do Spring:
mvn jasypt:encrypt -Dspring.profiles.active=cloud -Djasypt.encryptor.password= " the password " Para criptografar/descriptografar propriedades em projetos de vários módulos, desative a recursão com -N ou --non-recursive no comando 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 introduz um novo recurso para criptografar/descriptografar propriedades usando criptografia assimétrica com um par de chaves privadas/públicas nos formatos DER ou PEM.
A seguir estão as propriedades de configuração que você pode usar para configurar a descriptografia assimétrica de propriedades;
| Chave | Valor padrão | Descrição |
| jasypt.encryptor.privateKeyString | nulo | chave privada para descriptografia em formato String |
| jasypt.encryptor.privateKeyLocation | nulo | localização da chave privada para descriptografia no formato de recurso Spring |
| jasypt.encryptor.privateKeyFormat | DER | Formato chave. DER ou PEM |
Você deve usar privateKeyString ou privateKeyLocation , o formato String tem precedência se definido. Para especificar uma chave privada no formato DER com privateKeyString , codifique os bytes da chave para base64 .
Observe que jasypt.encryptor.password ainda tem precedência para criptografia PBE sobre a configuração assimétrica.
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
Não há programa/comando para criptografar propriedades usando chaves assimétricas, mas você pode usar o seguinte trecho de código para criptografar suas propriedades:
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 );
}
} A partir da versão 3.0.5, a criptografia AES 256-GCM é suportada. Para usar esse tipo de criptografia, configure a propriedade jasypt.encryptor.gcm-secret-key-string , jasypt.encryptor.gcm-secret-key-location ou jasypt.encryptor.gcm-secret-key-password .
O algoritmo subjacente usado é AES/GCM/NoPadding , portanto, certifique-se de que esteja instalado em seu JDK.
O SimpleGCMByteEncryptor usa um IVGenerator para criptografar propriedades. Você pode configurar isso com a propriedade jasypt.encryptor.iv-generator-classname se não quiser usar a implementação padrão RandomIvGenerator
Ao usar uma chave via jasypt.encryptor.gcm-secret-key-string ou jasypt.encryptor.gcm-secret-key-location , certifique-se de codificar sua chave em base64. O valor da string base64 pode ser definido como jasypt.encryptor.gcm-secret-key-string ou apenas salvá-lo em um arquivo e usar um localizador de recursos spring para esse arquivo na propriedade jasypt.encryptor.gcm-secret-key-location . Por exemplo:
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 Opcionalmente, você pode criar seu próprio bean StringEncryptor :
@ Bean ( "encryptorBean" )
public StringEncryptor stringEncryptor () {
SimpleGCMConfig config = new SimpleGCMConfig ();
config . setSecretKey ( "PNG5egJcwiBrd+E8go1tb9PdPvuRSmLSV3jjXBmWlIU=" );
return new SimpleGCMStringEncryptor ( config );
}Como alternativa, você pode usar uma senha para criptografar/descriptografar propriedades usando AES 256-GCM. A senha é usada para gerar uma chave na inicialização, portanto, há algumas propriedades que você precisa/pode definir, são elas:
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 " Certifique-se de que esses parâmetros sejam os mesmos se você estiver criptografando seus segredos com ferramentas externas. Opcionalmente, você pode criar seu próprio 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 );
}Você pode usar o plug-in Maven ou seguir uma estratégia semelhante, conforme explicado em Propriedades de criptografia da criptografia assimétrica
O repositório jasypt-spring-boot-demo-samples contém exemplos funcionais de aplicativos Spring Boot. O aplicativo de demonstração principal jasypt-spring-boot-demo define explicitamente uma propriedade do sistema com a senha de criptografia antes da execução do aplicativo. Para ter um cenário um pouco mais realista, tente remover a linha onde a propriedade do sistema está definida, construa o aplicativo com maven e execute:
java -jar target/jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar --jasypt.encryptor.password=password
E você passará a senha de criptografia como argumento de linha de comando. Execute assim:
java -Djasypt.encryptor.password=password -jar target/jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar
E você passará a senha de criptografia como uma propriedade do sistema.
Se você precisar passar esta propriedade como uma variável de ambiente, poderá fazer isso criando application.properties ou application.yml e adicionando:
jasypt.encryptor.password=${JASYPT_ENCRYPTOR_PASSWORD:}
ou em YAML
jasypt:
encryptor:
password: ${JASYPT_ENCRYPTOR_PASSWORD:}
basicamente o que isso faz é definir a propriedade jasypt.encryptor.password apontando para uma propriedade diferente JASYPT_ENCRYPTOR_PASSWORD que você pode definir com uma variável de ambiente e também pode substituir por meio das propriedades do sistema. Esta técnica também pode ser usada para traduzir nomes/valores de propriedades para qualquer outra biblioteca necessária. Isso também está disponível no aplicativo Demo. Então você pode executar o aplicativo Demo assim:
JASYPT_ENCRYPTOR_PASSWORD=password java -jar target/jasypt-spring-boot-demo-1.5-SNAPSHOT.jar
Nota: Ao usar Gradle como ferramenta de construção, a tarefa processResources falha por causa do caracter '$', para resolver isso você só precisa fazer o escape desta variável como este '$'.
Embora jasypt-spring-boot-demo seja uma demonstração abrangente que mostra todas as maneiras possíveis de criptografar/descriptografar propriedades, existem outras demonstrações múltiplas que demonstram cenários isolados.
