jasypt 加密和解密

摘要

博主写作此文时，该软件的最新版本为：Jasypt 1.9.3 RELEASED

Jasypt 简介
Jasypt 是一个 Java 库，它允许开发人员以最小的努力为项目添加基本的加密功能，而无需深入了解密码学的工作原理。

Jasypt 特征

Jasypt 提供简单的单向（摘要）和双向加密技术。
用于任何 JCE 提供程序的开放 API，而不仅仅是默认的 Java VM 提供程序。 Jasypt 可以很容易地与 Bouncy Castle 等知名提供商一起使用。
为您的用户密码提供更高的安全性。
二进制加密支持。 Jasypt 允许对二进制文件（字节数组）进行摘要和加密。在需要时加密您的对象或文件（例如通过网络发送）。
数值加密支持。除了文本和二进制文件，它还允许对数值进行摘要和加密（BigInteger 和 BigDecimal，加密 Hibernate 持久性时支持其他数字类型）。
完全线程安全。
支持加密/摘要池，以在多处理器/多核系统中实现高性能。
包括库的轻量级（“精简”）版本，以便在移动平台等大小受限的环境中具有更好的可管理性。
为加密新手提供简单、无需配置的加密工具，也为高级用户提供高度可配置的标准加密工具。
Hibernate 3、4 和 5 可选集成，用于以加密方式持久化映射实体的字段。字段加密在 Hibernate 映射文件中定义，它对应用程序的其余部分保持透明（对于敏感的个人数据、具有许多已启用读取的用户的数据库…）。加密文本、二进制文件、数字、布尔值、日期…
无缝集成到 Spring 应用程序中，具有适用于 Spring 2、Spring 3.0、Spring 3.1 和 Spring 4.0 的特定集成功能。 jasypt 中的所有摘要器和加密器都设计为易于从 Spring 使用（实例化、依赖注入…）。而且，由于它们是线程安全的，因此它们可以在像 Spring 这样的面向单例的环境中使用而无需担心同步问题。
Spring Security（原Acegi Security）可选集成，用于为安全框架执行密码加密和匹配任务，通过使用更安全的密码加密机制来提高用户密码的安全性，并为您提供更高程度的配置和控制。
提供用于加密全部或部分应用程序配置文件的高级功能，包括数据库密码等敏感信息。将加密配置无缝集成到普通的、基于 Spring 的和/或支持 Hibernate 的应用程序中。
提供易于使用的 CLI（命令行界面）工具，允许开发人员初始化他们的加密数据，并在维护任务或脚本中包含加密/解密/摘要操作。
集成到 Apache Wicket 中，以在您的安全应用程序中对 URL 进行更强大的加密。
全面的指南和 javadoc 文档，使开发人员能够更好地了解他们真正对数据做了什么。
强大的字符集支持，旨在充分加密和摘要文本，无论原始字符集是什么。完全支持日语、韩语、阿拉伯语等语言，没有编码或平台问题。
非常高级的配置功能：开发人员可以实施一些技巧，例如指示“加密器”向远程 HTTPS 服务器询问用于加密的密码。它可以让您满足您的安全需求。

下载 Jasypt

从GitHub下载Jasypt
使用Maven下载Jasypt
Spring Boot 集成 Jasypt

Jasypt 环境依赖要求
Java Virtual Machine

Jasypt 需要 Java 标准版 1.6 或更高版本。
如果您打算使用强加密算法（如 TripleDES），您可能需要下载并安装 Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files

Jasypt 的基本依赖项

从 1.7 版开始，jasypt 在与 Java 6 版或更高版本一起使用时不依赖于任何外部库。
如果您使用 Java SE 5 或更旧的版本作为较旧的 Jasypt 版本（小于 1.9.3），您将需要：International Components for Unicode (ICU) 3.4.4 或者更高版本。
另请注意，从 jasypt 1.8 开始，ICU (icu4j) 将用于规范化 Unicode，如果它存在于类路径中，即使使用 Java >= 6（尽管如此，icu4j 和 java.text.Normalizer 实现是完全兼容的）。

Jasypt 用法
简单用法：utils
使用 Jasypt 的最简单方法是使用其简单的加密工具，称为 utils，因为它们位于 org.jasypt.util 包中。

它们被称为 utils，因为它们是现成的、预先配置的摘要器和加密器，您可以在不了解其配置的情况下使用它们。

这些实用程序根据它们要执行的任务进行分类：

一般摘要（org.jasypt.util.digest.*）
密码加密（摘要）（org.jasypt.util.password.*）
文本加密 (org.jasypt.util.text.*)
数字加密 (org.jasypt.util.numeric.*)
二进制加密 (org.jasypt.util.binary.*)

提示：请注意，一般来说，当我们谈论“密码加密”时，我们实际上是在谈论“密码摘要”，这是技术上正确的术语。

一般摘要

org.jasypt.util.digest.Digester 在二进制级别执行消息摘要，其结果等同于从 java.security.MessageDigest 对象获得的结果，尽管以线程安全的方式运行并实现更合适的接口用于以 bean 为中心的环境。

        Digester digester = new Digester();digester.setAlgorithm("md5");System.out.println(digester.digest("wubo".getBytes()));

密码加密(摘要)。这里的所有类都实现了 org.jasypt.util.password.PasswordEncryptor 接口，以便它们可以在需要时互换使用。

1. org.jasypt.util.password.BasicPasswordEncryptor 可用于在用户注册时加密密码并在用户登录时检查输入密码。

        BasicPasswordEncryptor basicPasswordEncryptor = new BasicPasswordEncryptor();String pwd = basicPasswordEncryptor.encryptPassword("123456aA");System.out.println(pwd);System.out.println(basicPasswordEncryptor.checkPassword("123456aA",pwd));

