Android和JAVA后台实现RSA加解密

最新推荐文章于 2024-07-21 11:25:24 发布
最新推荐文章于 2024-07-21 11:25:24 发布
阅读量531 收藏 4
点赞数 1
分类专栏： 加密 文章标签： rsa android java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40525756/article/details/109649435
版权

先给大家贴上代码先实现功能吧，等有空了再和大家分享的详细些

##安卓端代码

import android.util.Base64;
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;


/**
 * author:  WeiFeiChen
 * date:    2020/11/6.
 * describe: RSA加解密
 *
 */
public class RSAUtils {
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;
    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    public static final String KEY_ALGORITHM = "RSA";
    private static KeyFactory keyFactory = null;

    static {
        try {
            keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }

    public static Key getPrivateKeyFromBase64KeyEncodeStr(String keyStr) {
        byte[] keyBytes = Base64.decode(keyStr, Base64.NO_WRAP);
        // 取得私钥
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
        Key privateKey = null;
        try {
            privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return privateKey;
    }

    /**
     * 获取base64加密后的字符串的原始公钥
     *
     * @param keyStr
     * @return
     */
    public static Key getPublicKeyFromBase64KeyEncodeStr(String keyStr) {
        byte[] keyBytes = Base64.decode(keyStr, Base64.NO_WRAP);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        Key publicKey = null;
        try {
            publicKey = keyFactory.generatePublic(x509KeySpec);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return publicKey;
    }

    /**
     * 公钥加密
     *
     * @param data 待加密数据
     * @param key  密钥
     * @return byte[] 加密数据
     */
    public static String encryptPublicKey(byte[] data, String key) throws Exception {
        //解密密钥
        byte[] keyBytes = Base64.decode(key, Base64.NO_WRAP);
        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

        //数据加密
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//Android端使用
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        byte[] bytes = cipher.doFinal(data);
        return new String(Base64.encode(bytes, Base64.NO_WRAP));
    }

    /**
     * 私钥解密
     *
     * @param data       待解密数据
     * @param privateKey 密钥
     * @return byte[] 解密数据
     */
    public static String decryptPrivateKey(String data, String privateKey) throws Exception {


        Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKey);
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//Android端使用
        cipher.init(Cipher.DECRYPT_MODE, decodePrivateKey);

        byte[] encryptedData = Base64.decode(data, Base64.NO_WRAP);
        byte[] decodedData = cipher.doFinal(encryptedData);
        String decodedDataStr = new String(decodedData);
        return decodedDataStr;
    }

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 使用公钥进行分段加密
     *
     * @param dataStr 要加密的数据
     * @return 公钥base64字符串
     * @throws Exception
     */
    public static String encryptByPublicKey(String dataStr, String publicKey)
            throws Exception {
        byte[] data = dataStr.getBytes();
        // 对公钥解密
        Key decodePublicKey = getPublicKeyFromBase64KeyEncodeStr(publicKey);
        // 对数据加密
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//Android端使用
        cipher.init(Cipher.ENCRYPT_MODE, decodePublicKey);
        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();
        String encodedDataStr = new String(Base64.encode(encryptedData, Base64.NO_WRAP));

        return encodedDataStr;
    }

    /**
     * 使用私钥进行分段解密
     *
     * @param dataStr 使用base64处理过的密文
     * @return 解密后的数据
     * @throws Exception
     */
    public static String decryptByPrivateKey(String dataStr, String privateKey)
            throws Exception {

        byte[] encryptedData = Base64.decode(dataStr, Base64.NO_WRAP);

        Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKey);

        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");//Android端使用
        cipher.init(Cipher.DECRYPT_MODE, decodePrivateKey);
        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();
        String decodedDataStr = new String(decryptedData, "utf-8");
        return decodedDataStr;
    }

}

##Java后台代码

package com.gbss.common.utils;

import java.io.ByteArrayOutputStream;
import java.security.Key;
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.SecureRandom;
import java.security.Security;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import javax.crypto.Cipher;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**
 * RSA加解密
 * @author 吴帅
 * created at 2017/6/8
 */
public class RSAUtils {
    
    /** *//** 
     * RSA最大加密明文大小 
     */  
    private static final int MAX_ENCRYPT_BLOCK = 117;  
      
