对称加密与非对称加密工具类及测试

最新推荐文章于 2024-07-01 15:19:51 发布
最新推荐文章于 2024-07-01 15:19:51 发布
阅读量742 收藏
点赞数
文章标签： 对称加密 非对称加密 base64
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guanzhongye007/article/details/78583166
版权
1.public class AESUtil {

/**
* 将byte[]转为各种进制的字符串
* @param bytes byte[]
* @param radix 可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制
* @return 转换后的字符串
*/
private static String binary(byte[] bytes, int radix){
return new BigInteger(1, bytes).toString(radix);// 这里的1代表正数
}

/**
* base 64 encode
* @param bytes 待编码的byte[]
* @return 编码后的base 64 code
*/
private static String base64Encode(byte[] bytes){
return new BASE64Encoder().encode(bytes);
}

/**
* base 64 decode
* @param base64Code 待解码的base 64 code
* @return 解码后的byte[]
* @throws Exception
*/
private static byte[] base64Decode(String base64Code) throws Exception{
return (base64Code==null) ? null : new BASE64Decoder().decodeBuffer(base64Code);
}

/**
* 获取byte[]的md5值
* @param bytes byte[]
* @return md5
* @throws Exception
*/
private static byte[] md5(byte[] bytes) throws Exception {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(bytes);

return md.digest();
}

/**
* 获取字符串md5值
* @param msg 
* @return md5
* @throws Exception
*/
private static byte[] md5(String msg) throws Exception {
return (msg==null) ? null : md5(msg.getBytes());
}

/**
* 结合base64实现md5加密
* @param msg 待加密字符串
* @return 获取md5后转为base64
* @throws Exception
*/
private static String md5Encrypt(String msg) throws Exception{
return (msg==null) ? null : base64Encode(md5(msg));
}

/**
* AES加密
* @param content 待加密的内容
* @param encryptKey 加密密钥
* @return 加密后的byte[]
* @throws Exception
*/
private static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128, new SecureRandom(encryptKey.getBytes()));


Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));

return cipher.doFinal(content.getBytes("utf-8"));
}

/**
* AES加密为base 64 code
* @param content 待加密的内容
* @param encryptKey 加密密钥
* @return 加密后的base 64 code
* @throws Exception
*/
public static String aesEncrypt(String content, String encryptKey) throws Exception {
return base64Encode(aesEncryptToBytes(content, encryptKey));
}

/**
* AES解密
* @param encryptBytes 待解密的byte[]
* @param decryptKey 解密密钥
* @return 解密后的String
* @throws Exception
*/
private static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128, new SecureRandom(decryptKey.getBytes()));

Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
byte[] decryptBytes = cipher.doFinal(encryptBytes);

return new String(decryptBytes);
}

/**
* 将base 64 code AES解密
* @param encryptStr 待解密的base 64 code
* @param decryptKey 解密密钥
* @return 解密后的string
* @throws Exception
*/
public static String aesDecrypt(String encryptStr, String decryptKey) throws Exception {
return (encryptStr==null) ? null : aesDecryptByBytes(base64Decode(encryptStr), decryptKey);
}

}

2.

/**
 * <p>
 * BASE64编码解码工具包
 * 
 * @author ACER
 * @date 2012-5-19
 * @version 1.0
 */
public class Base64Utils {
/**
* 文件读取缓冲区大小
*/
private static final int CACHE_SIZE = 1024;


/**
* <p>
* BASE64字符串解码为二进制数据
* </p>
* 
* @param base64
* @return
* @throws Exception
*/
public static byte[] decode(String base64) throws Exception {
return Base64.decode(base64.getBytes());
}


/**
* <p>
* 二进制数据编码为BASE64字符串
* </p>
* 
* @param bytes
* @return
* @throws Exception
*/
public static String encode(byte[] bytes) throws Exception {


return new String(Base64.encode(bytes));


}


/**
* <p>
* 将文件编码为BASE64字符串
* </p>
* <p>
* 大文件慎用，可能会导致内存溢出
* </p>
* 
* @param filePath
*            文件绝对路径
* @return
* @throws Exception
*/
public static String encodeFile(String filePath) throws Exception {


byte[] bytes = fileToByte(filePath);
return encode(bytes);


}


/**
* <p>
* BASE64字符串转回文件
* </p>
* 
* @param filePath
*            文件绝对路径
* @param base64
*            编码字符串
* @throws Exception
*/
public static void decodeToFile(String filePath, String base64)
throws Exception {


byte[] bytes = decode(base64);
byteArrayToFile(bytes, filePath);


}


/**
* <p>
* 文件转换为二进制数组
* </p>
* 
* @param filePath
*            文件路径
* @return
* @throws Exception
*/
public static byte[] fileToByte(String filePath) throws Exception {


byte[] data = new byte[0];
File file = new File(filePath);
if (file.exists()) {


FileInputStream in = new FileInputStream(file);
ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
byte[] cache = new byte[CACHE_SIZE];
int nRead = 0;
while ((nRead = in.read(cache)) != -1) {


out.write(cache, 0, nRead);
out.flush();


}
out.close();
in.close();
data = out.toByteArray();


}
return data;


}


/**
* <p>
* 二进制数据写文件
* </p>
* 
* @param bytes
*            二进制数据
* @param filePath
*            文件生成目录
*/
public static void byteArrayToFile(byte[] bytes, String filePath)
throws Exception {


InputStream in = new ByteArrayInputStream(bytes);
File destFile = new File(filePath);
if (!destFile.getParentFile().exists()) {


destFile.getParentFile().mkdirs();


}
destFile.createNewFile();
OutputStream out = new FileOutputStream(destFile);
byte[] cache = new byte[CACHE_SIZE];
int nRead = 0;
while ((nRead = in.read(cache)) != -1) {


out.write(cache, 0, nRead);
out.flush();


}
out.close();
in.close();


}
}