2. org.jasypt.util.password.StrongPasswordEncryptor 实现了比 PasswordEncryptor 更高的密码安全性（计算成本更高）。

//        StrongPasswordEncryptor strongPasswordEncryptor = new StrongPasswordEncryptor();
//        String pwd1 = strongPasswordEncryptor.encryptPassword("123456aA");
//        System.out.println(pwd1);
//        System.out.println(strongPasswordEncryptor.checkPassword("123456aA",pwd1));

3. org.jasypt.util.password.ConfigurablePasswordEncryptor 允许开发人员决定要使用的算法，以及他/她是否想要应用完整的安全密码加密机制（如此处所述），还是为遗留集成生成一个简单的摘要原因。

//        ConfigurablePasswordEncryptor configurablePasswordEncryptor = new ConfigurablePasswordEncryptor();
//        configurablePasswordEncryptor.setAlgorithm("SHA-256");
//        configurablePasswordEncryptor.setPlainDigest(true);
//        configurablePasswordEncryptor.setStringOutputType("base64");
//        String pwd2 = configurablePasswordEncryptor.encryptPassword("123456aA");
//        System.out.println(pwd2);
//        System.out.println(configurablePasswordEncryptor.checkPassword("123456aA",pwd2));

文本加密

这里的所有类都实现了 org.jasypt.util.text.TextEncryptor 接口，以便在需要时可以互换使用它们。

1. org.jasypt.util.text.BasicTextEncryptor 允许用户使用正常强度算法加密和解密文本数据。为了能够加密和解密，这个加密器必须先设置密码。

//        BasicTextEncryptor basicTextEncryptor = new BasicTextEncryptor();
//        basicTextEncryptor.setPassword("8db3ec5839dc45c60cd798ea1bd7a191");
//        String pwd4 = basicTextEncryptor.encrypt("root");
//        System.out.println(pwd4);
//        String user = basicTextEncryptor.decrypt("eNSihlLb2QBTqeoAUAbpDA==");
//        System.out.println("user::" + user);
//        String pwd6 = basicTextEncryptor.decrypt("Z16Okww4hgauYki5SM0Ii9fCl1VS2YtR");
//        System.out.println("pwd::" + pwd6);

2. org.jasypt.util.text.StrongTextEncryptor 允许用户使用高强度算法加密和解密文本数据。（您可能需要下载并安装 Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 才能使用它）。为了能够加密和解密，这个加密器必须先设置密码。

//        StrongTextEncryptor strongTextEncryptor = new StrongTextEncryptor();
//        strongTextEncryptor.setPassword("123456aA");
//        String pwd6 = strongTextEncryptor.encrypt("wubo");
//        System.out.println(pwd6);
//        String pwd7 = strongTextEncryptor.decrypt(pwd6);
//        System.out.println(pwd7);

提示：更高的安全性：AES256TextEncryptor 实用程序类具有更安全的算法：PBEWithHMACSHA512AndAES_256，（您至少需要 Java 8 才能使用它）：

//        AES256TextEncryptor aes256TextEncryptor  = new AES256TextEncryptor();
//        aes256TextEncryptor.setPassword("123456aA");
//        String pwd8 = aes256TextEncryptor.encrypt("wubo");
//        System.out.println(pwd8);
//        String pwd9 = aes256TextEncryptor.decrypt(pwd8);
//        System.out.println(pwd9);

数值加密

这里的所有类都实现了 org.jasypt.util.numeric.DecimalNumberEncryptor 或 org.jasypt.util.numeric.IntegerNumberEncryptor 接口，以便它们可以在需要时互换使用。

1. org.jasypt.util.numeric.BasicIntegerNumberEncryptor 允许用户使用正常强度算法加密和解密 BigInteger 对象。为了能够加密和解密，这个加密器必须先设置密码。

//        BasicIntegerNumberEncryptor integerEncryptor = new BasicIntegerNumberEncryptor();
//        integerEncryptor.setPassword("123456aA");
//        BigInteger bigInteger = new BigInteger("1000000");
//        BigInteger myEncryptedNumber = integerEncryptor.encrypt(bigInteger);
//        System.out.println(myEncryptedNumber);
//        BigInteger bigInteger1 =integerEncryptor.decrypt(myEncryptedNumber);
//        System.out.println(bigInteger1);

2. org.jasypt.util.numeric.StrongIntegerNumberEncryptor 允许用户使用高强度算法加密和解密 BigInteger 对象。（您可能需要下载并安装 Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 才能使用它）。为了能够加密和解密，这个加密器必须先设置密码。

//        StrongIntegerNumberEncryptor integerEncryptor = new StrongIntegerNumberEncryptor();
//        integerEncryptor.setPassword("123456aA");
//        BigInteger myEncryptedNumber = integerEncryptor.encrypt(new BigInteger("200000"));
//        System.out.println(myEncryptedNumber);
//        BigInteger plainNumber = integerEncryptor.decrypt(myEncryptedNumber);
//        System.out.println(plainNumber);

提示：更高的安全性：AES256DecimalNumberEncryptor 实用程序类具有更安全的算法：PBEWithHMACSHA512AndAES_256，（您至少需要 Java 8 才能使用它）：

//        AES256IntegerNumberEncryptor numberEncryptor = new AES256IntegerNumberEncryptor();
//        numberEncryptor.setPassword("123456aA");
//        BigInteger myEncryptedNumber = numberEncryptor.encrypt(new BigInteger("300000"));
//        System.out.println(myEncryptedNumber);
//        BigInteger plainNumber = numberEncryptor.decrypt(myEncryptedNumber);
//        System.out.println(plainNumber);

3. org.jasypt.util.numeric.BasicDecimalNumberEncryptor 允许用户使用正常强度算法加密和解密 BigDecimal 对象。为了能够加密和解密，这个加密器必须先设置密码。

