JS客户端RSA加密，Java服务端解密

最新推荐文章于 2024-09-12 17:12:18 发布
最新推荐文章于 2024-09-12 17:12:18 发布
阅读量1k 收藏 1
点赞数
分类专栏： 网站安全 文章标签： 登陆明文传输
在客户端浏览器，Javascript使用RSA算法，以公钥对密码进行加密，服务端使用相应的私钥进行解密。一般用于注册时或登录时填写的密码。 
Java引用到的包： 
commons-lang 
bouncycastle 
slf4j 
commons-codec 
commons-io 


RSA加密工具类——RSAUtils.java
package my.tools.security;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.security.KeyPair;
import java.security.KeyFactory;
import java.security.KeyPairGenerator;
import java.security.Provider;
import java.security.PublicKey;
import java.security.PrivateKey;
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
import java.security.InvalidParameterException;
import java.security.interfaces.RSAPublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.InvalidKeySpecException;
 
import javax.crypto.Cipher;
 
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateFormatUtils;
 
/**
  * RSA算法加密/解密工具类。
  *
  * @author fuchun
  * @version 1.0.0, 2010-05-05
  */
public abstract class RSAUtils {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(RSAUtils. class );
 
     /** 算法名称 */
     private static final String ALGORITHOM = "RSA" ;
     /**保存生成的密钥对的文件名称。 */
     private static final String RSA_PAIR_FILENAME = "/__RSA_PAIR.txt" ;
     /** 密钥大小 */
     private static final int KEY_SIZE = 1024 ;
     /** 默认的安全服务提供者 */
     private static final Provider DEFAULT_PROVIDER = new BouncyCastleProvider();
 
     private static KeyPairGenerator keyPairGen = null ;
     private static KeyFactory keyFactory = null ;
     /** 缓存的密钥对。 */
     private static KeyPair oneKeyPair = null ;
 
     private static File rsaPairFile = null ;
 
     static {
         try {
             keyPairGen = KeyPairGenerator.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
             keyFactory = KeyFactory.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
         } catch (NoSuchAlgorithmException ex) {
             LOGGER.error(ex.getMessage());
         }
         rsaPairFile = new File(getRSAPairFilePath());
     }
 
     private RSAUtils() {
     }
 
     /**
      * 生成并返回RSA密钥对。
      */
     private static synchronized KeyPair generateKeyPair() {
         try {
             keyPairGen.initialize(KEY_SIZE, new SecureRandom(DateFormatUtils.format( "yyyyMMdd" ).getBytes()));
             oneKeyPair = keyPairGen.generateKeyPair();
             saveKeyPair(oneKeyPair);
             return oneKeyPair;
         } catch (InvalidParameterException ex) {
             LOGGER.error( "KeyPairGenerator does not support a key length of " + KEY_SIZE + "." , ex);
         } catch (NullPointerException ex) {
             LOGGER.error( "RSAUtils#KEY_PAIR_GEN is null, can not generate KeyPairGenerator instance." ,
                     ex);
         }
         return null ;
     }
 
     /**
      * 返回生成/读取的密钥对文件的路径。
      */
     private static String getRSAPairFilePath() {
         String urlPath = RSAUtils. class .getResource( "/" ).getPath();
         return ( new File(urlPath).getParent() + RSA_PAIR_FILENAME);
     }
 
     /**
      * 若需要创建新的密钥对文件，则返回 {@code true}，否则 {@code false}。
      */
     private static boolean isCreateKeyPairFile() {
         // 是否创建新的密钥对文件
         boolean createNewKeyPair = false ;
         if (!rsaPairFile.exists() || rsaPairFile.isDirectory()) {
             createNewKeyPair = true ;
         }
         return createNewKeyPair;
     }
 
