Qt openssl rsa 加密解密

最新推荐文章于 2023-05-27 20:35:25 发布
最新推荐文章于 2023-05-27 20:35:25 发布
阅读量4.5k 收藏 26
点赞数 4
分类专栏： qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010559682/article/details/90479150
版权 
最近在处理加密问题，需要用到数字签名，查询资料得知采用rsa加密基本安全。关于rsa加密算法，网络上关于这类说明比较多。其实关于C++ + openssl + rsa的相关代码比较多，要么要积分，要么写的不是qt方面的。今天抽空整理出qt + openssl + rsa相关加密函数及实现。
首先在实现功能的时候出现的一些问题及解决方法。
1、采用openssl-1_1_0h版本
2、qt pro文件中增加动态库关联，这里是把openssl安装文件中的include和lib文件拷贝至qt项目目录下。
   INCLUDEPATH += ./include
   LIBS += libcrypto.lib \   
           libssl.lib 
3、openssl有两种生成key的方式，一种是通过openssl命令生成；一种是通过调用接口用代码生成。两者生成的私钥格式一致，
   但是公钥格式存在区别，从而导致调用接口不一样。
   代码生成的key标题为 -----BEGIN RSA PUBLIC KEY----- ，调用接口PEM_read_bio_RSAPublicKey；
   命令生成的key标题为 -----BEGIN PUBLIC KEY----- ，调用接口 PEM_read_bio_RSA_PUBKEY
4、若通过命令生成的key，拷贝至项目中使用时，需要注意格式，标题和每一行后的换行（/n）必须都带上。
5、由于传输的key都是QString类型，需要转化为uchar*。
   错误的方式： uchar* pPriKey = (uchar*)strPriKey.toUtf8().data();  
   正确的方式： QByteArray priKeyArry = strPriKey.toUtf8();
               uchar* pPriKey = (uchar*)priKeyArry.data(); 
6、代码中为方便查看生成的key，统一都转化base64格式，但是在解密的时候需要转化为uchar*。

这里仅处理小于128字节的数据加密，后续把分片加密整理出来。

代码实现如下：

#include <QDebug>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>

// define rsa public key
#define BEGIN_RSA_PUBLIC_KEY    "BEGIN RSA PUBLIC KEY"
#define BEGIN_PUBLIC_KEY        "BEGIN PUBLIC KEY"
#define KEY_LENGTH              1024                        // 密钥长度
 
class rsa
{
public:    
/**     
* @brief createRsaKey 生成秘钥对     
* @param strPubKey 公钥     
* @param strPriKey 私钥     
* @return 状态     
*/
static bool createRsaKey (QString& strPubKey, QString& strPriKey);    
/**     
* @brief rsa_pri_encrypt 私钥加密     
* @param strClearData 明文     
* @param strPriKey 私钥     
* @return 加密后数据(base64格式)     
*/    
static QString rsa_pri_encrypt_base64 (const QString& strClearData, const QString& strPriKey);    
/**
* @brief rsa_pub_decrypt 公钥解密    
* @param strDecrypt 待解密数据(base64格式)     
* @param strPubKey 公钥钥     
* @return 明文     
*/    
static QString rsa_pub_decrypt_base64 (const QString& strDecryptData, const QString& strPubKey);    
/**     
* @brief rsa_pub_encrypt 公钥加密     
* @param strClearData 明文     
* @param strPubKey 私钥     
* @return 加密后数据(base64格式)     
*/    
static QString rsa_pub_encrypt_base64 (const QString& strClearData, const QString& strPubKey);    
/**     
* @brief rsa_pri_decrypt 私钥解密     
* @param strDecrypt 待解密数据(base64格式)     
* @param strPriKey 私钥     
* @return 明文     
*/    
static QString rsa_pri_decrypt_base64 (const QString& strDecryptData, const QString& strPriKey);    
/**< 测试 */    
static void test ();
};

