【Java----加密解密】第八章 对称加密算法--AES

最新推荐文章于 2023-02-22 15:47:40 发布
最新推荐文章于 2023-02-22 15:47:40 发布
阅读量171 收藏
点赞数
分类专栏： 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ningjiebing/article/details/89410822
版权

注意：本节内容主要参考自《Java加密与解密的艺术（第2版）》第7章“初等加密算法--对称加密算法”

8.1、AES

特点：

  • 密钥建立时间短、灵敏性好、内存需求低（不管怎样，反正就是好）
  • 最常用的对称加密算法

8.2、实现方式

  • JDK（密钥长度有128,192,256三种选法，提供PKCS5Padding的填充模式）
  • Bouncy Castle（密钥长度有128,192,256三种选法，提供PKCS7Padding的填充模式）

8.2.1、基于JDK或BC的AES实现（工作模式为ECB）

package com.util.aes;

import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import java.security.spec.InvalidKeySpecException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**
 * 基于JDK或BC的AES算法，工作模式采用ECB
 */
public class AESJDK {
    private static final String ENCODING = "UTF-8";
    private static final String KEY_ALGORITHM = "AES";//产生密钥的算法
    private static final String CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//加解密算法 格式：算法/工作模式/填充模式 注意：ECB不使用IV参数
    /**
     * 产生密钥
     */
    public static byte[] getKey() throws NoSuchAlgorithmException{
        Security.addProvider(new BouncyCastleProvider());//在BC中用，JDK下去除
        KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_ALGORITHM);
        keyGenerator.init(256);//初始化密钥长度,128,192,256（选用192和256的时候需要配置无政策限制权限文件--JDK6）
        SecretKey key =keyGenerator.generateKey();//产生密钥
        return key.getEncoded();
    }
    
    /**
     * 还原密钥：二进制字节数组转换为Java对象
     */
    public static Key toKey(byte[] keyByte){
        return new SecretKeySpec(keyByte, KEY_ALGORITHM);
    }
    
    /**
     * AES加密
     * @param data     带加密数据
     * @param keyByte  密钥
     */
    public static byte[] encrypt(String data, byte[] keyByte) throws InvalidKeyException, 
                                                                     NoSuchAlgorithmException, 
                                                                     InvalidKeySpecException, 
                                                                     NoSuchPaddingException, 
                                                                     IllegalBlockSizeException, 
                                                                     BadPaddingException, 
                                                                     UnsupportedEncodingException, 
                                                                     NoSuchProviderException, 
                                                                     InvalidAlgorithmParameterException{
        Key key = toKey(keyByte);//还原密钥
        //Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);//JDK下用
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM,"BC");//BC下用
        cipher.init(Cipher.ENCRYPT_MODE, key);//设置加密模式并且初始化key
        return cipher.doFinal(data.getBytes(ENCODING));
    }
    
    /**
     * AES加密，并转为16进制字符串或Base64编码字符串
     */
    public static String encryptAESHex(String data, byte[] keyByte) throws InvalidKeyException, 
                                                                           NoSuchAlgorithmException, 
                                                                           InvalidKeySpecException, 
                                                                           NoSuchPaddingException, 
                                                                           IllegalBlockSizeException, 
                                                                           BadPaddingException, 
                                                                           UnsupportedEncodingException, 
                                                                           NoSuchProviderException, 
                                                                           InvalidAlgorithmParameterException {
        byte[] encodedByte = encrypt(data, keyByte);
        //return new String(Hex.encode(encodedByte));//借助BC
        //return new String(org.apache.commons.codec.binary.Hex.encodeHexString(encodedByte));//借助CC
        return Base64.encodeBase64String(encodedByte);//借助CC的Base64编码
    }
    
    /**
     * AES解密
     * @param data        待解密数据为字节数组
     * @param keyByte    密钥
     */
    public static byte[] decrypt(byte[] data, byte[] keyByte) throws InvalidKeyException, 
                                                                     NoSuchAlgorithmException, 
                                                                     InvalidKeySpecException, 
                                                                     NoSuchPaddingException, 
                                                                     IllegalBlockSizeException, 
                                                                     BadPaddingException, 
                                                                     UnsupportedEncodingException, 
                                                                     NoSuchProviderException, 
                                                                     InvalidAlgorithmParameterException {
        Key key = toKey(keyByte);//还原密钥
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM,"BC");//BC下用
        //Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);//JDK下用
        cipher.init(Cipher.DECRYPT_MODE, key);
        return cipher.doFinal(data);
    }
    
    /**
     * AES解密
     * @param data        待解密数据为字符串
     * @param keyByte    密钥
     */
    public static byte[] decrypt(String data, byte[] keyByte) throws InvalidKeyException, 
                                                                     NoSuchAlgorithmException, 
                                                                     InvalidKeySpecException, 
                                                                     NoSuchPaddingException, 
                                                                     IllegalBlockSizeException, 
                                                                     BadPaddingException, 
                                                                     UnsupportedEncodingException, 
                                                                     NoSuchProviderException, 
                                                                     InvalidAlgorithmParameterException {
        Key key = toKey(keyByte);//还原密钥
        //Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);//JDK下用
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM,"BC");//BC下用
        cipher.init(Cipher.DECRYPT_MODE, key);
        return cipher.doFinal(Base64.decodeBase64(data));//注意data不可以直接采用data.getByte()方法转化为字节数组，否则会抛异常
    }
    
    /**
     * 测试
     */
    public static void main(String[] args) throws NoSuchAlgorithmException, 
                                                  InvalidKeyException, 
                                                  InvalidKeySpecException, 
                                                  NoSuchPaddingException, 
                                                  IllegalBlockSizeException, 
                                                  BadPaddingException, 
                                                  UnsupportedEncodingException, 
                                                  NoSuchProviderException, 
                                                  InvalidAlgorithmParameterException {
        String data = "找一个好姑娘做老婆是我的梦 想!";
        /*************测试encrypt()、decrypt()**************/
        System.out.println("原文-->"+data);
        byte[] keyByte = AESJDK.getKey(); 
        System.out.println("密钥-->"+Base64.encodeBase64String(keyByte));//这里将二进制的密钥使用base64加密保存，这也是在实际中使用的方式
        byte[] encodedByte = AESJDK.encrypt(data, keyByte);
        System.out.println("加密后-->"+encodedByte);
        byte[] encodedByte2 = AESJDK.encrypt(data, keyByte);
        System.out.println("加密后-->"+encodedByte2);
        byte[] decodedByte = AESJDK.decrypt(encodedByte, keyByte);
        System.out.println("解密后-->"+decodedByte);
        for(int i=0;i<encodedByte.length;i++){
            System.out.println(encodedByte[i]==encodedByte2[i]);
        }
        /*************测试encryptAESHex()、decrypt()**************/
        System.out.println("原文-->"+data);
        byte[] keyByte3 = AESJDK.getKey(); 
        System.out.println("密钥-->"+Base64.encodeBase64String(keyByte3));//这里将二进制的密钥使用base64加密保存，这也是在实际中使用的方式
        String encodedStr = AESJDK.encryptAESHex(data, keyByte3);
        System.out.println("加密后-->"+encodedStr);
        String encodedByte4 = AESJDK.encryptAESHex(data, keyByte3);
        System.out.println("加密后-->"+encodedByte4);
        byte[] decodedByte3 = AESJDK.decrypt(Base64.decodeBase64(encodedStr), keyByte3);
        System.out.println("解密Byte[]后-->"+decodedByte3);
        byte[] decodedByte4 = AESJDK.decrypt(encodedStr, keyByte3);
        System.out.println("解密String后-->"+decodedByte4);
    }
}