    /** *//** 
     * RSA最大解密密文大小 
     */  
    private static final int MAX_DECRYPT_BLOCK = 128; 

    public static final String KEY_ALGORITHM = "RSA";//RSA/ECB/PKCS1Padding
    
    private static KeyFactory keyFactory = null;

    static {
        try {
            keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 获取base64加密后的字符串的原始私钥
     * @param keyStr
     * @return
     */
    public  static Key getPrivateKeyFromBase64KeyEncodeStr(String keyStr) {
        byte[] keyBytes = Base64.getDecoder().decode(keyStr);
        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        Key privateKey=null;
        try {
            privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return privateKey;
    }

    /**
     * 获取base64加密后的字符串的原始公钥
     * @param keyStr
     * @return
     */
    public static Key getPublicKeyFromBase64KeyEncodeStr(String keyStr) {
        byte[] keyBytes = Base64.getDecoder().decode(keyStr);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        Key publicKey = null;
        try {
            publicKey = keyFactory.generatePublic(x509KeySpec);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return publicKey;
    }
    

    /**
     * 公钥加密方法
     * @param dataStr 要加密的数据
     * @param dataStr 公钥base64字符串
     * @return 加密后的base64字符串
     * @throws Exception
     */
    public static String encryptPublicKey(String dataStr, String publicKey) throws Exception{
        //要加密的数据
        System.out.println("要加密的数据:"+dataStr);
        byte[] data = dataStr.getBytes();
        // 对公钥解密
        Key decodePublicKey = getPublicKeyFromBase64KeyEncodeStr(publicKey);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, decodePublicKey);
        byte[] encodedData = cipher.doFinal(data);
        String encodedDataStr = new String(Base64.getEncoder().encode(encodedData));
        System.out.println("公钥加密后的数据:"+encodedDataStr);
        return encodedDataStr;
    }
    
    /**
     * 私钥解密
     */
    public static String decrypt(String dataStr, String privateKey) throws Exception{
        //要加密的数据
        System.out.println("要解密的数据:"+dataStr);
        //对私钥解密
        Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKey);
        //Log.i("机密",""+decodePrivateKey);
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, decodePrivateKey);
        byte[] encodedData = Base64.getDecoder().decode(dataStr);
        byte[] decodedData = cipher.doFinal(encodedData);
        String decodedDataStr = new String(decodedData,"utf-8");
        System.out.println("私钥解密后的数据:"+decodedDataStr);
        return decodedDataStr;
    }
    
    /**
     * 使用公钥进行分段加密
     * @param dataStr 要加密的数据
     * @return 公钥base64字符串
     * @throws Exception
     */
    public static String encryptByPublicKey(String dataStr, String publicKey)  
            throws Exception {  
        //要加密的数据
        System.out.println("要加密的数据:"+dataStr);
        byte[] data = dataStr.getBytes();
        // 对公钥解密
        Key decodePublicKey = getPublicKeyFromBase64KeyEncodeStr(publicKey);
        
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        // 对数据加密  
        String s = keyFactory.getAlgorithm();
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.ENCRYPT_MODE, decodePublicKey);  
        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(); 
        String encodedDataStr = new String(Base64.getEncoder().encode(encryptedData));
        System.out.println("公钥加密后的数据:"+encodedDataStr);
        return encodedDataStr;  
    }

    /**
     * 使用私钥进行分段解密
     * @param dataStr 使用base64处理过的密文
     * @return 解密后的数据
     * @throws Exception
     */
    public static String decryptByPrivateKey(String dataStr, String privateKey)  
            throws Exception {
        byte[] encryptedData = Base64.getDecoder().decode(dataStr);
        
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKey);
        
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        //Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.DECRYPT_MODE, decodePrivateKey);  
        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();  
        String decodedDataStr = new String(decryptedData,"utf-8");
        System.out.println("私钥解密后的数据:"+decodedDataStr);
        return decodedDataStr;  
    } 
    
    /**
     * 生成公私钥
     */
    public static void genKeyPair() throws NoSuchAlgorithmException {  
    	 Security.addProvider(new BouncyCastleProvider());
         KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
         generator.initialize(1024, new SecureRandom());
         KeyPair pair = generator.generateKeyPair();
         PublicKey pubKey = pair.getPublic();
         PrivateKey privKey = pair.getPrivate();
         byte[] pk = pubKey.getEncoded();
         byte[] privk = privKey.getEncoded();
         String strpk = new String(Base64.getEncoder().encode(pk));
         String strprivk = new String(Base64.getEncoder().encode(privk));

         System.out.println("公钥Base64编码:" + strpk);
         System.out.println("私钥Base64编码:" + strprivk);
	}  
    