#endif // RSA_H
#include "rsa.h"
/** 
* @brief createRsaKey 生成秘钥对 
* @param strPubKey 公钥 
* @param strPriKey 私钥 
* @return 成功状态 
*/
bool rsa::createRsaKey (QString& strPubKey, QString& strPriKey)
{    
     RSA *pRsa = RSA_generate_key(KEY_LENGTH, RSA_3, NULL, NULL);    
     if ( !pRsa ){       
         return false; 
     }
     BIO *pPriBio = BIO_new(BIO_s_mem());    
     PEM_write_bio_RSAPrivateKey(pPriBio, pRsa, NULL, NULL, 0, NULL, NULL);    
     BIO *pPubBio = BIO_new(BIO_s_mem());   
     PEM_write_bio_RSAPublicKey(pPubBio, pRsa);    
     // 获取长度   
     size_t nPriKeyLen = BIO_pending(pPriBio);   
     size_t nPubKeyLen = BIO_pending(pPubBio);    
     // 密钥对读取到字符串    
     char* pPriKey = new char[nPriKeyLen];    
     char* pPubKey = new char[nPubKeyLen];    
     BIO_read(pPriBio, pPriKey, nPriKeyLen);     
     BIO_read(pPubBio, pPubKey, nPubKeyLen);    
     // 存储密钥对    
     strPubKey = QByteArray(pPubKey, nPubKeyLen);    
     strPriKey = QByteArray(pPriKey, nPriKeyLen);    
     // 内存释放     
     RSA_free(pRsa);    
     BIO_free_all(pPriBio);    
     BIO_free_all(pPubBio);    
     delete pPriKey;    
     delete pPubKey;    
     return true;
}

/**
 * @brief rsa_pri_encrypt 私钥加密
 * @param strClearData 明文
 * @param strPriKey 私钥
 * @return 加密后数据(base64格式)
 */
QString rsa::rsa_pri_encrypt_base64 (const QString& strClearData, const QString& strPriKey)
{    
    QByteArray priKeyArry = strPriKey.toUtf8();    
    uchar* pPriKey = (uchar*)priKeyArry.data();    
    BIO* pKeyBio = BIO_new_mem_buf(pPriKey, strPriKey.length());    
    if (pKeyBio == NULL){        
        return "";    
    }    
    RSA* pRsa = RSA_new();    
    pRsa = PEM_read_bio_RSAPrivateKey(pKeyBio, &pRsa, NULL, NULL);    
    if ( pRsa == NULL ){        
         BIO_free_all(pKeyBio);        
         return "";    
    }    
    int nLen = RSA_size(pRsa);    
    char* pEncryptBuf = new char[nLen];    
    memset(pEncryptBuf, 0, nLen);    
    QByteArray clearDataArry = strClearData.toUtf8();    
    int nClearDataLen = clearDataArry.length();     
    uchar* pClearData = (uchar*)clearDataArry.data();    
    int nSize = RSA_private_encrypt(nClearDataLen,                     
                                    pClearData,                                    
                                    (uchar*)pEncryptBuf,                                    
                                    pRsa,                                    
                                    RSA_PKCS1_PADDING);    
    QString strEncryptData = "";    
    if ( nSize >= 0 ){        
         QByteArray arry(pEncryptBuf, nSize);        
         strEncryptData = arry.toBase64();    
    }    
    // 释放内存    
    delete pEncryptBuf;    
    BIO_free_all(pKeyBio);    
    RSA_free(pRsa);   
    return strEncryptData;
}

/**
 * @brief rsa_pub_decrypt 公钥解密
 * @param strDecrypt 待解密数据(base64格式)
 * @param strPubKey 公钥
 * @return 明文
 */
