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 MANDATORY

String 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:

      input
      password

  * Optional arguments:

      verbose
      algorithm
      keyObtentionIterations
      saltGeneratorClassName
      providerName
      providerClassName
      stringOutputType
      ivGeneratorClassName


[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:

      input
      password

  * Optional arguments:

      verbose
      algorithm
      keyObtentionIterations
      saltGeneratorClassName
      providerName
      providerClassName
      stringOutputType
      ivGeneratorClassName


[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.sh

USAGE: digest.sh [ARGUMENTS]

  * Arguments must apply to format:

      "arg1=value1 arg2=value2 arg3=value3 ..."

  * Required arguments:

      input

  * Optional arguments:

      verbose
      algorithm
      iterations
      saltSizeBytes
      saltGeneratorClassName
      providerName
      providerClassName
      invertPositionOfSaltInMessageBeforeDigesting
      invertPositionOfPlainSaltInEncryptionResults
      useLenientSaltSizeCheck
      unicodeNormalizationIgnored
      stringOutputType
      prefix
      suffix

[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 片段，注册上下文侦听器：

  webPBEInitializerClassName
  myapp.MyWebPBEInitializer



  
    org.jasypt.web.pbeconfig.WebPBEInitializationContextListener
  

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

WebPBEConfigFilter

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

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

  webPBEConfigFilter
  org.jasypt.web.pbeconfig.WebPBEConfigFilter



  webPBEConfigFilter
  strutsActionServlet
   

 WebPBEConfigServlet

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

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

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

一个示例 web.xml 片段：
 

  webPBEConfigServlet
  
    org.jasypt.web.pbeconfig.WebPBEConfigServlet
  
  1



  webPBEConfigServlet
  /webPBEConfig.do

如果此 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 对象作为构造函数参数。

Building

Jasypt + Apache Maven

文章

如何加密用户密码

参考文献

Jasypt 官方文档
JCE
Jasypt JavaDoc API
Jasypt 经常被问到的问题
Jasypt Spring Boot 参考手册

小白入门之 Jasypt 加密和解密_高建伟-joe的博客-CSDN博客