Java 加密扩展（JCE）框架之 Cipher 加密与解密

末蓝、 2023-03-14 08:27 1阅读 0赞

**目录**

常用加密算法对比

Cipher 密码加密概述

Cipher 常量与常用方法

Hello World 快速入门

RSA 非对称加密详解

JCE 无限强度权限策略文件

--------------------

# 常用加密算法对比 #

<table>  
 <strong>常用加密算法对比</strong>  
 <thead> 
  <tr> 
   <th style="width:89px;">加密算法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:89px;">SHA</td> 
   <td>&nbsp;安全散列算法。单向加密、数据不可逆(即不可恢复)。长度是固定的。</td> 
  </tr> 
  <tr> 
   <td style="width:89px;"><a href="https://blog.csdn.net/wangmx1993328/article/details/83892385" rel="nofollow">BASE64</a></td> 
   <td> <p>1、BASE64 有自己的编码表，可编码，也可解码；<span style="color:#f33b45;">解码后能得到源内容。</span></p> <p>2、BASE64 编码的长度是不固定的，随着源字符串的增加而增加。</p> <p>3、在某些不方便使用中文的地方，可以通过 BASE64 编码成可见字符，需要中文时再解码回来即可，比如 url 地址，或者 Cookie.</p> </td> 
  </tr> 
  <tr> 
   <td style="width:89px;"><a href="https://blog.csdn.net/wangmx1993328/article/details/83892385" rel="nofollow">MD5</a></td> 
   <td> <p><span style="color:#f33b45;">信息摘要是安全的单向哈希函数，对大小的信息输出固定长度的哈希值，单向加密、数据不可逆。</span></p> <p>摘要好比指纹，每个人都是唯一的，相同的源数据，摘要也一样，不同的数据，摘要则不一样。摘要只是源数据的局部，所以想要解码回去恢复整个源数据是不行的，因为是不完整的。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:89px;"> <p>DES</p> </td> 
   <td> <p>Data Encrytion Standard（数据加密标准) , 特点：1.<span style="color:#f33b45;"> 对称加密&nbsp; 2. 同一个 SECRET_KEY（密钥）</span></p> </td> 
  </tr> 
  <tr> 
   <td style="width:89px;"> <p>AES</p> </td> 
   <td> <p>Advanced&nbsp;Encrytion Standard（高级加密标准），特点：1. <span style="color:#f33b45;">对称加密</span>&nbsp; 2. 一个 SECRET_KEY（密钥）扩展成多个子 SK，轮加密</p> </td> 
  </tr> 
  <tr> 
   <td style="width:89px;">RSA</td> 
   <td> <p>1. <span style="color:#f33b45;">非对称加密</span>，即：PK（PUBLIC_KEY 公钥） 与 SK（ SECRET_KEY 密钥） 不是同一个</p> <p>2. PK 加密时，必须用 SK 解密、反之&nbsp; SK 加密时，必须用 PK 解密，</p> <p>3. PK 决定 SK，但是 PK 很难算出 SK（数学原理：两个大质数相乘，积很难因式分解）</p> <p>4. 速度慢，适合对少量数据加密</p> </td> 
  </tr> 
 </tbody> 
</table>

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdteDE5OTMzMjg_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdteDE5OTMzMjg_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdteDE5OTMzMjg_size_16_color_FFFFFF_t_70 2][]

# Cipher 密码加密概述 #

1、javax.crypto.Cipher 类提供加密和解密的功能，它构成了 Java Cryptography Extension (JCE) —— Java 加密扩展框架的核心。这些都是 Java JDK 原生的 API，不是第三方的。

2、Cipher 的 getInstance(String transformation) 方法可以获取实例，参数 transformation 表示转换名称，包*括：加密算法/反馈模式/填充方案*。加密算法是必选项，反馈模式与填充方案可以不写使用默认值。如：

> Cipher cipher = Cipher.getInstance("AES");  
> Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");

3、Cipher  支持 4 种加密算法：AES、DES、DESede、RSA。

