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博客

你可能感兴趣的:(开发语言,java)