RSA加密解密

最新推荐文章于 2021-04-26 14:47:55 发布
最新推荐文章于 2021-04-26 14:47:55 发布
阅读量361 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 安全 文章标签： RSA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Abracadabra__/article/details/84974807

1.RSA：非对称加密
1、每个用户拥用一对密钥加密：公钥和私钥。
2、公钥加密，私钥解密；私钥加密，公钥解密。
公钥加密实现：发送方用接收方的公钥加密自己的密钥，接收方用自己的私钥解密得到发送方的密钥，逆过来亦然，从而实现密钥交换。
通信过程

2. RSA编码实现
RsaUtil.java

package SINO.encrypt.ras;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import SINO.encrypt.base64.BASE64Tools;
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
 
import javax.crypto.Cipher;


public class RsaUtil {
	 /**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "RSA";
    
    /** 
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
 
    /** 
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";
    
    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";
	
	/**
	 * RSA最大加密明文大小
	 */
	private static final int MAX_ENCRYPT_BLOCK = 117;

	/** 
	 * RSA最大解密密文大小
	 */
	private static final int MAX_DECRYPT_BLOCK = 128;


	/**
	 * 生成密钥对
	 * @return 长度为2的String数组，分别为BASE64编码的公钥和密钥
	 * @throws Exception
	 */
	public static String[] generateKeyPair(int KEY_SIZE) throws Exception {
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
		keyPairGen.initialize(KEY_SIZE);

		KeyPair keyPair = keyPairGen.generateKeyPair();
		System.out.println("keyPair.getPublic():"+keyPair.getPublic());
		System.out.println("keyPair.getPrivate():"+keyPair.getPrivate());
		String publicKey = BASE64Tools.encrypt(keyPair.getPublic().getEncoded());
		String privateKey = BASE64Tools.encrypt(keyPair.getPrivate().getEncoded());
		return new String[] { publicKey, privateKey };
	}


	/**
	 * 生成密钥对(公钥和私钥)
	 * @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 = BASE64Tools.decrypt(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 BASE64Tools.encrypt(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 = BASE64Tools.decrypt(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(BASE64Tools.decrypt(sign));
	}

	/**
	 * 私钥解密 
	 * @param encryptedData 已加密数据
	 * @param privateKey 私钥(BASE64编码)
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
	        throws Exception {
	    byte[] keyBytes = BASE64Tools.decrypt(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 = BASE64Tools.decrypt(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 = BASE64Tools.decrypt(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 = BASE64Tools.decrypt(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 BASE64Tools.encrypt(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 BASE64Tools.encrypt(key.getEncoded());
	}

	public static void main(String[] args) throws Exception {
		Map<String, Object> keyPair = genKeyPair();
		System.out.println("公钥=" + keyPair.get(PUBLIC_KEY));
		System.out.println("私钥=" + keyPair.get(PRIVATE_KEY));
		
		System.out.println();
		String[] keyPairStr = generateKeyPair(1024);
		System.out.println("SINO公钥=" + keyPairStr[0]);
		System.out.println("SINO私钥=" + keyPairStr[1]);
		
		Map<String, Object> keyMap = RsaUtil.genKeyPair();
		String publicKey = RsaUtil.getPublicKey(keyMap);
		String privateKey = RsaUtil.getPrivateKey(keyMap);
		System.out.println("公钥=" + publicKey);
		System.out.println("私钥=" + privateKey);
		
	}
}

BASE64Tools.java

package SINO.encrypt.base64;

import java.io.File;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import com.thoughtworks.xstream.core.util.Base64Encoder;
/**
 * BASE64加密解密工具
 * @author huangpeijun
 */
public class BASE64Tools {
	/**
	 * 使用Cipher解密信息
	 * @param data 待解密的信息
	 * @return 解密后的信息
	 * @throws Exception
	 */
	public static byte[] decrypt(String data) throws Exception {
		return (new Base64Encoder()).decode(data);	
	}
	
	/**
	 * 使用BASE64加密信息
	 * @param data 待加密的信息
	 * @return 加密后的信息
	 * @throws Exception
	 */
	public static String encrypt(byte[] data) throws Exception { 
		return (new Base64Encoder()).encode(data);
	}
	

	public static void main(String[] args) throws Exception {
		byte[] a = "HelloWorld!".getBytes();
		String encode = encrypt(a);
		System.out.println("加密：" + encode);
		byte[] decode = decrypt(encode);
		System.out.println("解密：" + new String(decode));
	}
}

RSATester.java

package SINO.encrypt.ras;
import java.util.Map;

public class RSATester {
 
    static String publicKey;
    static String privateKey;
 