<table>  
 <strong>Cipher.getInstance 实例化时转换名称参数可选值如下</strong>  
 <tbody> 
  <tr> 
   <td style="width:446px;">AES/CBC/NoPadding<br> AES/CBC/PKCS5Padding<br> AES/ECB/NoPadding<br> AES/ECB/PKCS5Padding</td> 
   <td style="width:446px;"> <p>1、<span style="color:#f33b45;">加密算法有 4 种：AES、DES、DESede、RSA</span></p> <p>2、反馈模式有两种：CBC(有向量模式)、ECB(无向量模式)</p> <p>3、填充方案有 5 种：NoPadding 、PKCS5Padding、PKCS1Padding 、OAEPWithSHA-1AndMGF1Padding、OAEPWithSHA-256AndMGF1Padding</p> <p>&nbsp;</p> <p>4、NoPadding 填充方案: 加密内容不足8位时用0补足8位, Cipher类不提供补位功能，需自己实现代码给加密内容添加0, 如{65,65,65,0,0,0,0,0}</p> <p>5、PKCS5Padding 填充方案: 加密内容不足8位用余位数补足8位, 如{65,65,65,5,5,5,5,5}或{97,97,97,97,97,97,2,2}.</p> </td> 
  </tr> 
  <tr> 
   <td style="width:446px;"> <p>DES/CBC/NoPadding<br> DES/CBC/PKCS5Padding<br> DES/ECB/NoPadding<br> DES/ECB/PKCS5Padding</p> </td> 
  </tr> 
  <tr> 
   <td style="width:446px;"> <p>DESede/CBC/NoPadding<br> DESede/CBC/PKCS5Padding<br> DESede/ECB/NoPadding<br> DESede/ECB/PKCS5Padding</p> </td> 
  </tr> 
  <tr> 
   <td style="width:446px;">RSA/ECB/PKCS1Padding<br> RSA/ECB/OAEPWithSHA-1AndMGF1Padding<br> RSA/ECB/OAEPWithSHA-256AndMGF1Padding</td> 
  </tr> 
 </tbody> 
</table>

# **Cipher 常量与常用方法** #

<table>  
 <strong>javax.crypto.Cipher 常量字段</strong>  
 <thead> 
  <tr> 
   <th><strong>字段类型</strong></th> 
   <th><strong>字段名称</strong></th> 
   <th><strong>字段值</strong></th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>static int</code></td> 
   <td><code><a rel="nofollow">ENCRYPT_MODE</a></code></td> 
   <td>1</td> 
   <td>常数用于将密码初始化为<span style="color:#f33b45;">加密</span>模式。</td> 
  </tr> 
  <tr> 
   <td><code>static int</code></td> 
   <td><code><a rel="nofollow">DECRYPT_MODE</a></code></td> 
   <td>2</td> 
   <td>常数用于将密码初始化为<span style="color:#f33b45;">解密</span>模式。</td> 
  </tr> 
  <tr> 
   <td><code>static int</code></td> 
   <td><code><a rel="nofollow">WRAP_MODE</a></code></td> 
   <td>3</td> 
   <td>常数用于将密码初始化为密钥<span style="color:#f33b45;">包装</span>模式</td> 
  </tr> 
  <tr> 
   <td><code>static int</code></td> 
   <td><code><a rel="nofollow">UNWRAP_MODE</a></code></td> 
   <td>4</td> 
   <td>常数用于将密码初始化为密钥<span style="color:#f33b45;">解包</span>模式。</td> 
  </tr> 
  <tr> 
   <td><code>static int</code></td> 
   <td><code><a rel="nofollow">PUBLIC_KEY</a></code></td> 
   <td>1</td> 
   <td>用于指示待解除密钥的常数是“<span style="color:#e579b6;">公钥</span>”。</td> 
  </tr> 
  <tr> 
   <td><code>static int</code></td> 
   <td><code><a rel="nofollow">PRIVATE_KEY</a></code></td> 
   <td>2</td> 
   <td>用于指示要解除密钥的常数是“<span style="color:#e579b6;">私钥</span>”。</td> 
  </tr> 
  <tr> 
   <td><code>static int</code></td> 
   <td><code><a rel="nofollow">SECRET_KEY</a></code></td> 
   <td>3</td> 
   <td>用于指示要解开的密钥的常数是“<span style="color:#e579b6;">密钥</span>”。</td> 
  </tr> 
 </tbody> 