//        BasicDecimalNumberEncryptor decimalEncryptor = new BasicDecimalNumberEncryptor();
//        decimalEncryptor.setPassword("123456aA");
//        BigDecimal myEncryptedNumber = decimalEncryptor.encrypt(new BigDecimal("400000"));
//        System.out.println(myEncryptedNumber);
//        BigDecimal plainNumber = decimalEncryptor.decrypt(myEncryptedNumber);
//        System.out.println(plainNumber);
//

4.org.jasypt.util.numeric.StrongDecimalNumberEncryptor 允许用户使用高强度算法加密和解密 BigDecimal 对象。（您可能需要下载并安装 Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 才能使用它）。为了能够加密和解密，这个加密器必须先设置密码。

StrongDecimalNumberEncryptor decimalEncryptor = new StrongDecimalNumberEncryptor();
decimalEncryptor.setPassword(myEncryptionPassword);
BigDecimal myEncryptedNumber = decimalEncryptor.encrypt(myNumber);BigDecimal plainNumber = decimalEncryptor.decrypt(myEncryptedNumber);

提示：更高的安全性：AES256DecimalNumberEncryptor 实用程序类具有更安全的算法：PBEWithHMACSHA512AndAES_256，（您至少需要 Java 8 才能使用它）：

//        AES256DecimalNumberEncryptor numberEncryptor = new AES256DecimalNumberEncryptor();
//        numberEncryptor.setPassword("123456aA");
//        BigDecimal myEncryptedNumber = numberEncryptor.encrypt(new BigDecimal("500000"));
//        BigDecimal plainNumber = numberEncryptor.decrypt(myEncryptedNumber);

二进制加密

这里的所有类都实现了 org.jasypt.util.binary.BinaryEncryptor 接口，以便它们可以在需要时互换使用。

1. org.jasypt.util.binary.BasicBinaryEncryptor 允许用户使用正常强度算法加密和解密 byte[] 对象。为了能够加密和解密，这个加密器必须先设置密码。

//        BasicBinaryEncryptor binaryEncryptor = new BasicBinaryEncryptor();
//        binaryEncryptor.setPassword("123456aA");
//        byte[] myEncryptedBinary = binaryEncryptor.encrypt("wubo".getBytes());
//        byte[] plainBinary = binaryEncryptor.decrypt(myEncryptedBinary);
//        String s = new String(plainBinary);

2.org.jasypt.util.binary.StrongBinaryEncryptor 允许用户使用高强度算法加密和解密 byte[] 对象。（您可能需要下载并安装 Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 才能使用它）。为了能够加密和解密，这个加密器必须先设置密码。

//        StrongBinaryEncryptor binaryEncryptor = new StrongBinaryEncryptor();
//        binaryEncryptor.setPassword("123456aA");
//        byte[] myEncryptedBinary = binaryEncryptor.encrypt("wubo".getBytes());
//        byte[]  plainBinary = binaryEncryptor.decrypt(myEncryptedBinary);

提示：更高的安全性：AES256BinaryEncryptor 实用程序类具有更安全的算法：PBEWithHMACSHA512AndAES_256，（您至少需要 Java 8 才能使用它）：

//        AES256BinaryEncryptor binaryEncryptor = new AES256BinaryEncryptor();
//        binaryEncryptor.setPassword("123456aA");
//        byte[] myEncryptedBytes = binaryEncryptor.encrypt("wubo".getBytes());
//        byte[] plainBytes = binaryEncryptor.decrypt(myEncryptedBytes);

一般用法

本节将教您有关 jasypt 为您提供的工具，当在简单使用页面中找到的简单实用程序不足以满足您的需求时。

Digesters

Digesters 是专门用于从输入创建消息摘要（也称为散列）的类。

消息摘要是摘要（或哈希）函数的结果，它们是单向的，也就是说，从消息摘要开始，原始消息无法重构。

因此，消息摘要非常适合密码加密。事实上，在某些国家/地区，以未加密的方式存储用户密码，甚至以可逆（双向）方式加密都是违法的。

jasypt 中的消化器位于 org.jasypt.digest 包中，该包由以下接口组成：

ByteDigester 用于从字节数组输入创建摘要。
StringDigester 用于从字符串输入创建摘要。

以及以下标准实现：

StandardByteDigester：ByteDigester 的可配置性和极其安全的实现，按照 PKCS #5：基于密码的加密标准中给出的指令实现。
StandardStringDigester：与 StandardByteDigester 对应的字符串，接收字符串输入并返回字符集安全、BASE64（或十六进制）编码的字符串输出。

及其相应的基于池的实现，可在多处理器/多核系统中实现高性能：

PooledByteDigester：与 StandardByteDigester 相同的 API，但实际上包含这些对象的池，用于在循环中提供摘要/检查请求。
PooledStringDigester：与 StandardStringDigester 相同的 API，但实际上包含这些对象的池，用于在循环中提供摘要/检查请求。

使用它们可以非常简单：

//        StandardStringDigester digester = new StandardStringDigester();
//        digester.setAlgorithm("SHA-1");   // optionally set the algorithm
//        digester.setIterations(50000);  // increase security by performing 50000 hashing iterations
//        String digest = digester.digest("wubo");

这些标准的和池化的摘要器实现了一组连贯且安全的默认配置值，但它们可以通过两种方式进行额外配置：

通过调用其 setX(…) 方法（算法、提供者、盐大小等）
通过设置一个 DigesterConfig 对象来配置消化器。提供了此接口的默认 bean 实现 (SimpleDigesterConfig)，但用户可以创建他/她自己的实现，以便能够以他/她需要的任何方式检索配置参数。

提高多处理器/多核系统的性能