View Code

注意点：

  • 本文JDK版本采用的是1.6（也是当下企业常用的版本）
  • 基于JDK或是基于BC去实现查看代码中注释即可
  • 想使用BC下，需要在生成密钥的地方加上Security.addProvider(new BouncyCastleProvider());（这与书中不同，可能JDK7不需要加）
  • 密钥初始化长度可以为128,192,256，其中在选用192和256的时候需要配置无政策限制权限文件，具体方法文末会讲。（这与书中不同，可能JDK7下192不需要配置那个文件）

这个类具体在实际中使用的方式见"Java企业项目开发实践"《第六章 企业项目开发--cookie》，具体链接如下：

http://www.cnblogs.com/java-zhao/p/5128393.html

8.2.2、基于BC的AES实现（工作模式为CTR）（这个类在我后边的使用中有点问题，以后有时间再来解决，如果要用AES算法的话，用上边那种就好）

package com.util.aes;

import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import java.security.spec.InvalidKeySpecException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**
 * 基于BC的AES算法，工作模式采用CTR
 */
public class AESBC {
    private static final String ENCODING = "UTF-8";
    private static final String KEY_ALGORITHM = "AES";//产生密钥的算法
    private static final String CIPHER_ALGORITHM = "AES/CTR/PKCS7Padding";//加解密算法 格式：算法/工作模式/填充模式 注意：ECB不使用IV参数，CTR使用
    private static final byte[] IV = "zhaojigangzhaoji".getBytes();//注意：这里需要是十六个字符,用于CTR
    /**
     * 产生密钥
     */
    public static byte[] getKey() throws NoSuchAlgorithmException{
        Security.addProvider(new BouncyCastleProvider());//加入BCProvider
        KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_ALGORITHM);
        keyGenerator.init(256);//初始化密钥长度,128,192,256（选用192和256的时候需要配置无政策限制权限文件--JDK6）
        SecretKey key =keyGenerator.generateKey();//产生密钥
        return key.getEncoded();
    }
    
    /**
     * 还原密钥：二进制字节数组转换为Java对象
     */
    public static Key toKey(byte[] keyByte){
        return new SecretKeySpec(keyByte, KEY_ALGORITHM);
    }
    
    /**
     * AES加密
     * @param data     带加密数据
     * @param keyByte  密钥
     */
    public static byte[] encrypt(String data, byte[] keyByte) throws InvalidKeyException, 
                                                                     NoSuchAlgorithmException, 
                                                                     InvalidKeySpecException, 
                                                                     NoSuchPaddingException, 
                                                                     IllegalBlockSizeException, 
                                                                     BadPaddingException, 
                                                                     UnsupportedEncodingException, 
                                                                     NoSuchProviderException, 
                                                                     InvalidAlgorithmParameterException{
        Key key = toKey(keyByte);//还原密钥
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM,"BC");//使用BC
        cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(IV));//设置加密模式并且初始化key,加入IV用于BC下的CTR
        return cipher.doFinal(data.getBytes(ENCODING));
    }
    
    /**
     * AES加密，并转为16进制字符串或Base64编码字符串
     */
    public static String encryptAESHex(String data, byte[] keyByte) throws InvalidKeyException, 
                                                                           NoSuchAlgorithmException, 
                                                                           InvalidKeySpecException, 
                                                                           NoSuchPaddingException, 
                                                                           IllegalBlockSizeException, 
                                                                           BadPaddingException, 
                                                                           UnsupportedEncodingException, 
                                                                           NoSuchProviderException, 
                                                                           InvalidAlgorithmParameterException {
        byte[] encodedByte = encrypt(data, keyByte);
        //return new String(Hex.encode(encodedByte));//借助BC
        //return new String(org.apache.commons.codec.binary.Hex.encodeHexString(encodedByte));//借助CC
        return Base64.encodeBase64String(encodedByte);//借助CC的Base64编码
    }
    
    /**
     * AES解密
     * @param data        待解密数据为字节数组
     * @param keyByte    密钥
     */
    public static byte[] decrypt(byte[] data, byte[] keyByte) throws InvalidKeyException, 
                                                                     NoSuchAlgorithmException, 
                                                                     InvalidKeySpecException, 
                                                                     NoSuchPaddingException, 
                                                                     IllegalBlockSizeException, 
                                                                     BadPaddingException, 
                                                                     UnsupportedEncodingException, 
                                                                     NoSuchProviderException, 
                                                                     InvalidAlgorithmParameterException {
        Key key = toKey(keyByte);//还原密钥
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM,"BC");
        cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(IV));//设置加密模式并且初始化key,加入IV用于BC下的CTR
        return cipher.doFinal(data);
    }
    
    /**
     * AES解密
     * @param data        待解密数据为字符串
     * @param keyByte    密钥
     */
    public static byte[] decrypt(String data, byte[] keyByte) throws InvalidKeyException, 
                                                                     NoSuchAlgorithmException, 
                                                                     InvalidKeySpecException, 
                                                                     NoSuchPaddingException, 
                                                                     IllegalBlockSizeException, 
                                                                     BadPaddingException, 
                                                                     UnsupportedEncodingException, 
                                                                     NoSuchProviderException, 
                                                                     InvalidAlgorithmParameterException {
        Key key = toKey(keyByte);//还原密钥
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM,"BC");
        cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(IV));//设置加密模式并且初始化key,加入IV用于BC下的CTR
        return cipher.doFinal(Base64.decodeBase64(data));
    }
    
    /**
     * 测试
     */
    public static void main(String[] args) throws NoSuchAlgorithmException, 
                                                  InvalidKeyException, 
                                                  InvalidKeySpecException, 
                                                  NoSuchPaddingException, 
                                                  IllegalBlockSizeException, 
                                                  BadPaddingException, 
                                                  UnsupportedEncodingException, 
                                                  NoSuchProviderException, 
                                                  InvalidAlgorithmParameterException {
        String data = "找一个好姑娘做老婆是我的梦 想!";
        /*************测试encrypt()、decrypt()**************/
        System.out.println("原文-->"+data);
        byte[] keyByte = AESBC.getKey(); 
        System.out.println("密钥-->"+Base64.encodeBase64String(keyByte));//这里将二进制的密钥使用base64加密保存，这也是在实际中使用的方式
        byte[] encodedByte = AESBC.encrypt(data, keyByte);
        System.out.println("加密后-->"+encodedByte);
        byte[] encodedByte2 = AESBC.encrypt(data, keyByte);
        System.out.println("加密后-->"+encodedByte2);
        byte[] decodedByte = AESBC.decrypt(encodedByte, keyByte);
        System.out.println("解密后-->"+decodedByte);
        for(int i=0;i<encodedByte.length;i++){
            System.out.println(encodedByte[i]==encodedByte2[i]);
        }
        /*************测试encryptAESHex()、decrypt()**************/
        System.out.println("原文-->"+data);
        byte[] keyByte3 = AESBC.getKey(); 
        System.out.println("密钥-->"+Base64.encodeBase64String(keyByte3));//这里将二进制的密钥使用base64加密保存，这也是在实际中使用的方式
        String encodedStr = AESBC.encryptAESHex(data, keyByte3);
        System.out.println("加密后-->"+encodedStr);
        String encodedByte4 = AESBC.encryptAESHex(data, keyByte3);
        System.out.println("加密后-->"+encodedByte4);
        byte[] decodedByte3 = AESBC.decrypt(Base64.decodeBase64(encodedStr), keyByte3);
        System.out.println("解密Byte[]后-->"+decodedByte3);
        byte[] decodedByte4 = AESBC.decrypt(encodedStr, keyByte3);
        System.out.println("解密String后-->"+decodedByte4);
    }
}