</table>

<table>  
 <strong>javax.crypto.Cipher 常用 API</strong>  
 <thead> 
  <tr> 
   <th style="width:402px;">方法</th> 
   <th style="width:499px;">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:402px;">Cipher getInstance(String transformation)<br> Cipher getInstance(String transformation,Provider provider)<br> Cipher getInstance(String transformation,String provider)</td> 
   <td style="width:499px;"> <p>实例化 Cipher 对象。</p> <p>1、transformation 转换名称，格式：<span style="color:#f33b45;"><em>加密算法/反馈模式/填充方案</em></span></p> <p><span style="color:#f33b45;"><em>2、</em></span>provider 供应商</p> </td> 
  </tr> 
  <tr> 
   <td style="width:402px;">init(int opmode,Key key)<br> init(int opmode,Key key,AlgorithmParameters params)<br> init(int opmode,Key key,AlgorithmParameterSpec params)<br> init(int opmode,Key key,AlgorithmParameters params,SecureRandom random)<br> init(int opmode,Key key,AlgorithmParameterSpec params,SecureRandom random)<br> init(int var1, Key var2, SecureRandom var3)<br> init(int opmode,Certificate certificate)<br> init(int opmode,Certificate certificate,SecureRandom random)</td> 
   <td style="width:499px;"> <p>初始化 Cipher</p> <p>1、opmode 对应上面常量：解密、加密、解包、模式、包装。</p> <p>2、key ：密匙，可以使用 SecretKeySpec、KeyGenerator 和 KeyPairGenerator 创建。其中<br> SecretKeySpec 和 KeyGenerator 支持 AES，DES，DESede 三种加密算法创建密匙，KeyPairGenerator支持 RSA 加密算法创建密匙。<br> 3、<span style="color:#f33b45;">params ：使用 CBC 模式时必须传入该参数.</span></p> </td> 
  </tr> 
  <tr> 
   <td style="width:402px;">update(byte[] input)<br> update(byte[] input,int off,int len)</td> 
   <td style="width:499px;">输入给定的字节数组完成更新</td> 
  </tr> 
  <tr> 
   <td style="width:402px;"> <p>update(byte[] input,int off,int len,byte[] output)<br> update(byte[] input,int off,int len,byte[] output,int outputoffset)</p> </td> 
   <td style="width:499px;">将更新结果输出到参数中</td> 
  </tr> 
  <tr> 
   <td style="width:402px;">update(ByteBuffer input,ByteBuffer output)</td> 
   <td style="width:499px;">使用缓冲的方式更新</td> 
  </tr> 
  <tr> 
   <td style="width:402px;"> <p>byte[] wrap(Key key)</p> </td> 
   <td style="width:499px;">包装密钥</td> 
  </tr> 
  <tr> 
   <td style="width:402px;">Key unwrap(byte[] wrappedKey, String wrappedKeyAlgorithm, int wrappedKeyType)</td> 
   <td style="width:499px;"> <p>解包装</p> <p>wrappedKeyType 对应常量 PRIVATE_KEY、PUBLIC_KEY、SECRET_KEY</p> </td> 
  </tr> 
  <tr> 
   <td style="width:402px;">&nbsp;byte[] getIV()</td> 
   <td style="width:499px;">返回缓冲区中的初始化向量</td> 
  </tr> 
  <tr> 
   <td style="width:402px;"> <p>int getMaxAllowedKeyLength(String transformation)</p> </td> 
   <td style="width:499px;">返回指定转换的最大密钥长度</td> 
  </tr> 
  <tr> 
   <td style="width:402px;"> <p>int getBlockSize()</p> </td> 
   <td style="width:499px;"> <p>返回块大小（以字节为单位），如果底层算法不是块密码，则为 0.</p> <p>分组加密中，每一组都有固定的长度，称为块.</p> </td> 
  </tr> 
  <tr> 
   <td style="width:402px;">int getOutputSize(int inputLen)</td> 
   <td style="width:499px;">获取输出缓冲区字节长度</td> 
  </tr> 
  <tr> 
   <td style="width:402px;">&nbsp;String getAlgorithm()</td> 
   <td style="width:499px;">返回此 Cipher 对象的算法名称。</td> 
  </tr> 
  <tr> 
   <td style="width:402px;">byte[] doFinal()</td> 
   <td style="width:499px;">完成多部分加密或解密操作，这取决于该密码如何初始化。<br> 返回的 byte 数组，如果直接使用 new String(b) 封装成字符串，则会出现乱码。</td> 
  </tr> 
 </tbody> 