池化消化器具有与其非池化标准相关的完全相同的 API——因此它们可以互换使用——但添加了一个新的必需配置方法，称为 setPoolSize()，用于确定它们将在内部保留的标准消化器的数量。

        PooledStringDigester digester = new PooledStringDigester();
//        digester.setPoolSize(4);          // This would be a good value for a 4-core system
//        digester.setAlgorithm("SHA-1");
//        digester.setIterations(50000);
//        String digest = digester.digest("wubo");

这些池化对象将使用其内部 Standard* 摘要器以循环方式为请求提供服务，因此由标准工件中的同步代码导致的线程阻塞量减少到最低限度。

这些实现不会创建新线程，因此它们可以安全地用于不允许创建新线程的容器控制环境中。

为特定应用程序和机器推荐的池大小取决于许多因素，但将大致等于机器中处理器/内核的数量。

Encryptors

加密器是专门用于执行双向加密操作的类。也就是说，它们既可以加密纯数据，也可以解密加密数据。

jasypt 中加密的相关接口位于 org.jasypt.encryption 包中，它们是：

ByteEncryptor 用于字节数组的加密和解密。
StringEncryptor 用于字符串的加密和解密。
BigIntegerEncryptor 用于对 BigInteger 进行加密和解密。
BigDecimalEncryptor 用于对 BigDecimals 进行加密和解密。

Jasypt 提供了一种加密类型的实现：基于密码的加密 (PBE)。

基于密码的加密是通过从用户提供的密码生成加密密钥，并将输入和生成的密钥提供给加密算法来执行的。密钥通常是通过对密码应用一些散列函数来获得的。

因此，jasypt 中的所有 PBE 加密器都需要在用于加密或解密操作之前设置密码。

jasypt 中 PBE 的相关接口位于 org.jasypt.encryption.pbe 包中，它们是：

PBEByteEncryptor 用于字节数组的基于密码的加密和解密。
PBEStringEncryptor 用于基于密码的字符串加密和解密。
PBEBigIntegerEncryptor 用于 BigInteger 的基于密码的加密和解密。
PBEBigDecimalEncryptor 用于 BigDecimals 的基于密码的加密和解密。

以及以下标准实现：

StandardPBEByteEncryptor：PBEByteEncryptor 的非常可配置且极其安全的实现，按照 PKCS #5：基于密码的加密标准中给出的指令实现。
StandardPBEStringEncryptor：StandardPBEByteEncryptor 的字符串对应物，接收字符串输入并返回字符集安全、BASE64（或十六进制）编码的字符串输出作为加密结果。
StandardPBEBigIntegerEncryptor：相当于StandardPBEByteEncryptor，接收BigInteger输入，返回BigInteger输出。
StandardPBEBigDecimalEncryptor：相当于StandardPBEByteEncryptor，接收BigDecimal 输入并返回BigDecimal 输出。

及其相应的基于池的实现，可在多处理器/多核系统中实现高性能：

PooledPBEByteEncryptor：与 StandardPBEByteEncryptor 相同的 API，但实际上包含这些对象的池，用于在循环中为加密/解密请求提供服务。
PooledPBEStringEncryptor：与 StandardPBEStringEncryptor 相同的 API，但实际上包含这些对象的池，用于在循环中为加密/解密请求提供服务。
PooledPBEBigIntegerEncryptor：与 StandardPBEBigIntegerEncryptor 相同的 API，但实际上包含这些对象的池，用于在循环中提供加密/解密请求。
PooledPBEBigDecimalEncryptor：与 StandardPBEBigDecimalEncryptor 相同的 API，但实际上包含这些对象的池，用于在循环中为加密/解密请求提供服务。

它的基本用法可以非常简单：

StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor();
encryptor.setPassword("jasypt");                         // we HAVE TO set a password
encryptor.setAlgorithm("PBEWithHMACSHA512AndAES_256");   // optionally set the algorithm
encryptor.setIvGenerator(new RandomIvGenerator());       // for PBE-AES-based algorithms, the IV generator is MANDATORYString encryptedText = encryptor.encrypt(myText);String plainText = encryptor.decrypt(encryptedText);  // myText.equals(plainText)

与摘要器一样，标准*加密器实现了一组连贯且安全的默认配置值（密码除外），但它们也可以通过两种方式进行额外配置：

通过调用其 setX(…) 方法（算法、提供者、密码、salt、IV 等…）
通过设置配置消化器的 PBEConfig 对象。提供了此接口的默认 bean 实现 (SimplePBEConfig)，但用户可以创建他/她自己的实现，以便能够以他/她需要的任何方式检索配置参数（例如，从远程服务器检索密码）。

提高多处理器/多核系统的性能

池化加密器与非池化标准相关的 API 完全相同——因此它们可以互换使用——但添加了一个名为 setPoolSize() 的新必需配置方法，该方法建立了它们将在内部保留的标准加密器的数量。

PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
encryptor.setPoolSize(4);          // This would be a good value for a 4-core system
encryptor.setPassword("jasypt");
encryptor.setAlgorithm("PBEWithMD5AndTripleDES");String encryptedText = encryptor.encrypt(myText);

这些池化对象将使用其内部 Standard* 加密器以循环方式为请求提供服务，因此由标准工件中的同步代码导致的线程阻塞量减少到最低限度。

这些实现不会创建新线程，因此它们可以安全地用于不允许创建新线程的容器控制环境中。

为特定应用程序和机器推荐的池大小取决于许多因素，但将大致等于机器中处理器/内核的数量。

all-code