     /**
      * 将指定的RSA密钥对以文件形式保存。
      *
      * @param keyPair 要保存的密钥对。
      */
     private static void saveKeyPair(KeyPair keyPair) {
         FileOutputStream fos = null ;
         ObjectOutputStream oos = null ;
         try {
             fos = FileUtils.openOutputStream(rsaPairFile);
             oos = new ObjectOutputStream(fos);
             oos.writeObject(keyPair);
         } catch (Exception ex) {
             ex.printStackTrace();
         } finally {
             IOUtils.closeQuietly(oos);
             IOUtils.closeQuietly(fos);
         }
     }
 
     /**
      * 返回RSA密钥对。
      */
     public static KeyPair getKeyPair() {
         // 首先判断是否需要重新生成新的密钥对文件
         if (isCreateKeyPairFile()) {
             // 直接强制生成密钥对文件，并存入缓存。
             return generateKeyPair();
         }
         if (oneKeyPair != null ) {
             return oneKeyPair;
         }
         return readKeyPair();
     }
     
     // 同步读出保存的密钥对
     private static KeyPair readKeyPair() {
         FileInputStream fis = null ;
         ObjectInputStream ois = null ;
         try {
             fis = FileUtils.openInputStream(rsaPairFile);
             ois = new ObjectInputStream(fis);
             oneKeyPair = (KeyPair) ois.readObject();
             return oneKeyPair;
         } catch (Exception ex) {
             ex.printStackTrace();
         } finally {
             IOUtils.closeQuietly(ois);
             IOUtils.closeQuietly(fis);
         }
         return null ;
     }
 
     /**
      * 根据给定的系数和专用指数构造一个RSA专用的公钥对象。
      *
      * @param modulus 系数。
      * @param publicExponent 专用指数。
      * @return RSA专用公钥对象。
      */
     public static RSAPublicKey generateRSAPublicKey( byte [] modulus, byte [] publicExponent) {
         RSAPublicKeySpec publicKeySpec = new RSAPublicKeySpec( new BigInteger(modulus),
                 new BigInteger(publicExponent));
         try {
             return (RSAPublicKey) keyFactory.generatePublic(publicKeySpec);
         } catch (InvalidKeySpecException ex) {
             LOGGER.error( "RSAPublicKeySpec is unavailable." , ex);
         } catch (NullPointerException ex) {
             LOGGER.error( "RSAUtils#KEY_FACTORY is null, can not generate KeyFactory instance." , ex);
         }
         return null ;
     }
 
     /**
      * 根据给定的系数和专用指数构造一个RSA专用的私钥对象。
      *
      * @param modulus 系数。
      * @param privateExponent 专用指数。
      * @return RSA专用私钥对象。
      */
     public static RSAPrivateKey generateRSAPrivateKey( byte [] modulus, byte [] privateExponent) {
         RSAPrivateKeySpec privateKeySpec = new RSAPrivateKeySpec( new BigInteger(modulus),
                 new BigInteger(privateExponent));
         try {
             return (RSAPrivateKey) keyFactory.generatePrivate(privateKeySpec);
         } catch (InvalidKeySpecException ex) {
             LOGGER.error( "RSAPrivateKeySpec is unavailable." , ex);
         } catch (NullPointerException ex) {
             LOGGER.error( "RSAUtils#KEY_FACTORY is null, can not generate KeyFactory instance." , ex);
         }
         return null ;
     }
     
     /**
      * 根据给定的16进制系数和专用指数字符串构造一个RSA专用的私钥对象。
      *
      * @param modulus 系数。
      * @param privateExponent 专用指数。
      * @return RSA专用私钥对象。
      */
     public static RSAPrivateKey getRSAPrivateKey(String hexModulus, String hexPrivateExponent) {
         if (StringUtils.isBlank(hexModulus) || StringUtils.isBlank(hexPrivateExponent)) {
             if (LOGGER.isDebugEnabled()) {
                 LOGGER.debug( "hexModulus and hexPrivateExponent cannot be empty. RSAPrivateKey value is null to return." );
             }
             return null ;
         }
         byte [] modulus = null ;
         byte [] privateExponent = null ;
         try {
             modulus = Hex.decodeHex(hexModulus.toCharArray());
             privateExponent = Hex.decodeHex(hexPrivateExponent.toCharArray());
         } catch (DecoderException ex) {
             LOGGER.error( "hexModulus or hexPrivateExponent value is invalid. return null(RSAPrivateKey)." );
         }
         if (modulus != null && privateExponent != null ) {
             return generateRSAPrivateKey(modulus, privateExponent);
         }
         return null ;
     }
     
