java中rsa算法的使用_Java中利用RSA算法进行加密解密

最新推荐文章于 2024-04-18 12:00:00 发布
最新推荐文章于 2024-04-18 12:00:00 发布
阅读量281 收藏
点赞数
文章标签： java中rsa算法的使用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_28999945/article/details/114607457
版权

首先需要两个工具类

package cnsts.common.utils;

import java.io.BufferedReader;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.math.BigInteger;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.InvalidKeySpecException;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.RSAPublicKeySpec;

import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

/**

* Created by wk on 2017/2/14.

*/

public class RSAUtils {

private static String RSA = "RSA";

/** *//**

* RSA最大加密明文大小

*/

private static final int MAX_ENCRYPT_BLOCK = 117;

/**

* 随机生成RSA密钥对(默认密钥长度为1024)

*

* @return

*/

public static KeyPair generateRSAKeyPair()

{

return generateRSAKeyPair(1024);

}

/**

* 随机生成RSA密钥对

*

* @param keyLength

* 密钥长度，范围：512～2048

* 一般1024

* @return

*/

public static KeyPair generateRSAKeyPair(int keyLength)

{

try

{

KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);

kpg.initialize(keyLength);

return kpg.genKeyPair();

} catch (NoSuchAlgorithmException e)

{

e.printStackTrace();

return null;

}

}

/**

* 用公钥加密

* 每次加密的字节数，不能超过密钥的长度值减去11

*

* @param data

* 需加密数据的byte数据

* @param publicKey 公钥

* @return 加密后的byte型数据

*/

public static byte[] encryptData(byte[] data, PublicKey publicKey)

{

try

{

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

// 编码前设定编码方式及密钥

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

// 传入编码数据并返回编码结果

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;

} catch (Exception e)

{

e.printStackTrace();

return null;

}

}

/**

* 用私钥解密

*

* @param encryptedData

* 经过encryptedData()加密返回的byte数据

* @param privateKey

* 私钥

* @return

*/

public static byte[] decryptData(byte[] encryptedData, PrivateKey privateKey)

{

try

{

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

cipher.init(Cipher.DECRYPT_MODE, privateKey);

return cipher.doFinal(encryptedData);

} catch (Exception e)

{

e.printStackTrace();

return null;

}

}

/**

* 通过公钥byte[](publicKey.getEncoded())将公钥还原，适用于RSA算法

*

* @param keyBytes

* @return

* @throws NoSuchAlgorithmException

* @throws InvalidKeySpecException

*/

public static PublicKey getPublicKey(byte[] keyBytes) throws NoSuchAlgorithmException,

InvalidKeySpecException

{

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance(RSA);

PublicKey publicKey = keyFactory.generatePublic(keySpec);

return publicKey;

}

/**

* 通过私钥byte[]将公钥还原，适用于RSA算法

*

* @param keyBytes

* @return

* @throws NoSuchAlgorithmException

* @throws InvalidKeySpecException

*/

public static PrivateKey getPrivateKey(byte[] keyBytes) throws NoSuchAlgorithmException,

InvalidKeySpecException

{

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance(RSA);

PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

return privateKey;

}

/**

* 使用N、e值还原公钥

*

* @param modulus

* @param publicExponent

* @return

* @throws NoSuchAlgorithmException

* @throws InvalidKeySpecException

*/

public static PublicKey getPublicKey(String modulus, String publicExponent)

throws NoSuchAlgorithmException, InvalidKeySpecException

{

BigInteger bigIntModulus = new BigInteger(modulus);

BigInteger bigIntPrivateExponent = new BigInteger(publicExponent);

RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);

KeyFactory keyFactory = KeyFactory.getInstance(RSA);

PublicKey publicKey = keyFactory.generatePublic(keySpec);

return publicKey;

}

/**

* 使用N、d值还原私钥

*

* @param modulus

* @param privateExponent

* @return

* @throws NoSuchAlgorithmException

* @throws InvalidKeySpecException

*/

public static PrivateKey getPrivateKey(String modulus, String privateExponent)