    static {
        try {
            Map<String, Object> keyMap = RsaUtil.genKeyPair();
            publicKey = RsaUtil.getPublicKey(keyMap);
            privateKey = RsaUtil.getPrivateKey(keyMap);
            System.err.println("公钥: \n\r" + publicKey);
            System.err.println("私钥： \n\r" + privateKey);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws Exception {
        test();
        testSign();
    }
 
    static void test() throws Exception {
        System.err.println("公钥加密——私钥解密");
        String source = "HelloWord";
        System.out.println("\r加密前文字：\r\n" + source);
        
        System.out.println();
        byte[] data = source.getBytes();
        byte[] encodedData = RsaUtil.encryptByPublicKey(data, publicKey);
        System.out.println("公钥加密后文字：\r\n" + new String(encodedData));
        
        System.out.println();
        byte[] decodedData = RsaUtil.decryptByPrivateKey(encodedData, privateKey);
        String target = new String(decodedData);
        System.out.println("私钥解密后文字: \r\n" + target);
    }
 
    static void testSign() throws Exception {
    	System.out.println();
        System.err.println("私钥加密——公钥解密");
        String source = "BigWorld";
        System.out.println("原文字：\r\n" + source);
        
        System.out.println();
        byte[] data = source.getBytes();
        byte[] encodedData = RsaUtil.encryptByPrivateKey(data, privateKey);
        System.out.println("私钥加密后：\r\n" + new String(encodedData));
        
        System.out.println();
        byte[] decodedData = RsaUtil.decryptByPublicKey(encodedData, publicKey);
        String target = new String(decodedData);
        System.out.println("公钥解密后: \r\n" + target);
        
        System.out.println();
        System.err.println("私钥签名——公钥验证签名");
        String sign = RsaUtil.sign(encodedData, privateKey);
        System.err.println("签名:\r" + sign);
        boolean status = RsaUtil.verify(encodedData, publicKey, sign);
        System.err.println("验证结果:\r" + status);
    }
}
rsa加解密工具类
牧梦者随笔
04-09 485
生成rsa密钥对、加密、解密工具类 import lombok.extern.slf4j.Slf4j; import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import java.security.*; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; import java
探秘 Lua-RSA：一个轻量级的Lua加密库
最新发布
gitblog_00032的博客
04-24 994
探秘 Lua-RSA：一个轻量级的Lua加密库 项目简介 在软件开发中，数据安全至关重要。尤其在移动设备和嵌入式系统上，由于资源限制，往往需要轻量级的加密解决方案。 就是一个专门为Lua编程语言设计的RSA加密模块，它提供了生成密钥对、公钥加密与私钥解密等基本功能，旨在帮助开发者在Lua环境中实现安全的数据交换。 技术分析 Lua-RSA的核心是实现了RSA算法，这是一种非对称加密算法，基于大素数...
RAS加解密
weixin_39357459的博客
01-29 1100
RAS加解密其实就是通过密钥和密匙进行加解密的一种加密算法需要连个jar包 bcprov-ext-jdk14-1.45.jar commons-codec-1.6.jar 第一个类是生成密钥和密匙的package com.cai.util; import java.security.KeyPair; import java.security.KeyPairGenerator;
RSA加密、解密 JAVA版 lua版 js版
weixin_37601506的博客
04-26 3312
安全加密总结 一、近代密码学 恩尼格玛密码机：（被人工智能之父图灵破解） 核心使用了位移和替换算法，（这种方式的密码可以采用频度分析法进行破解） 二、现代密码学 1、加密方式 （1）流加密 对信息流中的每个元素（一个字母或一个bit）作为基本的处理单元进行加密最后拼接成密文 （2）块加密 先对信息流进行分块，再对每个块进行加密 （3）举例 例如原文为abcd、流加密先对a加密、再对b加密、再对c加密、再对d加密，最后吧加密后的数据拼接组成密文。块加密先对原文分块比如abc 作为第一块、然后d+xx+xx为第
RSA加密与解密
乖乖的专栏
01-28 1940
package utils;   [html] view plaincopy import java.io.ByteArrayOutputStream;   import java.security.Key;   import java.security.KeyFactory;   import java.security.KeyPair;  
RSA加密解密工具，用于文件的加密和解密* RSA加密解密：私钥解密，公钥加密
02-11
在本压缩包中，提供了RSA加密解密的工具——PRO_TDES_RSA.exe，这是一个执行程序，能够帮助用户对文件进行加密和解密操作。结合"RSATool工具简易操作指南 .doc"，用户可以详细了解如何使用这个工具来保护他们的敏感...
.NET使用RSA加密解密的方法
01-20
本文实例为大家分享了.NET使用RSA加密解密的具体代码，供大家参考，具体内容如下 PassWordHelper.cs代码: using System; using System.IO; using System.Text; using System.Globalization; using System....
C# RSA加密解密
04-15
**C# RSA加密解密详解** 在信息安全领域，加密技术是一种至关重要的手段，用于保护数据的隐私和安全性。RSA（Rivest-Shamir-Adleman）算法是一种非对称加密算法，广泛应用于网络通信、数据存储等领域。C#作为.NET...
易语言调用JSEncrypt实现RSA加密解密
06-03
在易语言中调用JSEncrypt库来实现RSA加密解密，可以为易语言的应用增加一层安全防护。 JSEncrypt是一个JavaScript库，由Benjamin van Ryseghem开发，主要用于RSA加密操作，特别适用于前端与后端之间的安全通信。它...
C#RSA加密解密工具
09-07
C# RSA加密解密工具是一种基于公钥/私钥对的加密算法实现，主要用于保障数据的安全传输和存储。RSA（Rivest-Shamir-Adleman）算法是公开密钥加密技术的鼻祖，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出...
加密算法之RSA
蓝天白云
07-16 2527
原文：http://www.cnblogs.com/sydeveloper/archive/2012/08/11/2633624.html http://www.codeforge.cn/read/240738/Base64Utils.java__html  1.RSA加密解密： 　(1)获取密钥，这里是产生密钥，实际应用中可以从各种存储介质上读取密钥 (2)加密 (3)解密 2.R
RSA加密异常
weixin_34043301的博客
08-22 549
   在利用RSA进行数据加密时，出现如下异常： Exception in thread "main" javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes at com.sun.crypto.provider.RSACipher.a(DashoA13*..) at com.s...
java RSA加密解密实现
www.jiav.net技术网站的加盟博客
01-24 254
该工具类中用到了BASE64，需要借助第三方类库：javabase64-1.3.1.jar 下载地址：http://download.youkuaiyun.com/detail/centralperk/5025595注意：RSA加密明文最大长度117字节，解密要求密文最大长度为128字节，所以在加密和解密的过程中需要分块进行。RSA加密对明文的长度是有限制的，如果加密数据过大会抛出如下异常： Except...
Lua 中的 RSA 加解密实现
weixin_30359021的博客
12-01 1719
　　记得之前，部门某款游戏陆陆续续收到一些玩家反馈，抱怨在登录游戏时会等待很久。初步排查后基本断定可能是此游戏的登录服务器程序某块代码有问题，于是即安排了服务器同事作排查分析但一直无果。 　　之后我时间有了空余，开始协助排查调试。简单了解了此登录服务器的逻辑处理流程后（接收到经过加密的 HTTP 登陆请求-->解密数据包-->去数据库查询对应的玩家信息并作验证），一开始我简单认为瓶颈...
pycrypto 和 lua-resty-rsa 进行跨语言的RSA加密解密.md
orangleliu 笔记本
05-15 7423
最近需要在 OpenResty（Nginx lua) 和 Python 中做RSA的加密和解密操作，客户端是Python的使用 pycrypto 库，而服务端使用 OpenResty 来做解密，使用了德江的 lua-resty-rsa。如果不熟悉2个库的同学可能会遇到一些问题，下面说下遇到问题和简单的示例。 主要遇到的问题就是 rsa padding的问题， lua-resty-rsa 默认使用的是
RAS算法，JS公钥加密，JAVA私钥解密
干掉熊猫我就是国宝
03-06 2516
总体思路：前端用公钥加密，后端用私钥解密rsa.html 展示了js进行加密、解密的过程RSAUtil.java 是一个java类，后端用到的RSA加解密工具类，里面包含了一个main方法，可以允许进行测试一般范式 1、前端请求后端生成RSA公钥信息； 2、后台端可以利用RSAUtil.java生成的RSA信息，将私钥自己存起来，将公钥返回给前端 3、前端拿到公钥，进行加...
公钥私解和私钥公解的应用RSA的加密
topMan'blog
08-15 247
/** * RSA 工具类。提供加密，解密，生成密钥对等方法。 * 需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。 * RSA加密原理概述   * RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数（大于100的十进制位）的函数。   * 据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积   * ==========...
RSAUtil加密工具类，HexUtil工具类
王人冉的博客
05-17 1649
RSAUtil.java import java.math.BigInteger; import java.security.InvalidParameterException; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import j...
简易RSA加密解密演示教程
RSA加密解密是信息安全领域的一个重要概念，它是目前应用最为广泛的公钥加密算法之一。本知识点将详细阐述RSA算法的基本原理、实现过程以及在实际应用中的相关知识。 ### RSA算法原理 RSA算法是由Rivest、Shamir和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值