     /**
      * 根据给定的16进制系数和专用指数字符串构造一个RSA专用的公钥对象。
      *
      * @param modulus 系数。
      * @param publicExponent 专用指数。
      * @return RSA专用公钥对象。
      */
     public static RSAPublicKey getRSAPublidKey(String hexModulus, String hexPublicExponent) {
         if (StringUtils.isBlank(hexModulus) || StringUtils.isBlank(hexPublicExponent)) {
             if (LOGGER.isDebugEnabled()) {
                 LOGGER.debug( "hexModulus and hexPublicExponent cannot be empty. return null(RSAPublicKey)." );
             }
             return null ;
         }
         byte [] modulus = null ;
         byte [] publicExponent = null ;
         try {
             modulus = Hex.decodeHex(hexModulus.toCharArray());
             publicExponent = Hex.decodeHex(hexPublicExponent.toCharArray());
         } catch (DecoderException ex) {
             LOGGER.error( "hexModulus or hexPublicExponent value is invalid. return null(RSAPublicKey)." );
         }
         if (modulus != null && publicExponent != null ) {
             return generateRSAPublicKey(modulus, publicExponent);
         }
         return null ;
     }
 
     /**
      * 使用指定的公钥加密数据。
      *
      * @param publicKey 给定的公钥。
      * @param data 要加密的数据。
      * @return 加密后的数据。
      */
     public static byte [] encrypt(PublicKey publicKey, byte [] data) throws Exception {
         Cipher ci = Cipher.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
         ci.init(Cipher.ENCRYPT_MODE, publicKey);
         return ci.doFinal(data);
     }
 
     /**
      * 使用指定的私钥解密数据。
      *
      * @param privateKey 给定的私钥。
      * @param data 要解密的数据。
      * @return 原数据。
      */
     public static byte [] decrypt(PrivateKey privateKey, byte [] data) throws Exception {
         Cipher ci = Cipher.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
         ci.init(Cipher.DECRYPT_MODE, privateKey);
         return ci.doFinal(data);
     }
 
     /**
      * 使用给定的公钥加密给定的字符串。
      * <p />
      * 若 {@code publicKey} 为 {@code null}，或者 {@code plaintext} 为 {@code null} 则返回 {@code
      * null}。
      *
      * @param publicKey 给定的公钥。
      * @param plaintext 字符串。
      * @return 给定字符串的密文。
      */
     public static String encryptString(PublicKey publicKey, String plaintext) {
         if (publicKey == null || plaintext == null ) {
             return null ;
         }
         byte [] data = plaintext.getBytes();
         try {
             byte [] en_data = encrypt(publicKey, data);
             return new String(Hex.encodeHex(en_data));
         } catch (Exception ex) {
             LOGGER.error(ex.getCause().getMessage());
         }
         return null ;
     }
     
     /**
      * 使用默认的公钥加密给定的字符串。
      * <p />
      * 若{@code plaintext} 为 {@code null} 则返回 {@code null}。
      *
      * @param plaintext 字符串。
      * @return 给定字符串的密文。
      */
     public static String encryptString(String plaintext) {
         if (plaintext == null ) {
             return null ;
         }
         byte [] data = plaintext.getBytes();
         KeyPair keyPair = getKeyPair();
         try {
             byte [] en_data = encrypt((RSAPublicKey)keyPair.getPublic(), data);
             return new String(Hex.encodeHex(en_data));
         } catch (NullPointerException ex) {
             LOGGER.error( "keyPair cannot be null." );
         } catch (Exception ex) {
             LOGGER.error(ex.getCause().getMessage());
         }
         return null ;
     }
 