View Code

 注意点：

  • CTR是AES最常使用的工作模式
  • 在CTR模式下需要加入IV参数（必须是一个16位的自己数组，例如：byte[] IV = "zhaojigangzhaoji".getBytes()），这是ECB模式所不需要的。
  • IV参数用于cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(IV))

附：无政策限制权限文件配置方法：

第一步：下载配置文件压缩包

http://download.csdn.net/download/rzg813/8069407

第二步：用压缩包中下边选中的文件去覆盖%JAVA_HOME%\jre\lib\security和%JRE_HOME%\lib\security下相应的包即可。

 

Sunny3096
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现的对称加密算法AES定义与用法详解
08-27
主要介绍了Java实现的对称加密算法AES,结合实例形式分析了对称加密算法AES的定义、特点、用法及使用场景,需要的朋友可以参考下
C#实现微信AES-128-CBC加密数据的解密
03-29
小程序登录时，获得用户的信息，只是昵称，无法用作...对称解密使用的算法为 AES-128-CBC，数据采用PKCS#7填充。  对称解密的目标密文为 Base64_Decode(encryptedData),  对称解密秘钥 aeskey = Base64_Decode(sessio
java中的对称加密算法
冯冬冬的博客
09-08 2013
对数据的加密算是一个老生常谈的话题了，加密的方式很多，java也为这些加密算法提供了支持。今天就来聊聊对称加密算法的java实现方式。本文对加密算法不了解也没关系，我会从0开始讲解，保证小白也能看懂。 一、引言 这段时间在写论文，所以题目就叫做引言吧，在开始对对称加密算法真正认识之前，我们先看另外一块知识。相信我们都学过计算机中的一种位运算，叫做与或非（高中的时候就讲过，不知道的就回去补补）。下面...
java aes对称加密算法_java基于AES对称加密算法实现的加密与解密功能示例
weixin_36377635的博客
02-16 200
本文实例讲述了java基于aes对称加密算法实现的加密与解密功能。分享给大家供大家参考，具体如下：package com.soufun.com;import java.io.unsupportedencodingexception;import java.security.invalidkeyexception;import java.security.nosuchalgorithmexcepti...
Java中AES算法（对称加密）
qq_24614847的博客
03-23 216
话不多说上代码（思路大体一致）： 第一种： package *; import com.*.exception.exceptions.BusinessException; import javax.crypto.*; import java.nio.charset.StandardCharsets; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import jav.
Java实现AES加密算法
m0_60252632的博客
02-21 9346
一、AES简介 高级加密标准（AES，Advanced Encryption Standard）为最常见的对称加密算法。 对称加密算法：加密和解密用相同的密钥。 图解： 介绍： 明文 P 没有经过加密的原始数据 密钥 K 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的，密钥为发送方与接收方协商产生，但不可以直接在网络上传输，否则会导致密钥泄露，通常是通过非对称加密算法加密密钥，然后再通过网络传输给对方，或者直接面对面商量密钥 AES 加密函数 设AES加密函数为
AES对称加密算法-C语言
11-22
C语言实现AES-128对称加解密算法。编译环境：VS2010。请参考我的博客https://blog.csdn.net/u013073067/article/details/86529111 分析代码
小程序--前端AES加密
03-29
一.前言 什么是AES加密：高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称...AES加密的应用场景，AES加密可逆转加密，前后端公用一个秘钥来加密解密 二.难点： 小程序引入第三方库
Java AES对称加密解密算法
03-02
Java AES对称加密解密算法
微信小程序ASP版无组件加密数据解密算法 AES-128-CBC，数据采用PKCS#7填充
12-05
对称解密使用的算法为 AES-128-CBC，数据采用PKCS#7填充。 微信官方提供了多种编程语言的示例代码但是没有ASP的，网上也没有现成的，所以只能自己折腾了，通过整合CryptoJS v3.1.2可以实现AES跟BASE64的解密，从而...
Java 中的加密算法： AES
zhangjin501的专栏
01-05 5006
Java 中的加密算法： AES
Java加密算法—对称加密(DES、AES)
一恍过去
02-16 1万+
Java加密算法—对称加密(DES、AES)
Java笔记-对称加密AES的使用
IT1995的博客
08-17 895
AES加密库的使用： ·根据AES密钥创建Secret密钥向量； ·生成初始化参数向量； ·获取AES Cipher； ·执行加密； ·Base64编码（建议） 程序运行截图如下： 调用如下： public static void main(String[] args) throws UnsupportedEncodingException { String content = "123456"; AES aes = ne...
Java实现加密（一）AES加解密
热门推荐
ACGkaka的博客
09-19 4万+
AES：高级加密标准（Advanced Encryption Standard）是美国联邦政府采用的一种区块加密标准，是目前最流行的一种对称加密算法。是用来替代DES的新一代分组加密算法。AES支持三种长度的密钥：128位、192位、256位。
Java 对称加密几种算法分别实现
weixin_38885605的博客
02-17 347
https://www.jb51.net/article/102127.htm
Java AES算法加解密字符串
此生无分起相思
05-25 1577
结合网上资料自己封装了一个使用AES算法加解密String字符串的工具类，现记录如下import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.Sec...
Java实现AES对称加解密算法-块加密
生命的意义在于创造和毁灭
09-18 5473
生成AES固定、随机密钥或指定密钥实现AES加解密算法
Java 实现 AES 对称加密算法的加解密
yuanjian0814的博客
11-18 919
Java 实现 AES 对称加密算法的加解密前言一、AES 算法简介二、AES 加解密代码实例1.生成 AES 密钥2.AES 加解密3.AES + nonce 加解密总结 前言 一、AES 算法简介 二、AES 加解密代码实例 1.生成 AES 密钥 AES 密钥长度默认只支持128、192、256 这三种长度，不合法的密钥长度程序会抛出异常。 生成 AES 密钥时会使用到随机数生成器，可以指定不同的随机数算法，也可以在创建随机数生成器时指定 seed。 初始化算法生成器时，如果不指定随机数生成器默认使
密钥生成器KeyGenerator
kimi
02-22 4274
密钥生成器KeyGenerator
aes-256-cbc加密算法 解密
最新发布
02-27
AES-256-CBC是一种对称加密算法，它使用256位的密钥对数据进行加密和解密。CBC代表Cipher Block Chaining，它是一种分组密码模式，每个明文块与前一个密文块进行异或操作后再进行加密。 在AES-256-CBC算法中，明文...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值