QString rsa::rsa_pub_decrypt_base64(const QString& strDecryptData, const QString& strPubKey)
{    
    QByteArray pubKeyArry = strPubKey.toUtf8();
    uchar* pPubKey = (uchar*)pubKeyArry.data();
    BIO* pKeyBio = BIO_new_mem_buf(pPubKey, strPubKey.length());
    if (pKeyBio == NULL){
        return "";
    }

    RSA* pRsa = RSA_new();
    if ( strPubKey.contains(BEGIN_RSA_PUBLIC_KEY) ){
        pRsa = PEM_read_bio_RSAPublicKey(pKeyBio, &pRsa, NULL, NULL);
    }else{
        pRsa = PEM_read_bio_RSA_PUBKEY(pKeyBio, &pRsa, NULL, NULL);
    }

    if ( pRsa == NULL ){
        BIO_free_all(pKeyBio);
        return "";
    }
    int nLen = RSA_size(pRsa);
    char* pClearBuf = new char[nLen];
    memset(pClearBuf, 0, nLen);
    //解密
    QByteArray decryptDataArry = strDecryptData.toUtf8();
    decryptDataArry = QByteArray::fromBase64(decryptDataArry);
    int nDecryptDataLen = decryptDataArry.length();
    uchar* pDecryptData = (uchar*)decryptDataArry.data();
    int nSize = RSA_public_decrypt(nDecryptDataLen,
                                   pDecryptData,
                                   (uchar*)pClearBuf,
                                   pRsa,
                                   RSA_PKCS1_PADDING);
    QString strClearData = "";
    if ( nSize >= 0 ){
        strClearData = QByteArray(pClearBuf, nSize);
    }

    // 释放内存
    delete pClearBuf;
    BIO_free_all(pKeyBio);
    RSA_free(pRsa);
    return strClearData;
}

/**
 * @brief rsa_pub_encrypt 公钥加密
 * @param strClearData 明文
 * @param strPubKey 私钥
 * @return 加密后数据(base64格式)
 */
QString rsa::rsa_pub_encrypt_base64 (const QString& strClearData, const QString& strPubKey)
{
    QByteArray pubKeyArry = strPubKey.toUtf8();
    uchar* pPubKey = (uchar*)pubKeyArry.data();
    BIO* pKeyBio = BIO_new_mem_buf(pPubKey, pubKeyArry.length());
    if (pKeyBio == NULL){
        return "";
    }
    RSA* pRsa = RSA_new();
    if ( strPubKey.contains(BEGIN_RSA_PUBLIC_KEY) ){
        pRsa = PEM_read_bio_RSAPublicKey(pKeyBio, &pRsa, NULL, NULL);
    }else{
        pRsa = PEM_read_bio_RSA_PUBKEY(pKeyBio, &pRsa, NULL, NULL);
    }
    if ( pRsa == NULL ){
        BIO_free_all(pKeyBio);
        return "";
    }

    int nLen = RSA_size(pRsa);
    char* pEncryptBuf = new char[nLen];
    memset(pEncryptBuf, 0, nLen);

    QByteArray clearDataArry = strClearData.toUtf8();
    int nClearDataLen = clearDataArry.length();
    uchar* pClearData = (uchar*)clearDataArry.data();
    int nSize = RSA_public_encrypt(nClearDataLen,
                                   pClearData,
                                   (uchar*)pEncryptBuf,
                                   pRsa,
                                   RSA_PKCS1_PADDING);
    QString strEncryptData = "";
    if ( nSize >= 0 ){
        QByteArray arry(pEncryptBuf, nSize);
        strEncryptData = arry.toBase64();
    }
    // 释放内存
    delete pEncryptBuf;
    BIO_free_all(pKeyBio);
    RSA_free(pRsa);
    return strEncryptData;
}

/** 
 * @brief rsa_pri_decrypt 私钥解密
 * @param strDecrypt 待解密数据(base64格式) 
 * @param strPriKey 私钥
 * @return 明文
 */
QString rsa::rsa_pri_decrypt_base64(const QString& strDecryptData, const QString& strPriKey)
{
    QByteArray priKeyArry = strPriKey.toUtf8();
    uchar* pPriKey = (uchar*)priKeyArry.data();
    BIO* pKeyBio = BIO_new_mem_buf(pPriKey, priKeyArry.length());
    if (pKeyBio == NULL){
        return "";
    } 
    RSA* pRsa = RSA_new();
    pRsa = PEM_read_bio_RSAPrivateKey(pKeyBio, &pRsa, NULL, NULL);
    if ( pRsa == NULL ){
        BIO_free_all(pKeyBio);
        return "";
    }
    int nLen = RSA_size(pRsa);
    char* pClearBuf = new char[nLen];
    memset(pClearBuf, 0, nLen);

    //解密
    QByteArray decryptDataArry = strDecryptData.toUtf8();
    decryptDataArry = QByteArray::fromBase64(decryptDataArry);
    int nDecryptDataLen = decryptDataArry.length(); 
    uchar* pDecryptData = (uchar*)decryptDataArry.data(); 
    int nSize = RSA_private_decrypt(nDecryptDataLen,
                                    pDecryptData,
                                    (uchar*)pClearBuf,
                                    pRsa,
                                    RSA_PKCS1_PADDING);
    QString strClearData = "";
    if ( nSize >= 0 ){
        strClearData = QByteArray(pClearBuf, nSize);
    }
    // 释放内存
    delete pClearBuf;
    BIO_free_all(pKeyBio);
    RSA_free(pRsa);
    return strClearData;
}