     /**
      * 使用给定的私钥解密给定的字符串。
      * <p />
      * 若私钥为 {@code null}，或者 {@code encrypttext} 为 {@code null}或空字符串则返回 {@code null}。
      * 私钥不匹配时，返回 {@code null}。
      *
      * @param privateKey 给定的私钥。
      * @param encrypttext 密文。
      * @return 原文字符串。
      */
     public static String decryptString(PrivateKey privateKey, String encrypttext) {
         if (privateKey == null || StringUtils.isBlank(encrypttext)) {
             return null ;
         }
         try {
             byte [] en_data = Hex.decodeHex(encrypttext.toCharArray());
             byte [] data = decrypt(privateKey, en_data);
             return new String(data);
         } catch (Exception ex) {
             LOGGER.error(String.format( "\"%s\" Decryption failed. Cause: %s" , encrypttext, ex.getCause().getMessage()));
         }
         return null ;
     }
     
     /**
      * 使用默认的私钥解密给定的字符串。
      * <p />
      * 若{@code encrypttext} 为 {@code null}或空字符串则返回 {@code null}。
      * 私钥不匹配时，返回 {@code null}。
      *
      * @param encrypttext 密文。
      * @return 原文字符串。
      */
     public static String decryptString(String encrypttext) {
         if (StringUtils.isBlank(encrypttext)) {
             return null ;
         }
         KeyPair keyPair = getKeyPair();
         try {
             byte [] en_data = Hex.decodeHex(encrypttext.toCharArray());
             byte [] data = decrypt((RSAPrivateKey)keyPair.getPrivate(), en_data);
             return new String(data);
         } catch (NullPointerException ex) {
             LOGGER.error( "keyPair cannot be null." );
         } catch (Exception ex) {
             LOGGER.error(String.format( "\"%s\" Decryption failed. Cause: %s" , encrypttext, ex.getMessage()));
         }
         return null ;
     }
     
     /**
      * 使用默认的私钥解密由JS加密（使用此类提供的公钥加密）的字符串。
      *
      * @param encrypttext 密文。
      * @return {@code encrypttext} 的原文字符串。
      */
     public static String decryptStringByJs(String encrypttext) {
         String text = decryptString(encrypttext);
         if (text == null ) {
             return null ;
         }
         return StringUtils.reverse(text);
     }
     
     /** 返回已初始化的默认的公钥。*/
     public static RSAPublicKey getDefaultPublicKey() {
         KeyPair keyPair = getKeyPair();
         if (keyPair != null ) {
             return (RSAPublicKey)keyPair.getPublic();
         }
         return null ;
     }
     
     /** 返回已初始化的默认的私钥。*/
     public static RSAPrivateKey getDefaultPrivateKey() {
         KeyPair keyPair = getKeyPair();
         if (keyPair != null ) {
             return (RSAPrivateKey)keyPair.getPrivate();
         }
         return null ;
     }
}



服务端Action中调用RSAUtils工具类
// Struts2 Action方法中：
// 将公钥的 modulus 和 exponent 传给页面。
// Hex -> apache commons-codec
RSAPublicKey publicKey = RSAUtils.getDefaultPublicKey();
             ActionContext.getContext().put( "modulus" , new String(Hex.encodeHex(publicKey.getModulus().toByteArray())));
             ActionContext.getContext().put( "exponent" , new String(Hex.encodeHex(publicKey.getPublicExponent().toByteArray())));
 
// 页面里，Javascript对明文进行加密：
var modulus = $( '#hid_modulus' ).val(), exponent = $( '#hid_exponent' ).val();
var key = RSAUtils.getKeyPair(exponent, '' , modulus);
pwd1 = RSAUtils.encryptedString(key, pwd1);
pwd2 = RSAUtils.encryptedString(key, pwd2);
 