package com.cn.jettech.jettoproimage.controller.imagecontroller01.imagecontroller01.jasypt;import org.jasypt.digest.PooledStringDigester;
import org.jasypt.digest.StandardStringDigester;
import org.jasypt.util.binary.AES256BinaryEncryptor;
import org.jasypt.util.binary.BasicBinaryEncryptor;
import org.jasypt.util.binary.StrongBinaryEncryptor;
import org.jasypt.util.digest.Digester;
import org.jasypt.util.numeric.*;
import org.jasypt.util.password.BasicPasswordEncryptor;
import org.jasypt.util.password.ConfigurablePasswordEncryptor;
import org.jasypt.util.password.StrongPasswordEncryptor;
import org.jasypt.util.text.AES256TextEncryptor;
import org.jasypt.util.text.BasicTextEncryptor;
import org.jasypt.util.text.StrongTextEncryptor;import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;//https://blog.csdn.net/Gjw_java/article/details/119298471
public class DigestTest {public static void main(String[] args) {
//        BasicPasswordEncryptor basicPasswordEncryptor = new BasicPasswordEncryptor();
//        String pwd = basicPasswordEncryptor.encryptPassword("123456aA");
//        System.out.println(pwd);
//        System.out.println(basicPasswordEncryptor.checkPassword("123456aA",pwd));
//
//        Digester digester = new Digester();
//        digester.setAlgorithm("md5");
//        System.out.println(digester.digest("wubo".getBytes()));
//
//        StrongPasswordEncryptor strongPasswordEncryptor = new StrongPasswordEncryptor();
//        String pwd1 = strongPasswordEncryptor.encryptPassword("123456aA");
//        System.out.println(pwd1);
//        System.out.println(strongPasswordEncryptor.checkPassword("123456aA",pwd1));
//
//        ConfigurablePasswordEncryptor configurablePasswordEncryptor = new ConfigurablePasswordEncryptor();
//        configurablePasswordEncryptor.setAlgorithm("SHA-256");
//        configurablePasswordEncryptor.setPlainDigest(true);
//        configurablePasswordEncryptor.setStringOutputType("base64");
//        String pwd2 = configurablePasswordEncryptor.encryptPassword("123456aA");
//        System.out.println(pwd2);
//        System.out.println(configurablePasswordEncryptor.checkPassword("123456aA",pwd2));BasicTextEncryptor basicTextEncryptor = new BasicTextEncryptor();basicTextEncryptor.setPassword("eTbu3NUCWGHh6ASaZ8+Z17WQamx2wDiX");String pwd_user = basicTextEncryptor.encrypt("root");String pwd_pwd = basicTextEncryptor.encrypt("123456aA");System.out.println(pwd_user);System.out.println(pwd_pwd);String user = basicTextEncryptor.decrypt(pwd_user);System.out.println("user::" + user);String pwd6 = basicTextEncryptor.decrypt(pwd_pwd);System.out.println("pwd::" + pwd6);//        StrongTextEncryptor strongTextEncryptor = new StrongTextEncryptor();
//        strongTextEncryptor.setPassword("123456aA");
//        String pwd6 = strongTextEncryptor.encrypt("wubo");
//        System.out.println(pwd6);
//        String pwd7 = strongTextEncryptor.decrypt(pwd6);
//        System.out.println(pwd7);
//
//        AES256TextEncryptor aes256TextEncryptor  = new AES256TextEncryptor();
//        aes256TextEncryptor.setPassword("123456aA");
//        String pwd8 = aes256TextEncryptor.encrypt("wubo");
//        System.out.println(pwd8);
//        String pwd9 = aes256TextEncryptor.decrypt(pwd8);
//        System.out.println(pwd9);
//
//        BasicIntegerNumberEncryptor integerEncryptor = new BasicIntegerNumberEncryptor();
//        integerEncryptor.setPassword("123456aA");
//        BigInteger bigInteger = new BigInteger("1000000");
//        BigInteger myEncryptedNumber = integerEncryptor.encrypt(bigInteger);
//        System.out.println(myEncryptedNumber);
//        BigInteger bigInteger1 =integerEncryptor.decrypt(myEncryptedNumber);
//        System.out.println(bigInteger1);//        StrongIntegerNumberEncryptor integerEncryptor = new StrongIntegerNumberEncryptor();
//        integerEncryptor.setPassword("123456aA");
//        BigInteger myEncryptedNumber = integerEncryptor.encrypt(new BigInteger("200000"));
//        System.out.println(myEncryptedNumber);
//        BigInteger plainNumber = integerEncryptor.decrypt(myEncryptedNumber);
//        System.out.println(plainNumber);//        AES256IntegerNumberEncryptor numberEncryptor = new AES256IntegerNumberEncryptor();
//        numberEncryptor.setPassword("123456aA");
//        BigInteger myEncryptedNumber = numberEncryptor.encrypt(new BigInteger("300000"));
//        System.out.println(myEncryptedNumber);
//        BigInteger plainNumber = numberEncryptor.decrypt(myEncryptedNumber);
//        System.out.println(plainNumber);//        BasicDecimalNumberEncryptor decimalEncryptor = new BasicDecimalNumberEncryptor();
//        decimalEncryptor.setPassword("123456aA");
//        BigDecimal myEncryptedNumber = decimalEncryptor.encrypt(new BigDecimal("400000"));
//        System.out.println(myEncryptedNumber);
//        BigDecimal plainNumber = decimalEncryptor.decrypt(myEncryptedNumber);
//        System.out.println(plainNumber);
//
//
//        AES256DecimalNumberEncryptor numberEncryptor = new AES256DecimalNumberEncryptor();
//        numberEncryptor.setPassword("123456aA");
//        BigDecimal myEncryptedNumber = numberEncryptor.encrypt(new BigDecimal("500000"));
//        BigDecimal plainNumber = numberEncryptor.decrypt(myEncryptedNumber);//        BasicBinaryEncryptor binaryEncryptor = new BasicBinaryEncryptor();
//        binaryEncryptor.setPassword("123456aA");
//        byte[] myEncryptedBinary = binaryEncryptor.encrypt("wubo".getBytes());
//        byte[] plainBinary = binaryEncryptor.decrypt(myEncryptedBinary);
//        String s = new String(plainBinary);//        StrongBinaryEncryptor binaryEncryptor = new StrongBinaryEncryptor();
//        binaryEncryptor.setPassword("123456aA");
//        byte[] myEncryptedBinary = binaryEncryptor.encrypt("wubo".getBytes());
//        byte[]  plainBinary = binaryEncryptor.decrypt(myEncryptedBinary);//        AES256BinaryEncryptor binaryEncryptor = new AES256BinaryEncryptor();
//        binaryEncryptor.setPassword("123456aA");
//        byte[] myEncryptedBytes = binaryEncryptor.encrypt("wubo".getBytes());
//        byte[] plainBytes = binaryEncryptor.decrypt(myEncryptedBytes);//        StandardStringDigester digester1 = new StandardStringDigester();
//        digester1.setAlgorithm("SHA-1");   // optionally set the algorithm
//        digester1.setIterations(50000);  // increase security by performing 50000 hashing iterations
//        String digest1 = digester1.digest("wubo");
//        System.out.println(digest1);//        PooledStringDigester digester = new PooledStringDigester();
//        digester.setPoolSize(4);          // This would be a good value for a 4-core system
//        digester.setAlgorithm("SHA-1");
//        digester.setIterations(50000);
//        String digest = digester.digest("wubo");
//        System.out.println(digest);}
}

使用精简版 Jasypt
使用精简版 Jasypt

从命令行加密：Jasypt CLI 工具
Jasypt 提供了一系列命令行界面 (CLI) 工具，可用于从命令行执行加密、解密和摘要操作。

为了使用这个工具，你应该下载分发 zip 文件（名为 jasypt-$VERSION-dist.zip）并解压它。完成后，您将找到一个 jasypt-$VERSION/bin 目录，其中包含：
一组用于 Windows 执行的 .bat 文件：

encrypt.bat：用于 PBE（基于密码的加密）加密操作。
decrypt.bat：用于 PBE（基于密码的加密）解密操作。
digest.bat：用于消息摘要操作。
listAlgorithms.bat：用于列出 JVM 中可用的摘要和 PBE 加密算法。

一组用于 Linux/UNIX 执行的 .sh 文件：

encrypt.sh：用于 PBE（基于密码的加密）加密操作。
decrypt.sh：用于 PBE（基于密码的加密）解密操作。
digest.sh：用于消息摘要操作。
listAlgorithms.sh：用于列出 JVM 中可用的摘要和 PBE 加密算法。

提示：请注意，在使用 .sh 文件之前，您可能需要使用“chmod u+x *.sh”之类的内容为其添加执行权限。

::这些命令中的大多数都使用以下语法执行：::[command] [argument1]=[value1] [argument2]=[value2] ...::For example:[root@localhost bin]# ./digest.sh input="wubo" algorithm=SHA1----ENVIRONMENT-----------------Runtime: Oracle Corporation Java HotSpot(TM) 64-Bit Server VM 25.65-b01 ----ARGUMENTS-------------------algorithm: SHA1
input: wubo----OUTPUT----------------------85NTwS8KLwlTz6G5aA2NcIQt8n8sN7Vr3gxwTQ==

Extended Classpath：所有这些命令都遵循 JASYPT_CLASSPATH 环境变量的存在，其中包含用于执行加密/解密/摘要命令的扩展类路径定义。如果用户想要配置他/她自己的安全提供程序或盐生成器实现，或者如果用户使用 Java 1.5 或更早版本并且需要将 icu4j 的 jars 添加到类路径（这些不再包含在 jasypt 的分发中），则此功能非常有用）。

Verbosity：这些命令中的大多数都接受一个详细参数（可以设置为 true（默认）或 false），它让用户从解释性输出切换到非常简化的输出，只显示操作的结果（对于脚本编写特别有用））。

编码：

Encryption from the command line (“encrypt” command)

[root@localhost bin]# ./encrypt.sh USAGE: encrypt.sh [ARGUMENTS]* Arguments must apply to format:"arg1=value1 arg2=value2 arg3=value3 ..."* Required arguments:inputpassword* Optional arguments:verbosealgorithmkeyObtentionIterationssaltGeneratorClassNameproviderNameproviderClassNamestringOutputTypeivGeneratorClassName[root@localhost bin]# ./encrypt.sh input="wubo" password=123456aA----ENVIRONMENT-----------------Runtime: Oracle Corporation Java HotSpot(TM) 64-Bit Server VM 25.65-b01 ----ARGUMENTS-------------------input: wubo
password: 123456aA----OUTPUT----------------------FJw3OSL/h9uy24zaxgfigw==

解码：

Decryption from the command line (“decrypt” command)

[root@localhost bin]# ./decrypt.sh USAGE: decrypt.sh [ARGUMENTS]* Arguments must apply to format:"arg1=value1 arg2=value2 arg3=value3 ..."* Required arguments:inputpassword* Optional arguments:verbosealgorithmkeyObtentionIterationssaltGeneratorClassNameproviderNameproviderClassNamestringOutputTypeivGeneratorClassName[root@localhost bin]# ./decrypt.sh input="FJw3OSL/h9uy24zaxgfigw==" password=123456aA----ENVIRONMENT-----------------Runtime: Oracle Corporation Java HotSpot(TM) 64-Bit Server VM 25.65-b01 ----ARGUMENTS-------------------input: FJw3OSL/h9uy24zaxgfigw==
password: 123456aA----OUTPUT----------------------wubo

摘要：

Digest from the command line (“digest” command)

摘要在命令行中使用digest.bat/digest.sh 命令执行，其用法和参数化与org.jasypt.digest.StandardStringDigester 的用法和参数化完全对应。执行 CLI 命令时假定此摘要器类的所有默认值。要了解更多信息，请参阅 JavaDoc。

[root@localhost bin]# ./digest.shUSAGE: digest.sh [ARGUMENTS]* Arguments must apply to format:"arg1=value1 arg2=value2 arg3=value3 ..."* Required arguments:input* Optional arguments:verbosealgorithmiterationssaltSizeBytessaltGeneratorClassNameproviderNameproviderClassNameinvertPositionOfSaltInMessageBeforeDigestinginvertPositionOfPlainSaltInEncryptionResultsuseLenientSaltSizeCheckunicodeNormalizationIgnoredstringOutputTypeprefixsuffix[root@localhost bin]# ./digest.sh input="wubo"----ENVIRONMENT-----------------Runtime: Oracle Corporation Java HotSpot(TM) 64-Bit Server VM 25.65-b01 ----ARGUMENTS-------------------input: wubo----OUTPUT----------------------WZNtltOuQArEJaagQx63mWlJscs6fY7y[root@localhost bin]# ./digest.sh input="wubo"----ENVIRONMENT-----------------Runtime: Oracle Corporation Java HotSpot(TM) 64-Bit Server VM 25.65-b01 ----ARGUMENTS-------------------input: wubo----OUTPUT----------------------xq6BwOpIjuG/5ehGrEgqoSOrPfrDAqL1

用于列出 JVM 中可用的摘要和 PBE 加密算法。

Listing algorithms

listAlgorithms[.sh|.bat] 脚本将列出 Java VM 中可用的摘要和 PBE（基于密码的加密）算法。

它不接收任何参数，其用法非常简单：

[root@localhost bin]# 
[root@localhost bin]# ./listAlgorithms.sh DIGEST ALGORITHMS:   [MD2, MD5, SHA, SHA-224, SHA-256, SHA-384, SHA-512]PBE ALGORITHMS:      [PBEWITHHMACSHA1ANDAES_128, PBEWITHHMACSHA1ANDAES_256, PBEWITHHMACSHA224ANDAES_128, PBEWITHHMACSHA224ANDAES_256, PBEWITHHMACSHA256ANDAES_128, PBEWITHHMACSHA256ANDAES_256, PBEWITHHMACSHA384ANDAES_128, PBEWITHHMACSHA384ANDAES_256, PBEWITHHMACSHA512ANDAES_128, PBEWITHHMACSHA512ANDAES_256, PBEWITHMD5ANDDES, PBEWITHMD5ANDTRIPLEDES, PBEWITHSHA1ANDDESEDE, PBEWITHSHA1ANDRC2_128, PBEWITHSHA1ANDRC2_40, PBEWITHSHA1ANDRC4_128, PBEWITHSHA1ANDRC4_40]

提示：请注意，此命令不会列出来自非默认 JCE 提供程序（如 Bouncy Castle）的任何参数，除非您已通过将提供程序的 jar 文件复制到我们的 JRE 安装的扩展目录 ($JRE_HOME/lib/ext) 在 JVM 安装中注册了此类提供程序 )，然后在 $JRE_HOME/lib/security 中的 java.security 文件中的提供程序列表末尾附加 Provider 类的名称。有关更多详细信息，请参阅使用非默认提供程序或 Jasypt + Bouncy Castle。