throws NoSuchAlgorithmException, InvalidKeySpecException

{

BigInteger bigIntModulus = new BigInteger(modulus);

BigInteger bigIntPrivateExponent = new BigInteger(privateExponent);

RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);

KeyFactory keyFactory = KeyFactory.getInstance(RSA);

PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

return privateKey;

}

/**

* 从字符串中加载公钥

*

* @param publicKeyStr

* 公钥数据字符串

* @throws Exception

* 加载公钥时产生的异常

*/

public static PublicKey loadPublicKey(String publicKeyStr) throws Exception

{

try

{

byte[] buffer = Base64Utils.decode(publicKeyStr);

KeyFactory keyFactory = KeyFactory.getInstance(RSA);

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);

return (RSAPublicKey) keyFactory.generatePublic(keySpec);

} catch (NoSuchAlgorithmException e)

{

throw new Exception("无此算法");

} catch (InvalidKeySpecException e)

{

throw new Exception("公钥非法");

} catch (NullPointerException e)

{

throw new Exception("公钥数据为空");

}

}

/**

* 从字符串中加载私钥

* 加载时使用的是PKCS8EncodedKeySpec(PKCS#8编码的Key指令)。

*

* @param privateKeyStr

* @return

* @throws Exception

*/

public static PrivateKey loadPrivateKey(String privateKeyStr) throws Exception

{

try

{

byte[] buffer = Base64Utils.decode(privateKeyStr);

// X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);

KeyFactory keyFactory = KeyFactory.getInstance(RSA);

return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);

} catch (NoSuchAlgorithmException e)

{

throw new Exception("无此算法");

} catch (InvalidKeySpecException e)

{

throw new Exception("私钥非法");

} catch (NullPointerException e)

{

throw new Exception("私钥数据为空");

}

}

/**

* 从文件中输入流中加载公钥

*

* @param in

* 公钥输入流

* @throws Exception

* 加载公钥时产生的异常

*/

public static PublicKey loadPublicKey(InputStream in) throws Exception

{

try

{

return loadPublicKey(readKey(in));

} catch (IOException e)

{

throw new Exception("公钥数据流读取错误");

} catch (NullPointerException e)

{

throw new Exception("公钥输入流为空");

}

}

/**

* 从文件中加载私钥

*

* @param in

* 私钥文件名

* @return 是否成功

* @throws Exception

*/

public static PrivateKey loadPrivateKey(InputStream in) throws Exception

{

try

{

return loadPrivateKey(readKey(in));

} catch (IOException e)

{

throw new Exception("私钥数据读取错误");

} catch (NullPointerException e)

{

throw new Exception("私钥输入流为空");

}

}

/**

* 读取密钥信息

*

* @param in

* @return

* @throws IOException

*/

private static String readKey(InputStream in) throws IOException

{

BufferedReader br = new BufferedReader(new InputStreamReader(in));

String readLine = null;

StringBuilder sb = new StringBuilder();

while ((readLine = br.readLine()) != null)

{

if (readLine.charAt(0) == '-')

{

continue;

} else

{

sb.append(readLine);

sb.append('\r');

}

}

return sb.toString();

}

/**

* 打印公钥信息

*

* @param publicKey

*/

public static void printPublicKeyInfo(PublicKey publicKey)

{

RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;

System.out.println("----------RSAPublicKey----------");

System.out.println("Modulus.length=" + rsaPublicKey.getModulus().bitLength());

System.out.println("Modulus=" + rsaPublicKey.getModulus().toString());

System.out.println("PublicExponent.length=" + rsaPublicKey.getPublicExponent().bitLength());

System.out.println("PublicExponent=" + rsaPublicKey.getPublicExponent().toString());

}

public static void printPrivateKeyInfo(PrivateKey privateKey)