// 服务器端，使用RSAUtils工具类对密文进行解密
RSAUtils.decryptStringByJs(password1);
世逍遥
关注
专栏目录
RSA对称加密（JS加密，C#、Java解密）
清山博客
09-07 7867
常见的渗透测试会将网站登录时密码使用明文传输视为风险。推荐使用国密算法或者RSA算法对密码进行加密传输。
RSA双向加解密（公钥加密-私钥解密；私钥加密-公钥解密）
qq_42014561的博客
12-20 1万+
RSA私钥加密-公钥解密
JavaScript实现RSA加密和解密
最新发布
weixin_48839391的博客
09-12 679
在JavaScript中，可以使用RSA算法实现数据的加密和解密。下载链接RSA 是一种非对称加密算法，使用一对密钥：公钥 和 私钥。公钥加密：任何人可以使用公钥加密信息。私钥解密：只有拥有私钥的人才能解密加密的信息。私钥签名：私钥可以用于对消息进行签名。公钥验证签名：任何人都可以用公钥验证签名的真实性。通过这个封装好的 rsa-crypto.js 文件，所有与RSA加密和解密相关的操作（密钥生成、密钥存储、加密、解密）都被整理为独立的功能模块。
js rsa java解密_JS-RSA加密解密
weixin_30487899的博客
02-21 1187
在上一篇文章《Java使用RSA加密解密签名及校验》中，用java实现加密解密，但是在实际应用中，如前端页面用户输入的密码传输给后台服务前，需加密，也就是公钥加密，私钥解密。首先把《Java使用RSA加密解密签名及校验》中稍加修改，把公私钥写在代码中来，如下所示：class="java">package com.bijian.study;import org.apache.commons.c...
Java后端生成RSA随机密钥对，并实现前端（app和web）使用公钥加密，后端使用私钥解密
weixin_42023666的博客
04-30 9317
最近在思考网站登录注册时，如何保证用户的密码即使在传输过程中被劫持和破解（我常常喜欢将HTTP和HTTPS比作是押运公司，其功能是护送客户端与第三方服务器之间的交互数据，但是即便是强大如HTTPS，恐怕也不可能百分百保证数据的传输安全吧！况且，这家押运公司还是属于公共的收费服务，假如你托人家运输一箱RMB现金，然后装RMB的是快递用的纸箱，求你此刻的内心忐忑不?假设HTTPS请求仍有...
前端 RSA加密，java解密
Wghhdhjkhj的博客
07-12 602
使用jsencrypt下的encrypt进行加密的话对于短数据能够加密成功，长数据的话就需要进行分段加密，我这边试了一下，前端正确分段解密一次不能低于172个字节（可能跟encrypt方法中的base64转换有关），否则就解密失败（密钥对是1024位），java解密的话最大是128字节，所有解密报错，目前没有找到好的解决方法。// 对编码的字符串转化base64。throw '请输入加密类型,公钥加密或私钥加密';RSA rsa = new RSA("替换问你的私钥","替换为你的公钥");
RSA加密 js客户端加密 java服务端servlet解密
12-05
这个TestRSA项目提供的应该是完整的示例代码，包括JS端的加密函数和Java端的解密Servlet，可以直接部署运行，帮助开发者理解和实践RSA加密的客户端-服务器通信。通过分析和运行这些代码，开发者可以深入理解RSA加密...
RSA加密解密 JS加密 JAVA解密 【完美版】
12-12
经过本人修改，简化并完善了别人的代码，使其更加的容易理解和学习！ 此为一个完整的项目，...功能：服务端随机生成密钥，JS用公钥加密，服务端用私钥解密。用到的JS加密文件是从官网下载的最新版，速度快，稳定性好！
RSA浏览器加密，服务端解密
04-23
在这个场景中，客户端（浏览器）通常会使用JavaScript库，如`jsencrypt.js`，来实现RSA加密。`jsencrypt.js`是一个轻量级的JavaScript库，它提供了简单易用的接口来进行RSA加密。用户可以在浏览器中加载这个库，然后...
js RSA加密 java RSA解密
weixin_32691913的博客
07-21 119
JS RSA加密与Java RSA解密：入门指南 作为一名开发者，你可能会在Web开发中遇到需要对数据进行加密和解密的情况。RSA加密算法是一种常用的非对称加密算法，它在很多安全通信场景中都有应用。本文将指导你如何使用JavaScript进行RSA加密，以及如何使用Java进行RSA解密。 流程概览 首先，我们通过一个表格...
JavaScript学习 -- RSA算法应用实例及公钥私钥的生成方法
weixin_41489908的博客
08-03 1634
通过生成的密钥对，我们可以进行数据加密和解密操作，确保数据的安全性和保密性。接下来，我们实例化另一个JSEncrypt对象，并使用setPublicKey()和setPrivateKey()方法设置公钥和私钥。通过以上示例，您可以在JavaScript中使用RSA算法进行加密和解密操作，并自动生成公钥和私钥。需要注意的是，生成的公钥和私钥应妥善保管，确保其安全性和保密性，以防止数据泄露和非法使用。本文将介绍如何在JavaScript中使用RSA算法，并提供一个实际的案例，同时也会说明如何生成公钥和私钥。
unity C# 中关于字符串加密
qq_33503206的博客
03-20 255
【代码】 unity C# 中关于字符串加密。
使用C#实现的软件验证加密许可证功能
tomicode的博客
07-15 1008
C# 加密 解密 验证许可证逻辑
前端使用jsencrypt实现RSA公钥解密
蒋固金（jianggujin）的专栏
05-19 2310
最近需要在前端实现一个功能，后端对数据使用RSA私钥加密后，前端使用公钥对数据进行解密，在前端项目中使用jsencrypt库进行实现，但是jsencrypt库在解密时不支持使用公钥解密，网上有一些教程是通过修改源代码的方式进行实现，在实际阅读源码之后发现不需要这么麻烦，可以直接在调用的时候做些调整。废话不多说，直接上代码。方法即可实现公钥解密，如果想要全局生效的话，这里提供一个思路就是调整代码直接对。的原型链方法进行修改。
JavaScript实现前端rsa公钥加密，后端Java私钥进行解密
yinbenyang的专栏
08-22 5625
JavaScript实现前端rsa公钥加密，后端Java私钥进行解密 rsa进行前端js加密，后端java解密时需要注意，由后端先生成一对公私密钥对，然后将公钥传给前端，私钥后端保存，待下次前端请求后，用私钥解密经过公钥加密后的密文。 1、前端加密js，encrypt.js下载地址 2、需要使用加密的页面引入加密js <script src="../../../hs/js/work...
使用RSA非对称加密完成JavaScript前端分段加密和java后端分段解密
热门推荐
MrSpirit的博客
01-15 1万+
前言最近研究了RSA非对称加密，关于什么是RSA，网上各种文章一搜一大把，但是关于如何使用RSA完成前后端的组合加密解密，东西就非常少了，并且由于RSA的特性，一个1024位的密钥只能加密117位字节数据，当数据量超过117位字节的时候，程序就会抛出异常，下面就给出如何完成前端RSA分段解密和后端RSA分段解密。准备前端RSA的JS类库jsencrypt-master后端java的RSA辅助方法类...
前端JS RSA加密，后端JAVA RSA解密
博客
05-11 1552
需求描述：用户网页登录，使用RSA对密码进行加密；加密串传到后台，后端查询用户注册的密码（RSA加密后的），对两个加密串RSA解密，解密后对比密码是否相同。 参考 https://github.com/travist/jsencrypt https://www.jianshu.com/p/e19dc0b4fe78 https://blog.csdn.net/weixin_43652442/article/details/87875491 JS加密、JAVA解密，有两条路： 根据jsencrypt步骤，
RSA前端JS加密，后端JAVA解密实现
ccecwg的专栏
01-20 1342
用RSA非对称加密方式实现。后台生成rsa密钥对，然后在页面设置rsa公钥，提交时用公钥加密密码，生成的密文传到后台，后台再用私钥解密，获取密码明文。 这样客户端只需要知道rsa加密方式和公钥，前台不知道私钥是无法解密的，此解决方案还是相对比较安全的。 需要到http://www.bouncycastle.org下载bcprov-jdk16-140.jar文件。 缺陷：由于进行的都是大数计算
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值