3.

public class RSAUtils{
    /**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "RSA";
     
    /**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
 
    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "LocatorPublicKey";
     
    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "LocatorPrivateKey";
     
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;
     
    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;
 
    /**
     * 生成密钥对(公钥和私钥)
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }
    /**
     * 用私钥对信息生成数字签名
     * @param data 已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return Base64Utils.encode(signature.sign());
    }
    /**
     * 校验数字签名
     * @param data 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @param sign 数字签名
     * @return
     * @throws Exception
     */
    public static boolean verify(byte[] data, String publicKey, String sign)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(Base64Utils.decode(sign));
    }
    /**
     * 私钥解密
     * @param encryptedData 已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }
 
    /**
     * 公钥解密
     * @param encryptedData 已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }
 
    /**
     * 公钥加密
     * @param data 源数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }
 
    /**
     * 私钥加密
     * @param data 源数据
     * @param privateKey 私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }
 
    /**
     * 获取私钥
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return Base64Utils.encode(key.getEncoded());
    }
    /**
     * 获取公钥
     * @param keyMap 密钥对
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return Base64Utils.encode(key.getEncoded());
    }
}

4.

public class TestSecurity {
public static void main(String[] args) throws Exception {
test01();
}
/**
* 非对称加密
* @throws Exception
*/
public static void test01() throws Exception{
//随机获取公钥私钥
Map<String, Object> keyMap = RSAUtils.genKeyPair();
String privateKey = RSAUtils.getPrivateKey(keyMap);
String publicKey=RSAUtils.getPublicKey(keyMap);

//私钥加密  公钥 解密  服务器-客户端
byte[] bytes1=RSAUtils.encryptByPrivateKey("我爱中国".getBytes(), privateKey);
String encode1 = new String(bytes1);
System.out.println("加密后："+encode1);
String decode1 = new String(RSAUtils.decryptByPublicKey(bytes1, publicKey));
System.out.println(decode1);

System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
//公钥加密 私钥解密  客户端-服务器
byte[] bytes2=RSAUtils.encryptByPublicKey("我爱java".getBytes(), publicKey);
String encode2 = new String(bytes2);
System.out.println("加密后："+encode2);
String decode2 = new String(RSAUtils.decryptByPrivateKey(bytes2, privateKey));
System.out.println(decode2);


}
/**
* 对称加密
* @throws Exception
*/
public static void test02() throws Exception{
String content = "I hate java";
System.out.println("加密前：" + content);
String key = "i love java";
String encrypt = AESUtil.aesEncrypt(content, key);
System.out.println("加密后：" + encrypt);
String decrypt = AESUtil.aesDecrypt(encrypt, key);
System.out.println("解密后：" + decrypt);
}
}