{

RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;

System.out.println("----------RSAPrivateKey ----------");

System.out.println("Modulus.length=" + rsaPrivateKey.getModulus().bitLength());

System.out.println("Modulus=" + rsaPrivateKey.getModulus().toString());

System.out.println("PrivateExponent.length=" + rsaPrivateKey.getPrivateExponent().bitLength());

System.out.println("PrivatecExponent=" + rsaPrivateKey.getPrivateExponent().toString());

}

}package cnsts.common.utils;

import java.io.UnsupportedEncodingException;

/**

* Created by wk on 2017/2/14.

*/

public class Base64Utils {

private static char[] base64EncodeChars = new char[]

{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',

'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',

'6', '7', '8', '9', '+', '/' };

private static byte[] base64DecodeChars = new byte[]

{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53,

54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,

12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,

30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1,

-1, -1, -1 };

/**

* 加密

*

* @param data

* @return

*/

public static String encode(byte[] data)

{

StringBuffer sb = new StringBuffer();

int len = data.length;

int i = 0;

int b1, b2, b3;

while (i < len)

{

b1 = data[i++] & 0xff;

if (i == len)

{

sb.append(base64EncodeChars[b1 >>> 2]);

sb.append(base64EncodeChars[(b1 & 0x3) << 4]);

sb.append("==");

break;

}

b2 = data[i++] & 0xff;

if (i == len)

{

sb.append(base64EncodeChars[b1 >>> 2]);

sb.append(base64EncodeChars[((b1 & 0x03) << 4) | ((b2 & 0xf0) >>> 4)]);

sb.append(base64EncodeChars[(b2 & 0x0f) << 2]);

sb.append("=");

break;

}

b3 = data[i++] & 0xff;

sb.append(base64EncodeChars[b1 >>> 2]);

sb.append(base64EncodeChars[((b1 & 0x03) << 4) | ((b2 & 0xf0) >>> 4)]);

sb.append(base64EncodeChars[((b2 & 0x0f) << 2) | ((b3 & 0xc0) >>> 6)]);

sb.append(base64EncodeChars[b3 & 0x3f]);

}

return sb.toString();

}

/**

* 解密

*

* @param str

* @return

*/

public static byte[] decode(String str)

{

try

{

return decodePrivate(str);

} catch (UnsupportedEncodingException e)

{

e.printStackTrace();

}

return new byte[]

{};

}

private static byte[] decodePrivate(String str) throws UnsupportedEncodingException

{

StringBuffer sb = new StringBuffer();

byte[] data = null;

data = str.getBytes("US-ASCII");

int len = data.length;

int i = 0;

int b1, b2, b3, b4;

while (i < len)

{

do

{

b1 = base64DecodeChars[data[i++]];

} while (i < len && b1 == -1);

if (b1 == -1)

break;

do

{

b2 = base64DecodeChars[data[i++]];

} while (i < len && b2 == -1);

if (b2 == -1)

break;

sb.append((char) ((b1 << 2) | ((b2 & 0x30) >>> 4)));

do

{

b3 = data[i++];

if (b3 == 61)

return sb.toString().getBytes("iso8859-1");

b3 = base64DecodeChars[b3];

} while (i < len && b3 == -1);

if (b3 == -1)

break;

sb.append((char) (((b2 & 0x0f) << 4) | ((b3 & 0x3c) >>> 2)));

do

{

b4 = data[i++];

if (b4 == 61)

return sb.toString().getBytes("iso8859-1");

b4 = base64DecodeChars[b4];

} while (i < len && b4 == -1);

if (b4 == -1)

break;

sb.append((char) (((b3 & 0x03) << 6) | b4));

}

return sb.toString().getBytes("iso8859-1");

}

}

然后新建一个用来加密解密的工具类

package cnsts.common.utils;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.InputStream;

import java.security.PrivateKey;

import java.security.PublicKey;