void rsa::test()
{
    /**< rsa private/public key 若从文件中拷贝出来，需要注意保存元先文件格式，即换行符需要带上，包括最后一行的换行符 */
    QString strPriKey = "";   
    QString strPubKey = "";
    /** 
     *  用代码生成的key与openssl命令生成的key区别：
     *  1、代码生成key，标题为 -----BEGIN RSA PUBLIC KEY-----,openssl命令生成key, 标题为 -----BEGIN PUBLIC KEY-----
     *  2、获取RSA函数不同，代码生成key，用PEM_read_bio_RSAPublicKey，openssl命令生成key，用PEM_read_bio_RSA_PUBKEY
    */
    createRsaKey(strPubKey, strPriKey);
    qDebug() << strPubKey << endl;
    qDebug() << strPriKey << endl;
    qDebug() << "private key encrypt, public key decrypt";
    QString strClear = "hello";
    QString strEncryptData = rsa_pri_encrypt_base64 (strClear, strPriKey);
    qDebug() << strEncryptData;
    QString strClearData = rsa_pub_decrypt_base64 (strEncryptData, strPubKey);
    qDebug() << strClearData;
    qDebug() << "public key encrypt, private key decrypt"; 
    strEncryptData = rsa_pub_encrypt_base64 (strClear, strPubKey);
    qDebug() << strEncryptData; 
    strClearData = rsa_pri_decrypt_base64 (strEncryptData, strPriKey);
    qDebug() << strClearData;
}
 
 
u010559682
关注
  • 4
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Qt使用第三方库openssl进行RSA加密解密操作详解
小米的修行之路
06-08 1324
qt使用openssl进行rsa加密解密
Qt对二进制文件进行加密及解密操作
最新发布
qq_43517257的博客
06-08 941
在工作中可能会做一些二进制文件加密及解密的任务，比如说仪器的时序指令bin文件。
Qt实现RSA加解密
07-24
利用Qt框架实现RSA加解密，使用的开源库是openssl，该开源库是一套完整的密码学库，该资源仅供大家学习
QT使用Openssl实现RSA加解密
未来的博客
12-03 6082
前言： RSA是目前最有影响力和最常用的加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准。这是一种非对称密码算法，所谓非对称，就是指该算法需要一对公密钥，使用其中一个加密，则需要用另一个才能解密。密钥越长，它就越难破解。根据已经披露的文献，目前被破解的最长RSA密钥是768个二进制位。也就是说，长度超过768位的密钥，还无法破解（至少没人公开宣布...
QT使用openssl实现RSA加解密
weixin_42098322的博客
05-26 3146
使用openssl生成公私钥，随后用QT对相应的信息进行RSA加解密
QT中用openssl做rsa加密解密
热门推荐
yajunsun的专栏
12-27 1万+
首先，你得安装openssl，去官网下载最新版本就行， 安装完成后用命令行打开到openssl安装目录，先生成私钥，私钥保存到此目录的private.pem中，密钥长度2048位，然后再从私钥中提取公钥，公钥保存到此目录的public.pem中，当然，文件名称自己定。 按照上述命令生成好私钥公钥文件后，直接编辑打开把密钥复制出来用，或者在程序中直接用公钥私钥文件加载RSA对象。
使用Qt调用openssl 从内存中读取私钥对RSA密文进行解密
d_a_r_k的专栏
12-12 2019
头文件 #ifndef CTOOLS_H #define CTOOLS_H #include #include #include "openssl/rsa.h" #include "openssl/pem.h" #include #include "lusb0_usb.h" #include #include #include class CTools { public:
C++使用Openssl进行RSA加密解密及签名验签功能（SHA256）
09-19
本文将深入探讨如何使用OpenSSL库在C++中实现RSA加密、解密以及签名和验签功能，特别关注SHA256WithRSA这一安全强度更高的签名方法。 首先，RSA的核心原理是基于大整数因子分解的困难性。它包含一对密钥，即公钥和...
Qt利用OpenSSl实现RSA数字签名
07-05
接着，导入必要的头文件，例如`<openssl/rsa.h>`、`<openssl/pem.h>`等，然后在Qt项目中编写代码来生成RSA密钥对。这通常包括以下步骤： 1. 初始化OpenSSL库：`OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS |...
QT RSA 公钥加密 公钥解密 私钥加密 私钥解密 分段加密 分段解密
05-25
推荐在线完成RSA加密解密的网站：https://the-x.cn/cryptography/Rsa.aspx 可以用VS打开.sln文件也可以用QT编辑器打开.pro文件 文件中虽然有RSATool.cpp的文件，但是程序中使用动态库的形式引入的 如果你想分步调试...
使用openssl实现rsa非对称加密算法示例
10-26
在本示例中，我们通过PHP代码展示了如何使用OpenSSL库来实现RSA加密和解密。整个过程分为以下几个步骤： 1. 密钥对的生成：首先我们需要生成一对RSA密钥，包括一个私钥和一个公钥。在PHP代码中，通过调用openssl_...
C++ Qt5实现RSA加解密
11-14
本程序用Qt creator 4.5.1，Qt5.10.1制作，环境在win10和msvc2017下完美运行，点开就能用。 程序包含加解密两个部分，由于密文和明文存在int数组中，所以暂时只能加密数字，需要的人可以自行修改。 程序有一个小bug，输出加解密的结果的时候，会判断数组为空结束输出，但是这里数组初始化为0，故若结果是1101的时候，可能只会输出111，但其他时候一切正常。而且这个可以自行修改。 未提供加密字母，中文，文件等功能。 基本情况如上，根据需要下载。
使用Qt实现简化版的RSA算法
06-29
该资源是使用Qt开发的简化版的RSA非对称加密算法工具，有简单的操作界面。下载前请前往主页查看《使用Qt实现一个简化版的RSA加密算法》的博客。
Qt实现的RSA密钥生成器[2048bit]， 附带项目源码和工程文件
08-21
本资源内含2部分， 一个Qt实现的附带界面的RSA密钥生成器， 支持2048bit,可以直接安装使用， 另外一部分是本软件的Qt项目源文件工程。其中RSA的实现使用的是gmp库，只有2个类， 方便移植使用。
【QT】windows下OpenSSL的使用，RSA加解密
weixin_48618536的博客
05-27 716
链接：https://pan.baidu.com/s/1vg4s_1JmCpa68TMc1F2gMw。链接：https://pan.baidu.com/s/1mtmfps7Ob6oMfR0EwmwPSQ。可以从百度网盘下载，也可以直接在博文资源中下载，已经上传共享。完成了前期准备，接下来我们开始QT端的OpenSSL使用。实现对字符串“123456”的加密，然后对加密的内容用。OpenSSL工具使用学习，可以参考大神的博客。在QT端实现对字符串的加密与解密。，很详细，这边就不进行重复介绍。
Qt封装的RSA加解密，AES加解密类
一尘二的博客
03-31 1220
qt封装的rsa加解密，AES加解密类 #pragma execution_character_set("utf-8") #ifndef YCRSA_H #define YCRSA_H #include <QDebug> #ifdef Q_OS_WIN #include <openssl/rsa.h> #include <openssl/pem.h> #include <openssl/err.h> #include <openssl/aes.h>
QT中使用openssl实现RSA加密
li_yi_feng_的博客
03-10 1851
RSA加密，QT，openssl
QT使用OpenSSL的接口实现RSA的加密解密
QtCompany的博客
05-04 838
这里-out指定生成文件的。需要注意的是这个文件包含了公钥和密钥两部分，也就是说这个文件即可用来加密也可以用来解密。后面的1024是生成密钥的长度。-in指定输入文件，-out指定提取生成公钥的文件名。-in指定要加密的文件，-inkey指定密钥，-pubin表明是用纯公钥文件加密，-out为加密后的文件。-in指定被加密的文件，-inkey指定私钥文件，-out为解密后的文件。QT使用OpenSSL的接口实现RSA的加密解密-QT开发中文网。QT使用OpenSSL的接口实现RSA的加密解密。
linux qt rsa加密解密,使用qt实现一个简化版的rsa加密算法
06-28
### 回答1： RSA是一种非对称加密算法，使用公钥加密和私钥解密。在Linux和Qt环境下，我们可以使用OpenSSL库对RSA进行加密和解密操作。 在Qt中使用OpenSSL库，需要在.pro文件中加入如下语句： LIBS += -lssl -lcrypto 这样就可以链接OpenSSL库。 RSA算法分为公钥加密和私钥解密两个步骤。在Qt中，我们可以使用该库中的RSA_generate_key函数生成一对公私钥，该函数需要传入一个整型值作为密钥位数。 生成密钥对后，我们可以使用RSA_public_encrypt函数和RSA_private_decrypt函数分别对明文进行加密和密文进行解密操作。 下面是一个简化版的RSA加密算法实现： #include <openssl/rsa.h> #include <openssl/pem.h> #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { // 生成密钥对 RSA *r = RSA_generate_key(1024, RSA_F4, NULL, NULL); // 明文和密文 unsigned char plaintext[100] = "Hello, world!"; unsigned char ciphertext[1024] = {0}; unsigned char output[100] = {0}; // 加密 int len = RSA_public_encrypt(strlen((const char *)plaintext), plaintext, ciphertext, r, RSA_PKCS1_PADDING); printf("Ciphertext: %s\n", ciphertext); // 解密 len = RSA_private_decrypt(len, ciphertext, output, r, RSA_PKCS1_PADDING); printf("Plaintext: %s\n", output); return 0; } 这是一个简单的RSA加密解密程序，其中使用了OpenSSL库中的RSA_generate_key、RSA_public_encrypt和RSA_private_decrypt函数分别生成密钥对、加密明文和解密密文。 ### 回答2： RSA加密算法是一种非对称加密算法，常用于信息安全领域。使用Qt实现RSA加密解密，需要先了解RSA算法及其原理。 首先，RSA算法中需要生成一对公私钥，公钥用于加密，私钥用于解密。生成公私钥的过程如下： 1. 随机选择两个不同的质数p和q 2. 计算n=p*q 3. 计算欧拉函数φ(n)=(p-1)*(q-1) 4. 选择一个整数e(1<e<φ(n))，e与φ(n)互质 5. 计算d，满足d*e ≡ 1 (mod φ(n)) 6. 公钥为(n,e)，私钥为(n,d) 加密过程如下： 1. 将待加密数据转换为整数m(0<=m<n) 2. 计算密文c=m^e (mod n) 解密过程如下： 1. 接收到密文c 2. 计算明文m=c^d (mod n) 使用Qt实现RSA加密解密，可以参考以下步骤： 1. 生成公私钥对：随机选择两个质数p和q，计算n、φ(n)、e和d，得到公钥(n,e)和私钥(n,d)。 2. 加密：将待加密数据转换为整数m，计算密文c=m^e(mod n)。 3. 解密：接收到密文c，计算明文m=c^d(mod n)。 4. 实现一个简化版的RSA加密算法：通过Qt提供的大数类，实现上述步骤。 5. 测试：输入待加密的字符串，将其转换为整数后加密，再将密文解密并转回字符串，与原字符串进行比较，验证加解密是否正确。 总的来说，使用Qt实现RSA加密解密需要了解RSA算法原理，并掌握Qt提供的大数类。在实现过程中，需要注意数据类型的转换和边界处理，保证算法的正确性和运行效率。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值