guanzhongye007
关注
对称加密与非对称加密
weixin_49171105的博客
07-19 829
DES的分组大小是64位，如果需要加密的明文 长度不足64位，需要进行填充。由于DES的密钥长度只有56位，因此DES容易受到暴力破解和差分攻击手段的威胁。公钥加密，私钥解密。对称加密指的是加密和解密使用同一个秘钥，所以叫对称加密。：安全，即使密文被拦截，公钥被获取，但只要不知道私钥，也就无法破解密文。例如：对称加密算法中，加密解密用的相同算法参数，次参数必须保密，为秘钥。在非对称加密算法中，公钥可以对外公开，为密钥，私钥必须对外保密，为秘钥。：加密算法比较复杂，安全性依赖算法与密钥，加密和解密效率低。
对称加密和非对称加密
qq_38702393的博客
01-09 232
加密一：概述1.1 对称加密1.2 非对称加密 一：概述 加密分为：对称加密、和非对称加密 1.1 对称加密 什么是对称加密？ 对称加密就是指，加密和解密使用同一个密钥的加密方式。 对称加密的工作过程 发送方使用密钥将明文数据加密成密文，然后发送出去，接收方收到密文后，使用同一个密钥将密文解密成明文读取。 对称加密的优点 加密计算量小、速度块，适合对大量数据进行加密的场景。 常见的对称加密算法有...
文件非对称加密解密工具（RSA）.exe
07-25
本工具是用于golang编写的，用于rsa非对称加密技术实现的对字符串的加密解密工具，可以对文件进行加密解密（txt、docx、xls文档等）。对文档加密会对文档同目录下生成一个后缀名加.hh的文档。 操作说明： 一、对字符串加密： 1.首先要生成加密的密钥 2.输入要加密的字符串对其进行加密 3.解密也需要相应的privatekey密钥 二、对文件加解密： 1.生成并保存密钥 2.选择相应的publickey.pem进行加密 3.选择相应的privatekey.pem进行文档解密
对称加密工具类
no pain !no gain !
09-30 338
头文件 包含终端命令，可以验证加密结果是否正确#import <Foundation/Foundation.h> #import <CommonCrypto/CommonCrypto.h>/** * 终端测试指令 * * DES(ECB)加密 * $ echo -n hello | openssl enc -des-ecb -K 616263 -nosalt | base64 *
RSA加密算法工具类
最新发布
二掌柜的博客
07-01 1237
RSA加密是一种非对称加密算法，由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）在1977年首次公开提出。RSA是他们三人姓氏的首字母组成的。RSA算法基于一个数学上的事实：将两个大质数相乘很容易，但是想要将其乘积分解成原始的质数因子却非常困难。这就是所谓的“陷门函数TDF”的概念，是RSA加密安全性的基础。
非对称加密工具类
weixin_30642305的博客
07-09 596
说明 非对称加密有公钥和私钥两个概念，私钥自己拥有，不能给别人，公钥公开。根据应用的不同，我们可以选择使用不同的密钥加密。 签名：使用私钥加密，公钥解密。用于让所有公钥所有者验证私钥所有者的身份并且用来防止私钥所有者发布的内容被篡改，但是不用来保证内容不被他人获得。 加密：用公钥加密，私钥解密。用于向公钥所有者发布信息,这个信息可能被他人篡改,但是无法被他人获得。 工具引入了hutool，可...
Java使用RSA非对称加密对大于117的字符串进行加密
谦虚使人发胖的博客
07-04 3097
import java.io.ByteArrayOutputStream; import java.io.IOException; import java.security.InvalidKeyException; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPair...
文件内容加密工具(非对称RSA加密算法版)
06-05
程序会让用户生成并保存一个公钥和一个私钥文件 用公钥对明文内容进行加密,加密后为乱码! 只能用唯一对应的私钥才能解密!
openssl测试对称加密和非对称加密以及数字签名测试demo,打开文件即可
05-01
在这个压缩包文件中，我们可以看到一个关于OpenSSL的测试项目，用于演示对称加密、非对称加密和数字签名的用法。接下来，我们将详细探讨这些概念及其在C++中的实现。 首先，对称加密是一种简单而快速的加密方式，它...
密码学实验_对称加密算法DES_非对称加密算法RSA.pdf
02-20
综上所述，本实验涵盖了密码学中的核心概念，通过实践使学生掌握了对称加密和非对称加密的实现细节。这种实践性的学习方法有助于巩固理论知识，增强实际问题解决能力，对于网络安全领域的研究和工作具有重要意义。
工具类-RSA非对称加密工具类，自用留存
07-06
非对称加密与对称加密不同，它使用一对密钥，一把是公开的公钥，另一把是私有的私钥。这种机制使得信息的发送方可以使用接收方的公钥来加密数据，只有持有对应私钥的接收方才能解密，从而保证了数据的安全性。 在...
对称加密工具
03-05
信息加密工具，可以供学生实验使用。没有电子书。
对称加密工具软件 DESTOOL DesTool
03-13
对称加密算法的教学实用工具。以及对对称加密技术的研究，都需要联系实用此工具。书山有路勤为径，学海无涯苦作舟。
AES对称加密java工具类
12-30
适用于java开发者使用，用于对称加密的数据。进行加密。
Java AES对称加密工具类Utils
12-18
综合网上的AES加密，把其做成一个工具类，方便加密解密的实现
Rsa非对称加密技术工具类
03-10
Rsa非对称加密技术工具类
对称加密算法工具
AuroraEle的博客
09-08 723
对称加密算法工具包 图片 源码 import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import java.security.GeneralSecurityException; import java.util.Base64; public class Encryption_tool { //对称加密算法工具包 // 加密: publ
AES对称加密工具类，拿来即用！
IT_Most的博客
11-26 684
AES对称加密，一看就会~
对称加密和非对称工具类
lzh657083979的博客
02-15 429
加密方法有对称加密和非对称加密两种。 对称加密是key+明文==加密后的数据 然后服务端得到加密后的数据和key解密得到明文。 这里key是一致的。 非对称加密是key是不一致的。安全，但效率低。 这里需要base64工具类，因为生成的乱码会在传输的过程中出问题。比如说我在这加密了一套算法，服务端那边拿到解密却不是这一套算法，这不是乱套了么，，所以最好规定一套公共的，加密解密都用这种算法...
对称加密与非对称加密原理及应用示例
"本文主要介绍了加密算法中的对称加密和非对称加密概念，并探讨了它们的优缺点。此外，还提到了数字签名的概念及其在实际应用中的作用，特别是使用RSA算法进行加密解密和签名验签的示例。" 在信息安全领域，加密...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值