public class SecurityUtils {

/**

* 解密

* @param cipherText 密文

* @return 返回解密后的字符串

* @throws Exception

*/

public static String decrypt(String cipherText) throws Exception{

// 从文件中得到私钥

FileInputStream inPrivate = new FileInputStream(

SecurityUtils.class.getClassLoader().getResource("").getPath() + "/pkcs8_private_key.pem");

PrivateKey privateKey = RSAUtils.loadPrivateKey(inPrivate);

byte[] decryptByte = RSAUtils.decryptData(Base64Utils.decode(cipherText), privateKey);

String decryptStr = new String(decryptByte,"utf-8");

return decryptStr;

}

/**

* 加密

* @param plainTest 明文

* @return返回加密后的密文

* @throws Exception

*/

public static String encrypt(String plainTest) throws Exception{

FileInputStream inPublic = new FileInputStream(

SecurityUtils.class.getClassLoader().getResource("").getPath() + "/rsa_public_key.pem");

PublicKey publicKey = RSAUtils.loadPublicKey(inPublic);

// 加密

byte[] encryptByte = RSAUtils.encryptData(plainTest.getBytes(), publicKey);

String afterencrypt = Base64Utils.encode(encryptByte);

return afterencrypt;

}

}

思否小姐姐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java的rsa加密算法_基于Java的RSA加密算法实现
weixin_42349434的博客
02-22 1592
一、RSA算法描述(1)选取长度相等的两个大素数p、q，计算其乘积n=p.q(2)计算n的欧拉数Φ(n)=(p-1).(q-1)(3)随机选择加密密钥e，使得e与(p-1)、(q-1)互素(4)用欧几里得扩展算法计算解密密钥d，满足：ed=1modΦ(n)，(e，n)是公钥，d是私钥。(5)加密明文：Ci=mi^e(modn)(6)解密密文：mi=Ci^d(modn)二、RSA实现的Java代码1...
java的rsa加密算法_用java编程实现RSA加密算法
weixin_36425412的博客
02-22 3428
RSA加密算法是目前应用最广泛的公钥加密算法，特别适用于通过Internet传送的数据，常用于数字签名和密钥交换。那么我今天就给大家介绍一下如何利用Java编程来实现RSA加密算法。一、RSA加密算法描述RSA加密算法是1978年提出的。经过多年的分析和研究，在众多的公开密钥加密算法中，RSA加密算法最受推崇，它也被推荐为公开密钥数据加密标准。由数论知识可知，若将一个具有大素数因子的合数进行分解是...
RSA 公私钥加解密Java实现
qq_28600087的博客
10-09 7203
RSA加解密
DES加密解密
nnnnch的博客
11-24 203
package com.test; import java.security.InvalidKeyException; import java.security.SecureRandom; import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.SecretKeyFact
RSA+AES实现混合加密
最新发布
xnxqwzy的博客
04-18 1256
为什么使用RSA + AES混合加密1.加密介绍2.加密思路3.混合加密原因基于以上特点，就有了我们混合加密的思路时序图前端代码：创建aesUtils.js创建CryptoJSUtils.jsjava后台创建DecodeRequestBodyAdvice.java创建EncodeResponseBodyAdvice.java创建接口：SecurityParameter测试。
Java实现加密（二）RSA加解密
ACGkaka的博客
09-19 1万+
RSA是一种应用比较广泛的非对称加密算法，是由MIT工作的三人姓名首字母命名的。RSA算法主要依靠分解大素数的复杂性来实现其安全性，由于大素数之积难被分解，因此该密码就难被破解。（素数：质数的别称，一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则成为合数，规定1既不是质数也不是合数。）从1977年提出到现在已经四十余年，经历了各种攻击的考验，普遍认为是目前最优秀的公钥方案之一。
java代码还原rsa私钥,java生成RSA公私钥字符串，简单易懂
weixin_27298377的博客
03-15 467
解决方法：1.下载bcprov-jdk16-140.jar包，参考：http://www.yayihouse.com/yayishuwu/chapter/15372.java代码KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");keyPairGenerator.initialize(2048);KeyPa...
RSA算法使用介绍
weixin_33858485的博客
09-17 215
国内私募机构九鼎控股打造APP，来就送 20元现金领取地址：http://jdb.jiudingcapital.com/phone.html内部邀请码：C8E245J （不写邀请码，没有现金送）国内私募机构九鼎控股打造，九鼎投资是在全国股份转让系统挂牌的公众公司，股票代码为430719，为“中国PE第一股”，市值超1000亿元。    ---------------------------...
Rsa.rar_RSA 算法_java 非对称 加密 算法_rsa java
09-19
用JAVA实现Rsa非对称加密算法 不算简单的算法 既可以加密又可以解密
RSA.zip_RSA 加密解密_rsa_rsa加密算法_rsa加密解密_rsa加密解密算法
09-20
RSA加密解密算法源码,功能齐全,没有密码,使用方便,学习用.
JAVA 中解密RSA算法JS加密实例详解
10-20
在Java中，解密RSA算法通常涉及到以下步骤： 1. 导入必要的库：在上述代码中，`commons-codec`包用于Base64编码和解码，而Java标准库提供了解密和加密所需的`javax.crypto`和`java.security`包。 2. 定义常量：`...
RSA.rar_RSA算法Python_python实现加密_rsa加密_加密_加密解密
09-20
python实现的RSA加密解密算法，带图形界面，key.py随机生成公钥私钥，消息可利用加密器解密器进行加密
RSA.rar_RSA 算法_rsa_rsa加密解密_rsa算法模拟
09-24
RSA加密解密，密码编码学与网络安全课程的重点之一。本程序用于模拟实现RSA的加密和解密算法
java加解密之RSA使用
热门推荐
生为码农，死亦码奴
09-20 5万+
最近为了分析一段请求流，不得不去研究一下RSA加密。 网上关于RSA的原理一抓一大把的，这里只是简单说说我的理解： 1. 两个足够大的互质数p, q； 2. 用于模运算的模 n=p*q； 3. 公钥KU（e, n）中的e满足 1 4. 密钥KR（d, n）中的d满足  d*e % (p-1)(q-1）= 1，%是取余运算。 因为公钥是公开的，所以我知道了e和n，那么根据2,3,4式子的
mysql rsa加密_RSA加密的方式和解密方式
weixin_39715290的博客
01-27 1010
RSAsecurity.javapackage com.mstf.rsa;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.PrivateKey;import java.security.PublicKey;i...
Java使用RSA算法
weixin_30706507的博客
02-13 496
RSA算法代码如下： package gj.secure; import javax.crypto.Cipher; import java.io.ByteArrayOutputStream; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGen...
java使用RSA加密方式实现数据加密解密
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
10-07 2万+
全栈工程师开发手册 （作者：栾鹏） java教程全解 java使用RSA加密方式实现数据加密解密，需要首先产生私钥和公钥测试代码public static void main(String args[]) { try { RSADemo rsa=new RSADemo(); rsa.generateKey(); byte[] da
RSA PKCS1私钥解密（JAVA实现）
xiaobai___111的博客
03-26 1万+
在开始编码前，你需要根据你的JAVA版本下载2个JAR文件 Bouncycastle的主JAR包 bcprov-jdk15on-164.jar 和OPENSSL相关JAR包 bcpkix-jdk15on-164.jar 官网 https://www.bouncycastle.org/java.html private String decryptRSA(String str, String pri...
[企业微信二次开发]RSA PKCS1私钥解密获取加密消息（JAVA实现）
weixin_43303530的博客
12-24 2319
获取企业微信会话存档内容需要使用RSA PKCS1算法和私钥对str1进行解密 在开始编码前，你需要根据你的JAVA版本下载2个JAR文件 Bouncycastle的主JAR包 bcprov-jdk15on-164.jar 和OPENSSL相关JAR包 bcpkix-jdk15on-164.jar 官网 https://www.bouncycastle.org/java.html maven导入： <dependency> <groupId>org.bouncycastl.
前端使用RSA算法加密超长文本数据，java进行解密
07-12
对于前端使用RSA算法加密超长文本数据，Java进行解密的问题，可以按照以下步骤进行操作： 1. 前端使用RSA公钥加密文本数据： - 生成RSA公钥和私钥对。 - 将文本数据分割成较短的块，每个块的长度不超过RSA算法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值