</table>

# Hello World 快速入门 #

源码中都有详细说明，这里重点强调几点；

1、使用 CBC 有向量模式时，cipher.init 必须传入 \{@link AlgorithmParameterSpec\}-算法参数规范。如果使用的是 ECB-无向量模式，那么 cipher.init 则加解密都不需要传  \{@link AlgorithmParameterSpec\} 参数.

2、生成密钥 SecretKey 与 算法参数规范 AlgorithmParameterSpec 的 key ，AES加密算法时必须是 16 个字节，DES 时必须是 8 字节.

3、加/解密都是调用 Cipher.doFinal(byte\[\] content) 方法，具体取决于 cipher.init 时 使用的是 Cipher.ENCRYPT\_MODE 加密模式，还是 Cipher.DECRYPT\_MODE 解密模式.

4、下面演示的是 AES 加密算法，DES 加密算法使用也是同理，区别在于参数：secret\_key、vector\_key : AES 时必须是 16 个字节，DES 时必须是 8 字节.

import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    import java.security.spec.AlgorithmParameterSpec;
    /**
     * Cipher 密码工具类
     *
     * @author wangmaoxiong
     * @version 1.0
     * @date 2020/5/17 13:09
     */
    public class CipherUtils {
        /**
         * AES/CBC/PKCS5Padding 加密
         *
         * @param content    :待加密的内容.
         * @param secret_key :用于生成密钥的 key，自定义即可，加密与解密必须使用同一个，如果不一致，则抛出异常
         * @param vector_key 用于生成算法参数规范的 key，自定义即可，加密与解密必须使用同一个，如果不一致，解密的内容可能会造成与源内容不一致.
         *                   <p>
         *                   1、secret_key、vector_key: AES 时必须是 16 个字节，DES 时必须是 8 字节.
         *                   2、secret_key、vector_key 值不建议使用中文，如果是中文，注意一个汉字是3个字节。
         *                   </p>
         * @return 返回 Cipher 加密后的数据，对加密后的字节数组用 Base64 进行编码转成了可视字符串，如 7giH2bqIMH3kDMIg8gq0nY
         * @throws Exception
         */
        public static String encrypt(String content, String secret_key, String vector_key) throws Exception {
            //实例化 Cipher 对象。使用：AES-高级加密标准算法、CBC-有向量模式、PKCS5Padding-填充方案:（加密内容不足8位时用余位数补足8位）
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            //使用 SecretKeySpec(byte[] key, String algorithm) 创建密钥. 算法要与 Cipher.getInstance 保持一致.
            SecretKey secretKey = new SecretKeySpec(secret_key.getBytes(), "AES");
            /**
             * init(int opMode,Key key,AlgorithmParameterSpec params)：初始化 Cipher，
             * 1、Cipher.ENCRYPT_MODE 表示加密模式
             * 2、key 表示加密密钥
             * 3、params 表示算法参数规范，使用 CBC 有向量模式时，必须传入,如果是 ECB-无向量模式,那么可以不传
             * 4、所有参数规范都必须实现 {@link AlgorithmParameterSpec} 接口.
             */
            IvParameterSpec parameterSpec = new IvParameterSpec(vector_key.getBytes());
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, parameterSpec);
            /**
             * byte[] doFinal(byte[] content)：对 content 完成加密操作，如果 cipher.init 初始化时使用的解密模式，则此时是解密操作.
             * 返回的是加密后的字节数组，如果直接 new String(byte[] bytes) 是会乱码的，可以借助 BASE64 转为可视字符串，或者转成 16 进制字符
             */
            byte[] encrypted = cipher.doFinal(content.getBytes());
            //BASE64Encoder.encode：BASE64 对字节数组内容进行编码，转为可视字符串，这样方便存储和转换.
            String base64Encode = new BASE64Encoder().encode(encrypted);
            return base64Encode;
        }
    
        /**
         * AES/CBC/PKCS5Padding 解密
         *
         * @param base64Encode :待解密的内容，因为加密时使用了 Base64 进行了编码，所以这里传入的也是 Base64 编码后的可视化字符串
         * @param secret_key   :用于生成密钥的 key，自定义即可，加密与解密必须使用同一个，如果不一致，则抛出异常
         * @param vector_key   用于生成算法参数规范的 key，自定义即可，加密与解密必须使用同一个，如果不一致，解密的内容可能会造成与源内容不一致.
         *                     <p>
         *                     1、secret_key、vector_key：AES 时必须是 16 个字节，DES 时必须是 8 字节.
         *                     2、secret_key、vector_key 值不建议使用中文，如果是中文，注意一个汉字是3个字节。
         *                     </p>
         * @return
         * @throws Exception
         */
        public static String decrypt(String base64Encode, String secret_key, String vector_key) throws Exception {
            //实例化 Cipher 对象。加密算法/反馈模式/填充方案，解密与加密需要保持一致.
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            //创建密钥。算法也要与实例化 Cipher 一致.
            SecretKey secretKey = new SecretKeySpec(secret_key.getBytes(), "AES");
            //有向量模式(CBC)需要传入 AlgorithmParameterSpec 算法参数规范参数.
            IvParameterSpec parameterSpec = new IvParameterSpec(vector_key.getBytes());
            //初始化 cipher。使用解密模式.
            cipher.init(Cipher.DECRYPT_MODE, secretKey, parameterSpec);
            //将 Base64 编码的内容解码成字节数组(因为加密的时候，对密文使用了 Base64编码，所以这里需要先解码)
            byte[] content = new BASE64Decoder().decodeBuffer(base64Encode);
            //执行解密操作。返回解密后的字节数组，此时可以使用 String(byte bytes[]) 转成源字符串.
            byte[] decrypted = cipher.doFinal(content);
            return new String(decrypted);
        }
    
        public static void main(String[] args) throws Exception {
            String content = "红网时刻5月17日讯（记者 汪衡 通讯员 颜雨彬 汪丹）“场面壮观，气势磅礴，简直就是一部抗洪抢险水域救援大片！”抗洪抢险水域救援实战训练刚一结束，现场围观的群众纷纷发出了感叹。5月16日，湖南省消防救援总队在长沙市望城区千龙湖举办舟艇操作员培训，长沙、株洲、湘潭等40余名消防指战员参加，开展了一场抗洪抢险水域救援实战训练。" +
                    "夏以来，随着湖南防汛救援任务的日趋繁重。为提高全省消防救援队伍水域救援能力，充分发挥应急救援“主力军”和“国家队”的作用，湖南省消防救援总队组织了这次为期35天的培训。依托长沙、岳阳、常德3支省级水域救援队设立了3个培训点，全省653名学员分17期参加培训。此次培训采用课堂授课、实地讲解、实操训练等多种形式，培训内容贴近实战，主要包括OSO驾驶、快速出入库、翻船自救、故障排除、200米游泳、受限控艇等项目。省消防救援总队相关负责人介绍，为了加快适应“全灾种、大应急”的职能定位，全面做好“防大汛、抢大险、救大灾”的准备工作，湖南消防救援队伍未雨绸缪，组建了1支省级抗洪抢险救援队、13支市级抗洪抢险救援队，有水域救援任务的消防救援站均成立了1支站级抗洪抢险救援队，总人数2300余人。此外，省消防救援总队还把重型工程机械救援大队、航空救援大队作为抢险救援机动力量纳入调度体系，充分发挥消防救援队伍装备技术优势，最大限度地挽救生命，减少灾害损失。";
            //生成密钥的 key 与 生成算法参数规范的 key 加解密必须一致，它就像是一把钥匙或者口令，不能忘记.
            //AES 加密算法时必须是 16 个字节，DES 时必须是 8 字节.
            String slatKey = "wYDJty8o8HE6YjJS";
            String vectorKey = "SC35fdGrQozSMT5a";
            String encrypt = encrypt(content, slatKey, vectorKey);
            System.out.println("源内容：\n" + content);
            System.out.println("加密后：\n" + encrypt);
            System.out.println("解密后：\n" + decrypt(encrypt, slatKey, vectorKey));
        }
    }