    public static void main(String[] args) throws Exception {
    	
//    	String pubKey = "公钥";
//    	String prvKey = "私钥";
//    	Map<String, String> data = new HashMap<String, String>();
//    	data.put("account","111");
//    	data.put("password","JJHH");
//    	System.out.println("-->加密前：" + data);
//    	
//    	String enData = RSAUtils.encryptByPublicKey(JacksonUtils.obj2json(data), pubKey);
//    	System.out.println("-->加密后：" + enData);
//    	
//    	String deData = RSAUtils.decryptByPrivateKey(enData, prvKey);
//    	System.out.println("-->解密后：" + deData);
//    	genKeyPair();
    }
}
HiYoungPeople
关注
专栏目录
android 与 java后端 rsa 加密解密互通 （整理修改别人的）
piaomiaozaitianya的博客
12-04 658
后端工具 package com.kingyon.backend.snake; import java.io.ByteArrayOutputStream; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey; import j
java android rsa加密解密_Android RSA加密解密
weixin_35644453的博客
03-04 616
转载 http://blog.csdn.net/bbld_/article/details/38777491RSA是目前最有影响力的公钥加密算法，该算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困 难，因此可以将乘积公开作为加密密钥，即公钥，而两个大素数组合成私钥。公钥是可发布的供任何人使用，私钥则为自己所有，供解密之用。关于RSA其它需要了解的知识...
java android rsa加密解密_Android中的RSA加密解密
weixin_35367645的博客
02-21 525
我正在爲Android中的RSA加密和解密實施演示。我可以很好地執行加密，但在解密中，我得到一個例外：>>java.security.InvalidKeyException: unknown key type passed to RSA。Android中的RSA加密解密KeyPairGenerator kpg;KeyPair kp;PublicKey publicKey;Private...
Android RSA 加解密
最新发布
xingfuyisheng的专栏
07-21 921
RSA是一种常用的非对称加密算法，所谓非对称加密是指使用一对密钥（公钥和私钥）进行加密和解密，公钥人人都可以获得，用于加密数据，私钥保存在服务器中，用于解密数据。加密解密过程如下：使用RSA进行加密解密，其优点是非常不容易破解，缺点是和对称加密（如AES）相比，加密速度较慢。因此，实际使用中，常常将对称加密和非对称加密结合使用，即使用非对称加密协商对称加密的密钥，使用对称加密密钥加密传输内容。
java中RSA加解密的实现，移动应用开发app
m0_64319298的博客
11-23 252
模 @param exponent 指数 @return */ public static RSAPublicKey getPublicKey(String modulus, String exponent) { try { BigInteger b1 = new BigInteger(modulus); BigInteger b2 = new BigInteger(exponent); KeyFactory keyFactory = KeyFactory...
Android RSA加密 在服务端进行RSA解密不成功的问题
张少飞的CSDN
12-15 5730
如题，原因是因为，加密标准的原因。"RSA/ECB/PKCS1Padding" 与'RSA"    在ANdroid中应该使用这个标准 Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); 在服务端使用这个标准 Cipher cipher = Cipher.getInstance("RSA");
android rsa 私钥加密解密,Android网络数据传输安全——实现RSA公钥加密私钥解密...
weixin_29233333的博客
06-03 1257
一，整体流程后台生成一个RSA秘钥对，包括公钥和私钥后台将公钥字符串下发给客户端，然后客户端用此公钥生成一个RSAPublicKey对象，再将手机号密码等数据用此对象加密，客户端将加密的数据发送给后台，后台将加密的数据用私钥解密。image.png二，公私钥你可以利用工具一键生成密钥对访问支付宝官网，进入如下页面，该页面的URL：https://docs.open.alipay.com/291/1...
安卓RSA加密和解密，和后台能够进行数据互通的算法
11-17
android平台的RSA加密和解密算法，和后台JAVA加密和解密算法有所不同，能够和后台进行数据互通。完美解决后台的加密数据，android平台解密后乱码问题，也不会出现android平台加密密文，后台解析出现乱码问题
Android RSA加密解密
热门推荐
Rocko's blog - http://rocko.xyz
08-23 2万+
RSA是目前最有影响力的公钥加密算法。在项目开发中对于一些比较敏感的信息需要对其进行加密处理，我们就可以使用RSA这种非对称加密算法来对数据进行加密处理，保证数据的安全。
Android_Java_RSA加密
06-23
Android与Java后台交互时采用RSA加密能有效保护数据安全，防止数据在传输过程中被窃取。理解RSA的工作原理以及在Android中实现的步骤，对于开发安全的移动应用至关重要。同时，需要注意密钥管理、数据完整性和网络...
android RSA实现
hasayaqimomo的专栏
11-19 182
客服端：android 服务端：java android： Base64Utils.java import java.io.UnsupportedEncodingException; public class Base64Utils { private static char[] base64EncodeChars = new char[] {'A', 'B...
android java加密解密_Android RSA加密解密
weixin_39775976的博客
02-21 253
需求在Android上实现RSA 2048 PKCS#1加密，秘钥不能放在Java层(其实公钥被别人看了也没啥吧？)。几个思路：所有加密的程序都在native层。秘钥在Native层，加密在Java实现。所有都在Java实现。(不满足公钥不能放在Java层的要求)RSA加密RSA是一种非对称加密算法。通常的使用流程是A生成一对秘钥，公钥和私钥，而这对秘钥有这样的特性：使用公钥加密的数据,利用私钥进...
JAVA（Android）,PHP,IOS三平台RSA加解密互通算法
lsxf_xin的专栏
02-14 1万+
JAVA（Android）,PHP,IOS三平台RSA加解密互通算法RSA算法RSA公开密钥密码体制。所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，而解密密钥（即秘密密钥）SK是需要保密的。加密算法E和解密算法D也都是公开的。虽然解密密钥SK是由公开密钥PK决定的...
Android平台和java平台 DES、3DES、RSA加密解密互通程序及其不能互通的原因
Hank-Android
07-21 1983
网上的demo一搜一大堆，但是，基本上都是一知半解（包括我）。为什么呢？我在尝试分别在两个平台加密的时候，竟然发现Android DES 加密和java DES加密的程序不能互通。就是加密的结果不一样，更不要说Android平台的加密输入作为java DES的解密输出了。这样的话，客户端和服务器端就不能进行通信了。我网上之前也发帖子问了不少人，但是回答都不满意。 今天部门的另外一个同事跟我说
Android平台和java平台 DES加密解密互通程序及其不能互通的原因
07-15 281
前言：最近一直在搞DES加解密传文件数据流。在网上搜了N多资料，但是总是不太理想。 最后找到了这篇博文：http://www.oschina.net/question/54100_35081  确实不错，启发很大。   不多说贴个Android加解密的工具类： package com.example.cryptographic; import java.io.Bu
Android端RSA加密，后端无法解密的情况
倚栏静望的博客
09-12 1671
原因是因为，加密标准：“RSA/ECB/PKCS1Padding” 与’RSA"， 在Android中应该使用这个标准 Cipher cipher = Cipher.getInstance(“RSA/ECB/PKCS1Padding”); 在服务端使用这个标准 Cipher cipher = Cipher.getInstance(“RSA”); 因此 Android端加密应使用Cipher cip...
Android RSA数据加密与Java服务端RSA私钥解密出错问题
weixin_34019929的博客
06-03 665
为什么80%的码农都做不了架构师？>>> ...
java android rsa加密解密_android – 外包RSA加密和解密的问题
weixin_35516624的博客
02-21 138
我有RSA加密和解密的问题.我正在开发android,并希望外包RSA加密和解密.在我尝试外包之前,我的源代码运行良好.我创建了一个私钥和公钥,并将其保存为private.key和public.key.该错误是由此方法引起的ClassNotFoundException：public Key getPrivateKey(){try {InputStream fis = activity.getRes...
Java RSA加解密实现及注意事项
"Java RSA加密解密方法及注意事项" ...Java中的RSA加密解密涉及到密钥对的生成、密钥的编码和传输、数据的分块处理以及错误处理等多个环节。理解这些知识点对于在实际项目中安全地使用RSA加密至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值