高级用法

加密器和摘要器的高级配置
加密器和摘要器的高级配置

Web PBE Configuration
在 Web 应用程序中，Jasypt 允许开发人员避免将 PBE 加密器的加密密码存储在 Web 应用程序内的文件中，而是在每次部署时通过 Web 界面向应用程序指定这些密码。

这是通过以下基础设施实现的：

特殊的 *Config 类：org.jasypt.encryption.pbe.WebPBEConfig 和 org.jasypt.encryption.pbe.WebStringPBEConfig，当分配给加密器时，“标记”该加密器有资格通过网络接收其密码。
一个上下文侦听器 org.jasypt.web.pbeconfig.WebPBEInitializationContextListener 它将让我们创建我们的加密器，设置它们的 WebPBEConfig 配置并将它们注册到我们应用程序的某个地方。如果我们使用 Spring Framework，则不需要此上下文侦听器。
过滤器 org.jasypt.web.pbeconfig.WebPBEConfigFilter，它将避免任何用户访问 Web 应用程序，直到管理员设置了加密密码。
一个 servlet，org.jasypt.web.pbeconfig.WebPBEConfigServlet，它将向授权用户显示一个表单，他/她可以使用该表单为所有带有 WebPBEConfig 的加密器设置加密密码。

WebPBEConfig