![20200518144147131.gif][]

> 在线源码：[src/main/java/com/wmx/thymeleafapp/utils/CipherUtils.java][src_main_java_com_wmx_thymeleafapp_utils_CipherUtils.java]

# RSA 非对称加密详解 #

1. 非对称加密，需要使用 PK（PUBLIC\_KEY 公钥） 与 SK（ SECRET\_KEY 密钥），PK 加密时，必须用 SK 解密、反之  SK 加密时，必须用 PK 解密。

2. 安全性最高，但是速度慢，适合对少量数据加密。

3、源码中有详细解释：

import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    import javax.crypto.Cipher;
    import java.security.*;
    import java.security.spec.EncodedKeySpec;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    /**
     * RSA 非对称加密工具类。
     * 1、公钥（PUBLIC_KEY）、私钥：PRIVATE_KEY 必须分开使用，比如公钥加密时，必须是私钥解密，反之私钥加密时，必须是公钥解密
     *
     * @author wangmaoxiong
     * @version 1.0
     * @date 2020/5/18 15:41
     */
    public class CipherRsaUtils {
    
        /**
         * CIPHER_TRANSFORMS : cipher 实例化时的 加密算法/反馈模式/填充方案。ECB 表示无向量模式
         * ALGORITHM: 创建密钥时使用的算法
         * KEY_PAIR_LENGTH: 秘钥对长度。数值越大，能加密的内容就越大。
         * <p>
         * 如 KEY_PAIR_LENGTH 为 1024 时加密数据的长度不能超过 117 字节
         * 如 KEY_PAIR_LENGTH 为 2048 时加密数据的长度不能超过 245 字节
         * 依次类推
         * </p>
         */
        private static final String CIPHER_TRANSFORMS = "RSA/ECB/PKCS1Padding";
        private static final int KEY_PAIR_LENGTH = 1024;
    
        /**
         * 生成 RSA 密钥对：公钥（PUBLIC_KEY）、私钥：PRIVATE_KEY
         *
         * @param secureRandomSeed ：SecureRandom 随机数生成器的种子，只要种子相同，则生成的公钥、私钥就是同一对.
         *                         <p>randomSeed 长度可以自定义，加/解密必须是同一个.</p>
         * @return
         */
        public static KeyPair generateRsaKeyPair(String secureRandomSeed) {
            //KeyPair 是密钥对（公钥和私钥）的简单持有者。加密、解密都需要使用.
            KeyPair keyPair = null;
            try {
                //获取生成 RSA 加密算法的公钥/私钥对 KeyPairGenerator 对象
                KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
                //获取实现指定算法（SHA1PRNG）的随机数生成器（RNG）对象.
                SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
                //重新设定此随机对象的种子.
                secureRandom.setSeed(secureRandomSeed.getBytes());
                /**
                 * initialize(int keySize, SecureRandom random):使用给定的随机源（random）初始化特定密钥大小的密钥对生成器。
                 * keySize: 健的大小值，这是一个特定于算法的度量。值越大，能加密的内容就越多，否则会抛异常：javax.crypto.IllegalBlockSizeException: Data must not be longer than xxx bytes
                 * 如 keySize 为 2048 时加密数据的长度不能超过 245 字节。
                 */
                keyPairGenerator.initialize(KEY_PAIR_LENGTH, secureRandom);
                //genKeyPair(): 生成密钥对
                keyPair = keyPairGenerator.genKeyPair();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            return keyPair;
        }
    
        /**
         * 使用私钥（PrivateKey）对数据进行加密 或 解密
         *
         * @param content          :待加/解密的数据。如果待解密的数据，则是 Base64 编码后的可视字符串.
         * @param model            ：1 表示加密模式（Cipher.ENCRYPT_MODE），2 表示解密模式（Cipher.DECRYPT_MODE）
         * @param secureRandomSeed ：SecureRandom 随机数生成器的种子，只要种子相同，则生成的公钥、私钥就是同一对.
         *                         加解密必须是同一个.
         * @return ：返回加/解密后的数据，如果是加密，则将字节数组使用 Base64 转为可视字符串.
         */
        public static String cipherByPrivateKey(String content, int model, String secureRandomSeed) {
            String result = "";
            try {
                //获取 RSA 密钥对
                KeyPair keyPair = generateRsaKeyPair(secureRandomSeed);
                /**getPrivate()：获取密钥对的私钥。
                 * getEncoded(): 返回已编码的密钥，如果密钥不支持编码，则返回 null*/
                byte[] privateEncoded = keyPair.getPrivate().getEncoded();
                /**PKCS8EncodedKeySpec(byte[] encodedKey): 使用给定的编码密钥创建新的 PKCS8EncodedKeySpec
                 * PKCS8EncodedKeySpec 表示 ASN.1 号私钥的编码*/
                EncodedKeySpec encodedKeySpec = new PKCS8EncodedKeySpec(privateEncoded);
                //创建 KeyFactory 对象，用于转换指定算法(RSA)的公钥/私钥。
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                //从提供的密钥规范生成私钥对象
                PrivateKey keyPrivate = keyFactory.generatePrivate(encodedKeySpec);
                //实例化 Cipher 对象。
                result = encryptionDecryption(content, model, keyPrivate);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 使用公钥（PublicKey）对数据进行加密 或 解解
         *
         * @param content          :待加解密的数据
         * @param model            ：1 表示加密模式（Cipher.ENCRYPT_MODE），2 表示解密模式（Cipher.DECRYPT_MODE）
         * @param secureRandomSeed ：SecureRandom 随机数生成器的种子，只要种子相同，则生成的公钥、私钥就是同一对.
         *                         加解密必须是同一个.
         * @return :返回加密 或者 解密后的数据
         */
        public static String cipherByPublicKey(String content, int model, String secureRandomSeed) {
            String result = "";
            try {
                // 得到公钥
                KeyPair keyPair = generateRsaKeyPair(secureRandomSeed);
                EncodedKeySpec keySpec = new X509EncodedKeySpec(keyPair.getPublic().getEncoded());
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                PublicKey keyPublic = keyFactory.generatePublic(keySpec);
                // 数据加/解密
                result = encryptionDecryption(content, model, keyPublic);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 加密或解密
         *
         * @param content :待加解密的数据
         * @param model   ：1 表示加密模式（Cipher.ENCRYPT_MODE），2 表示解密模式（Cipher.DECRYPT_MODE）
         * @param key     ：公钥（PUBLIC_KEY）或 私钥（PRIVATE_KEY）的 key
         * @return
         */
        private static String encryptionDecryption(String content, int model, Key key) {
            String result = "";
            try {
                Cipher cipher = Cipher.getInstance(CIPHER_TRANSFORMS);
                //init(int opMode, Key key)：初始化 Cipher.
                cipher.init(model, key);
                //如果是解密模式，则需要使用 Base64 进行解码.
                byte[] contentBytes = content.getBytes();
                if (model == Cipher.DECRYPT_MODE) {
                    contentBytes = new BASE64Decoder().decodeBuffer(content);
                }
                /**执行加密 或 解密操作。如果 contentBytes 内容过长，则 doFinal 可能会抛出异常.
                 *javax.crypto.IllegalBlockSizeException: Data must not be longer than 245 bytes ：数据不能超过xxx字节
                 * 此时需要调大 KEY_PAIR_LENGTH 的值*/
                byte[] finalBytes = cipher.doFinal(contentBytes);
                //如果是加密，则将加密后的字节数组使用 Base64 转成可视化的字符串。否则是解密时，直接 new String 字符串.
                if (model == Cipher.ENCRYPT_MODE) {
                    result = new BASE64Encoder().encode(finalBytes);
                } else if (model == Cipher.DECRYPT_MODE) {
                    result = new String(finalBytes);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        public static void main(String[] args) {
            String content = "红网时刻5月17日讯（记者 汪衡 通讯员 颜雨彬 汪丹）“场面壮观，气势磅礴.";
            String secureRandomSeed = "TPCz0lDvTHybGMsHTJi3mJ7Pt48llJmRHb";
    
            System.out.println("被加密数据字节大小：" + content.getBytes().length + " 字节，" + content.length() + " 个字符");
            System.out.println("源内容：\n" + content);
            try {
                //公钥、私钥必须分开使用，公钥解密时，必须是私钥解密，反之亦然.
                String encrypted = CipherRsaUtils.cipherByPublicKey(content, 1, secureRandomSeed);
                String decrypted = CipherRsaUtils.cipherByPrivateKey(encrypted, 2, secureRandomSeed);
                System.out.println("加密后：\n" + encrypted);
                System.out.println("解密后：\n" + decrypted);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    }

> 在线源码：[/src/main/java/com/wmx/thymeleafapp/utils/CipherRsaUtils.java][src_main_java_com_wmx_thymeleafapp_utils_CipherRsaUtils.java]

![20200518202111554.gif][]

# JCE 无限强度权限策略文件 #

1、Java 加密扩展（JCE）原生的 API 存在一定的限制，比如说加密的长度等，Oracle 官方提供的解决办法是，下载新的加密 jar 包替换本地 jdk 或者 jre 目录下原生的 jar 包。

2、这个增强版的 jar 包，官方称之为 JCE 无限强度权限策略文件（其实就是两个 jar 包）:下载地址： [https://www.oracle.com/java/technologies/javase-jce-all-downloads.html][https_www.oracle.com_java_technologies_javase-jce-all-downloads.html]

3、JDK9 及更高版本附带了无限制策略文件，并在默认情况下使用，所以不需要再额外处理，对于低版本则需要更新：

<table> 
 <tbody> 
  <tr> 
   <td>Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 8</td> 
   <td>0.01 MB</td> 
   <td> <p><a href="https://www.oracle.com/java/technologies/javase-jce-all-downloads.html#license-lightbox" rel="nofollow">jce_policy-8.zip</a></p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 7</td> 
   <td>7.3 K</td> 
   <td> <p><a href="https://www.oracle.com/java/technologies/javase-jce-all-downloads.html#license-lightbox" rel="nofollow">UnlimitedJCEPolicyJDK7.zip</a></p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 6</td> 
   <td>8.89 KB</td> 
   <td> <p><a href="https://www.oracle.com/java/technologies/javase-jce-all-downloads.html#license-lightbox" rel="nofollow">jce_policy-6.zip</a></p> </td> 
  </tr> 
 </tbody> 
</table>

4、使用非常简单，下载压缩包后进行解压，然后将里面的两个 jar 包替换本地 jdk 或者 jre 下自带的即可： `$JAVA_HOME/jre/lib/securit`

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdteDE5OTMzMjg_size_16_color_FFFFFF_t_70]: /images/20230312/2e7a141d9a8d40308aa3952d70b9d735.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdteDE5OTMzMjg_size_16_color_FFFFFF_t_70 1]: /images/20230312/dc4209ceda0045be8d63f2ca881306ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdteDE5OTMzMjg_size_16_color_FFFFFF_t_70 2]: /images/20230312/008d7f1e155f4b609057e6adac0b6f91.png
[20200518144147131.gif]: /images/20230312/fc0b02d56b444091ba1d300b7816465a.png
[src_main_java_com_wmx_thymeleafapp_utils_CipherUtils.java]: https://github.com/wangmaoxiong/thymeleafapp/blob/master/src/main/java/com/wmx/thymeleafapp/utils/CipherUtils.java
[src_main_java_com_wmx_thymeleafapp_utils_CipherRsaUtils.java]: https://github.com/wangmaoxiong/thymeleafapp/blob/master/src/main/java/com/wmx/thymeleafapp/utils/CipherRsaUtils.java
[20200518202111554.gif]: /images/20230312/c0dd23b1b6e245eb9c12794135b7c177.png
[https_www.oracle.com_java_technologies_javase-jce-all-downloads.html]: https://www.oracle.com/java/technologies/javase-jce-all-downloads.html