对于要从网络分配密码的加密器，只需为其分配一个 WebPBEConfig 对象，该对象必须使用唯一名称和验证字进行初始化。该名称将标识配置对象（以及加密器），验证字将确保只有授权人员（例如，应用程序部署者）才能设置密码。

WebPBEInitializationContextListener

这是一个 ContextListener，它将 org.jasypt.web.pbeconfig.WebPBEInitializer 实现类名称作为参数 (context-param) 并调用其 initializeWebPBEConfigs() 方法以允许 web 应用程序创建其 PBE 加密器并声明其关联的 WebPBEConfig 对象。

一个示例 WebPBEInitializer 实现：

package com.cn.jettech;public class MyWebPBEInitializer implements WebPBEInitializer {public void initializeWebPBEConfigs() {StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor();encryptor.setAlgorithm("PBEWithMD5AndDES");WebPBEConfig webConfig = new WebPBEConfig();webConfig.setValidationWord("123456aA");webConfig.setName("wubo");encryptor.setConfig(webConfig);// Get some user-defined singleton or similar, and register// the encryptor with it so that it can be accessed from the// rest of the application.}}

一个示例 web.xml 片段，注册上下文侦听器：

<context-param><param-name>webPBEInitializerClassName</param-name><param-value>myapp.MyWebPBEInitializer</param-value>
</context-param><listener><listener-class>org.jasypt.web.pbeconfig.WebPBEInitializationContextListener</listener-class>
</listener>

提示：重要提示：如果 web 应用程序使用 Spring 框架，WebPBEConfig 对象在 Spring 上下文中被声明为 bean，并且这个 Spring 上下文在应用程序部署时初始化（使用 Spring 的 ContextLoaderListener），则不需要使用这个上下文侦听器。

WebPBEConfigFilter

此过滤器旨在避免在管理员设置加密密码之前访问 Web 应用程序。它将查询网络 PBE 配置系统以了解是否已设置密码，如果没有，它将向用户显示一个简单的访问禁止页面。

示例 web.xml 片段（应用于 Struts servlet）：

<filter><filter-name>webPBEConfigFilter</filter-name><filter-class>org.jasypt.web.pbeconfig.WebPBEConfigFilter</filter-class>
</filter><filter-mapping><filter-name>webPBEConfigFilter</filter-name><servlet-name>strutsActionServlet</servlet-name>
</filter-mapping>

WebPBEConfigServlet

这个 servlet 的 URL 应该在部署时由 webapp 管理员调用，用于设置所有先前分配了 WebPBEConfig 配置对象的 PBE 加密器的密码。

如果尚未完成 Web PBE 配置，它将向用户显示一个表单，其中包含每个加密器的两个输入：验证字和密码（重新输入）。

验证词必须通过其 setValidationWord(…) 方法输入到 WebPBEConfig 对象上设置的值中。这将确保只有授权人员才能设置加密密码。
密码（重新键入）必须输入到希望作为每个特定加密器的加密密码的值中。

一个示例 web.xml 片段：

<servlet><servlet-name>webPBEConfigServlet</servlet-name><servlet-class>org.jasypt.web.pbeconfig.WebPBEConfigServlet</servlet-class><load-on-startup>1</load-on-startup>
</servlet><servlet-mapping><servlet-name>webPBEConfigServlet</servlet-name><url-pattern>/webPBEConfig.do</url-pattern>
</servlet-mapping>

如果此 servlet 的上下文设置为记录器，它将为成功和失败的密码设置尝试输出消息，包括日期、时间和原始 IP 地址。

将 Jasypt 与非默认 JCE 提供程序一起使用
将 Jasypt 与非默认 JCE 提供程序一起使用

按日期类型
Encrypting passwords
Encrypting passwords

Encrypting texts
Encrypting texts

Encrypting numbers
Encrypting numbers

Encrypting binaries
Encrypting binaries

Encrypting application configuration files
Jasypt 以三种不同的方式提供对加密应用程序配置的支持：

.properties files: Jasypt 提供了 org.jasypt.properties.EncryptableProperties 类，用于加载、管理和透明解密 .properties 文件中的加密值，允许在同一文件中混合加密和未加密的值。
Spring集成的.properties文件透明解密：Jasypt可以集成到Spring Framework（2.x和3.x）的配置系统中，透明地解密Spring应用使用的.properties文件。了解更多：Spring 2.x、Spring 3.0、Spring 3.1、Spring 4.0。
Hibernate 的 hibernate.cfg.xml 文件中数据源参数的加密：Jasypt 为 Hibernate 提供了两个连接提供程序类（基于 DriverManager 和 C3P0），它们允许基本数据源参数（驱动程序、url、用户名和密码）以加密的形式写入 hibernate.cfg.xml 文件中的方式。了解更多。

通过这种方式，jasypt 支持在多个场景（基于 Hibernate、Spring、两者或两者都不是的应用程序）中对敏感配置数据进行加密。

作为一般规则，jasypt 期望加密的配置参数出现在“ENC(…)”周围。您可以使用 CLI 工具计算此值。

在这里你可能会想：“等等…我可以加密我的配置文件中的值，好吧，但是…我仍然需要一个密码（加密密码）来解密它们！我在哪里可以安全地存储它？”。没错，您仍然需要一个密码，但这次是加密密码，在 jasypt 控制下，因此可以通过许多其他更安全的方式进行配置（特别推荐环境变量或 Web PBE 配置…）。

EncryptableProperties

通过使用 org.jasypt.properties.EncryptableProperties 对象，应用程序将能够正确读取和使用 .properties 文件，如下所示：

datasource.driver=com.mysql.jdbc.Driver
datasource.url=jdbc:mysql://localhost/reportsdb
datasource.username=reportsUser
datasource.password=ENC(G6N718UuyPE5bHyWKyuLQSm02auQPUtm)

请注意，数据库密码已加密（实际上，任何其他属性也可以加密，无论是否与数据库配置相关）。

我们如何读取这个值？像这样：

/** First, create (or ask some other component for) the adequate encryptor for* decrypting the values in our .properties file.*/StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor();encryptor.setPassword("jasypt"); // could be got from web, env variable...encryptor.setAlgorithm("PBEWithHMACSHA512AndAES_256");encryptor.setIvGenerator(new RandomIvGenerator());/** Create our EncryptableProperties object and load it the usual way.*/Properties props = new EncryptableProperties(encryptor);props.load(new FileInputStream("/path/to/my/configuration.properties"));/** To get a non-encrypted value, we just get it with getProperty...*/String datasourceUsername = props.getProperty("datasource.username");/** ...and to get an encrypted value, we do exactly the same. Decryption will* be transparently performed behind the scenes.*/ String datasourcePassword = props.getProperty("datasource.password");// From now on, datasourcePassword equals "reports_passwd"...

为了解密加密值，我们只需要使用 getProperty 访问它，就像任何其他非加密值一样。

EncryptableProperties 对象可以接收 org.jasypt.encryption.StringEncryptor 实现或 org.jasypt.util.TextEncryptor 对象作为构造函数参数。