程序猿成长之路之密码学篇-分组密码加密模式及IV(偏移量)的详解

已于 2023-08-11 16:31:11 修改
阅读量1.1k 收藏 5
点赞数 1
分类专栏： 笔记 文章标签： 密码学 java 网络 算法
于 2023-08-11 16:27:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31236027/article/details/132224276
版权

Cipher.getInstance("AES/ECB/PKCS5Padding");
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
在进行加解密编程的时候应该有很多小伙伴接触过以上的语句，但是大伙儿在编码过程中是否了解过ECB/CBC的含义、区别以及PKCS5Padding的含义？如果不清楚的话那么希望这篇文章可以帮到你们。

什么是分组密码？

分组密码就是按照固定长度的字符对明文加密/密文解密的一种加解密算法。常见的有DES、AES等。具体如下图所示
在这里插入图片描述

什么是IV（偏移量）？

可以理解为加解密过程中设置的可变变量，可以是时间戳、uuid也可以是其他随机值，目的是为了增加混乱度，降低被破译的风险。

什么是分组加密模式？

对于一般加解密(或ECB)而言，我们只是调用了加解密函数分组加密就完事了，但是如果遇到了重放攻击（多次发起同一请求）,那么黑客在截获密文后可以较为轻松的按照分组进行解密，那么这时候就会对系统安全性造成威胁。为了防止这种情况的发生，我们就可以采取一定的措施去对分组密码进行轮次迭代处理，上述提到的ECB（电子密码本模式）/CBC（密文分组链接模式)就属于分组加密模式。此外还有CFB（密文反馈模式）等也属于分组加密模式。
下面我们来一一分析不同分组加密模式的含义以及各自的优缺点。

ECB(电子密码本模式）
在这里插入图片描述
过程/原理：
这种分组加密模式就属于最简单的不经过处理的分组加密模式，直接对明文或密文按组进行加密或解密得到结果。

优点:
-支持多线程异步处理，效率较高
-无需分组轮次迭代计算，计算量更小

缺点:
-安全性能较差，容易被攻破

CBC(密文分组链接模式）
在这里插入图片描述
过程/原理：
加密：
第一轮：生成初始化向量iv，与第一组明文分组异或运算后共同加密。
后续：拿上一轮CBC运算结果与当前分组明文异或运算后加密。
解密：
第一轮：生成初始化向量iv，先对第一组密文分组解密后再与初始化向量进行异或运算。
后续：先对当前密文分组解密后再与上一轮密文分组进行异或运算
加解密原理：
A异或B异或B = A
例如第一轮加密后的第一组密文 e1 = Ek(iv xor 第一组明文)
则第一轮解密后的第一组明文 d1 = (Ek’(第一组密文) xor iv) = (iv xor 第一组明文) xor iv = 第一组明文

优点：
-使用了iv作为随机变量，增加了破译的难度，使得每次针对同一明文加密后的结果不一致
-加密使用前一轮的输出作为后一轮的输入

缺点：
-增加了计算量，加大了计算开销

CFB(密文反馈模式）
在这里插入图片描述
过程/原理：
加密：
第一轮：生成初始化向量iv，先进行加密计算后与第一组明文分组进行异或运算。
后续：拿上一轮CFB运算结果先加密后与当前分组明文进行异或运算。
解密：
第一轮：生成初始化向量iv，先进行加密计算后与第一组密文分组进行异或运算。
后续：拿上一轮CFB运算结果先加密后与当前分组密文进行异或运算。
加解密原理：
A异或B异或B = A
例如第一轮加密后的第一组密文 e1 = Ek(iv) xor 第一组明文
则第一轮解密后的第一组明文 d1 = (Ek(iv) xor 第一组密文) = (Ek(iv) xor (Ek(iv) xor 第一组明文) ) = 第一组明文

优点：
-使用了iv作为随机变量，增加了破译的难度，使得每次针对同一明文加密后的结果不一致
-加密使用前一轮的输出作为后一轮的输入
-iv在分组加密算法中可以单独使用

缺点：
-增加了计算量，加大了计算开销

分组加密模式代码实现

注：如需要AES代码详见以下文章：
程序猿成长之路之密码学篇-AES算法解密详解及代码呈现 https://blog.csdn.net/qq_31236027/article/details/131206018

枚举类型

public enum EncryptMode {
	CBC("CBC"),
	CFB("CFB");
	
	private String name;
	
	private EncryptMode(String name) {
		this.setName(name);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

加密部分

/**
	 * 分组加密(128位一组)【完整版】
	 * @param text 明文
	 * @param mode 加密模式（CFB、CBC)
	 * @param iv 偏移量
	 */
	@Override
	public String encrypt(String text, String iv, EncryptMode mode) {
		if(mode == null) {
			return encrypt(text);
		}
		String result = null;
		switch(mode) {
			case CBC: result = encryptCBC(text,iv); break;
			case CFB: result = encryptCFB(text,iv);break;
			default: result = encrypt(text);break;
		}
		return result;
	}
	

	/**
	 * 分组加密(128位一组)(无iv【偏移量】版)
	 * @param text 明文
	 */
	private String encrypt(String text) {
		StringBuilder sb = new StringBuilder();
		int textLen = text.length();
		//获取分组长度
		// DIV_LEN * CHAR_LEN = 128
		// 根据DIV_LEN进行分组，如CHAR_LEN=16位，那么就每8个字符一组
		int divLen = textLen % AESConstant.DIV_LEN == 0 ? textLen / AESConstant.DIV_LEN : (textLen / AESConstant.DIV_LEN + 1);
		//分组加密处理
		for (int i = 0; i < divLen; i++) {
			int startIndex = i * AESConstant.DIV_LEN;
			int endIndex = (startIndex + AESConstant.DIV_LEN) >= textLen ? textLen : (startIndex + AESConstant.DIV_LEN);
			String substr = text.substring(startIndex, endIndex);
			//尾部填充
			while(substr.length() < AESConstant.DIV_LEN) {
				substr += " ";
			}
			sb.append(EncodeUtil.binaryToHexStr(baseEncrypt(substr)).trim());
		}
		return new BASE64Encoder().encode(sb.toString().trim().getBytes());
	}
	
	/**
	 * 分组加密(128位一组),(有iv【偏移量】CBC版,更安全)
	 * 
	 * CBC特性
	 * 1. 每一组分组的密文都依赖于上一组的结果
	 * 2. 加入了iv偏移量使得每次加密执行后的结果都不一致
	 * 
	 * @param text 明文
	 * @param iv 偏移量
	 */
	private String encryptCBC(String text,String iv) {
		StringBuilder sb = new StringBuilder();
		int textLen = text.length();
		//获取分组长度
		// DIV_LEN * CHAR_LEN = 128
		// 根据DIV_LEN进行分组，如CHAR_LEN=16位【UNICODE】，那么就每8个字符一组
		int divLen = textLen % AESConstant.DIV_LEN == 0 ? textLen / AESConstant.DIV_LEN : (textLen / AESConstant.DIV_LEN + 1);
		// CFB加密初始化向量
		String encryptedPart = iv;
		//分组加密处理
		for (int i = 0; i < divLen; i++) {
			int startIndex = i * AESConstant.DIV_LEN;
			int endIndex = (startIndex + AESConstant.DIV_LEN) >= textLen ? textLen : (startIndex + AESConstant.DIV_LEN);
			String substr = text.substring(startIndex, endIndex);
			//尾部填充
			while(substr.length() < AESConstant.DIV_LEN) {
				substr += " ";
			}
			while(encryptedPart.length() < AESConstant.DIV_LEN) {
				encryptedPart += " ";
			}
			//CBC关键，需要拿明文与上一轮结果进行异或得到的结果共同加密作为下一轮的输入
			encryptedPart = EncodeUtil.binaryToStr(
					baseEncrypt(strXor(encryptedPart,substr)), 16
			);
			sb.append(encryptedPart);
		}
		//批量处理为16进制后base64运算
		String result = sb.toString().trim();
		result = EncodeUtil.strtoBinary(result, 16);
		result = EncodeUtil.binaryToHexStr(result);
		return new BASE64Encoder().encode(result.getBytes());
	}
	
	/**
	 * 分组加密(128位一组),(有iv【偏移量】CFB版,更安全)
	 * 
	 * CFB特性
	 * 
	 * @param text 明文
	 * @param iv 偏移量
	 */
	private String encryptCFB(String text,String iv) {
		StringBuilder sb = new StringBuilder();
		int textLen = text.length();
		//获取分组长度
		// DIV_LEN * CHAR_LEN = 128
		// 根据DIV_LEN进行分组，如CHAR_LEN=16位【UNICODE】，那么就每8个字符一组
		int divLen = textLen % AESConstant.DIV_LEN == 0 ? textLen / AESConstant.DIV_LEN : (textLen / AESConstant.DIV_LEN + 1);
		// CFB加密初始化向量
		String encryptedPart = iv;
		//分组加密处理
		for (int i = 0; i < divLen; i++) {
			int startIndex = i * AESConstant.DIV_LEN;
			int endIndex = (startIndex + AESConstant.DIV_LEN) >= textLen ? textLen : (startIndex + AESConstant.DIV_LEN);
			String substr = text.substring(startIndex, endIndex);
			//尾部填充
			while(substr.length() < AESConstant.DIV_LEN) {
				substr += " ";
			}
			while(encryptedPart.length() < AESConstant.DIV_LEN) {
				encryptedPart += " ";
			}
			//CFB关键，需要拿明文与上一轮加密结果进行异或得到的结果作为下一轮的输入
			encryptedPart = strXor(EncodeUtil.binaryToStr(
					baseEncrypt(encryptedPart), 16
			),substr);
			sb.append(encryptedPart);
		}
		//批量处理为16进制后base64运算
		String result = sb.toString().trim();
		result = EncodeUtil.strtoBinary(result, 16);
		result = EncodeUtil.binaryToHexStr(result);
		return new BASE64Encoder().encode(result.getBytes());
	}

解密部分

	/**
	 * 分组解密(128位一组)【完整版】
	 * @param encrytedText 密文
	 * @param mode 加密模式（CFB、CBC)
	 * @param iv 偏移量
	 */
	@Override
	public String decrypt(String encrytedText, String iv, EncryptMode mode) {
		if(mode == null) {
			return decrypt(encrytedText);
		}
		String result = null;
		switch(mode) {
			case CBC: result = decryptCBC(encrytedText,iv); break;
			case CFB: result = decryptCFB(encrytedText,iv);break;
			default: result = decrypt(encrytedText);break;
		}
		return result;
	}


	/**
	 * 分组解密
	 * @param encrytedText 密文
	 */
	private String decrypt(String encrytedText) {
		try {
			//base64解码
			byte[] bytes = new BASE64Decoder().decodeBuffer(encrytedText);
			String str = new String(bytes,Charset.forName("UTF8"));
			int textLen = str.length();
			StringBuilder sb = new StringBuilder();
			int divLen = textLen < 32 ? 1 : (int)(Math.ceil(textLen/(4*8*1.0))); //因为加密后会自动填充所以长度必为字符长度的倍数(HEX 4位)
			//分组解密
			for (int i = 0; i< divLen; i++) {
				int startIndex = i * (4*8);
				int endIndex = (startIndex + (4*8));
				String temp = str.substring(startIndex, endIndex);
				sb.append(baseDecrypt(temp));
			}
			return sb.toString();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 分组解密(128位一组),(有iv【偏移量】CBC版)
	 * @param encrytedText 密文
	 * @param iv 偏移量
	 * @return 明文
	 */
	private String decryptCBC(String encrytedText,String iv) {
		try {
			//base64解码
			byte[] bytes = new BASE64Decoder().decodeBuffer(encrytedText);
			String str = new String(bytes,Charset.forName("UTF8"));
			int textLen = str.length();
			StringBuilder sb = new StringBuilder();
			int divLen = textLen < 32 ? 1 : (int)(Math.ceil(textLen/(4*8*1.0))); //因为加密后会自动填充所以长度必为字符长度的倍数(HEX 4位)
			//CFB解密初始化向量
			String decryptedPart = iv;
			//分组解密
			for (int i = 0; i< divLen; i++) {
				int startIndex = i * (4*8);
				int endIndex = (startIndex + (4*8));
				String temp = str.substring(startIndex, endIndex);
				//尾部填充
				while(decryptedPart.length() < AESConstant.DIV_LEN) {
					decryptedPart += " ";
				}
				//转换成16位的字符，方便strXor运算
				sb.append(strXor(baseDecrypt(temp),decryptedPart));
				//位数转换
				decryptedPart = EncodeUtil.binaryToStr(EncodeUtil.toBinary(temp, EncodeRadix.HEX), 16);
			}
			return sb.toString();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 分组解密(128位一组),(有iv【偏移量】CFB版)
	 * @param encrytedText 密文
	 * @param iv 偏移量
	 * @return 明文
	 */
	private String decryptCFB(String encrytedText,String iv) {
		try {
			//base64解码
			byte[] bytes = new BASE64Decoder().decodeBuffer(encrytedText);
			String str = new String(bytes,Charset.forName("UTF8"));
			int textLen = str.length();
			StringBuilder sb = new StringBuilder();
			int divLen = textLen < 32 ? 1 : (int)(Math.ceil(textLen/(4*8*1.0))); //因为加密后会自动填充所以长度必为字符长度的倍数(HEX 4位)
			//CFB解密初始化向量(转为16进制方便计算
			String decryptedPart = iv;
			//分组解密
			for (int i = 0; i< divLen; i++) {
				int startIndex = i * (4*8);
				int endIndex = (startIndex + (4*8));
				String temp = str.substring(startIndex, endIndex);
				//转换成16位的字符，方便strXor运算
				temp = EncodeUtil.binaryToStr(EncodeUtil.toBinary(temp, EncodeRadix.HEX), 16);
				//尾部填充
				while(decryptedPart.length() < AESConstant.DIV_LEN) {
					decryptedPart += " ";
				}
				//转换成16位的字符，方便strXor运算
				sb.append(
					strXor(EncodeUtil.binaryToStr(baseEncrypt(decryptedPart), 16),temp)
				);
				decryptedPart = temp;
			}
			return sb.toString();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

运行代码

public static void main(String[] args) {
		AesUtil util = new AesUtil();
		//偏移量（8个字符，每个字符16位）
		String iv = UUID.randomUUID().toString().substring(0,8);
		//CFB(密文反馈模式）
		String encrytedStr = util.encrypt(
				"{\"code\":200,\"message\":\"成功！\",\"data\":{\"id\":\"2103813902831\",\"name\":\"章鱼哥是我啊\",\"gender\":\"男\"}}"
				,iv
				,EncryptMode.CFB
		);
		System.out.println("encrytedStr = " + encrytedStr);
		System.out.println("result= " + util.decrypt(encrytedStr,iv,EncryptMode.CFB));
	}

最后是运行截图
在这里插入图片描述
————————————————PKCS5Padding后续再讲————————————————————

zygswo
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java程序猿技术路线图
08-29
Java程序猿技术路线图：让你从一个菜鸟到大神的指导线路！
AES 128位CBC加密解密（不使用固定IV）
热门推荐
weixin_39722651的博客
05-24 1万+
安全检查时要求账号和密码加密后才能存到数据库中，要求加密算法如下： 1）分组密码算法：AES（密钥长度在128位及以上）（GCM或CBC模式） 2）流密码算法：AES（密钥长度在128位及以上）（OFB或CTR模式）、chacha20 3）非对称加密算法：RSA（2048位及以上)、ECC（256位以上） 4）哈希算法：SHA2、SHA3 5）密钥交换算法：DSA/DH（密钥长度2048位及以上)...
CTF之常见密码学攻击手法和实现.md
10-24
CTF-crypto-入门-密码学
加密算法--node + aes +iv 偏移量实现加密
GO BEYOND YOURSELF
10-28 7938
在互联网发展迅速的同时，我们必须注重传输的数据的准确和安全。提到数据的安全，我们会想到很多加密：数字认证、MD5 加密，aes加密，des加密……或许你还能想到很多，虽然名称不同，但最终目标是一致的，都为了保护数据的完整、安全和准确性。今天小编就带着大家一起来认识其中的一种--aes + iv偏移量； 背景：     生活中的很多时候，大家都是收到不同形式的陌生推销，这归根结底就是对数据的保护
aes加密iv是什么_Vue.js使用 CryptoJS加密密码以及BCryptPasswordEncoder的使用
weixin_39961369的博客
11-20 2447
文章回顾：Spring Security（一）：整合JWT实现登录功能Spring Security（二）：获取用户权限菜单树Spring Security（三）：与Vue.js整合Spring Security（四）：更新前端路由获取方式Spring Security（五）：前后端权限控制详解Spring Security（六）：前端菜单，角色权限页面的搭建Spring Security（七）：...
AES算法中参数的一个问题
运维小岛
03-31 1215
AES算法 这个 AES 加密的主要坑就在于这些条件， 首先 aes 加密有一下几个参数 秘钥：加密的时候用秘钥，解密的时候需要同样的秘钥才能解出来 明文：需要加密的参数 模式：aes 加密常用的有 ECB 和 CBC 模式（我只用了这两个模式，还有其他模式） iv 偏移量：这个参数在 ECB 模式下不需要，在 CBC 模式下需要 这几个参数的条件： 秘钥：必须是16位字节或者24位字节或者32位字节（因为python3的字符串是unicode编码，需要 encode才可以转换成字节型数据） 明文：字节长度
Aes算法随机生成秘钥Key和随机生成偏移量Iv的java例子
qq_54136026的博客
11-27 5243
Aes算法利用java实现，包含随机生成的key和iv
对称加密——AES算法使用
Java是世界上最好的语言
12-12 7082
对称加密 我们知道MD5加密的本质上是无法解密，是一个不可逆的过程，而网上有很多解密其实都是一种穷举法对比，根本不存在破解方法。 但是在业务中，很多时候存在解密的需要，这个时候我们可以采用对称加密，对称加密是指加密和解密都采用相同的秘钥。使用对称加密，发送方使用密钥将明文数据加密成密文，然后发送出去，接收方收到密文后，使用同一个密钥将密文解密成明文读取，我们可以用一个很形象的例子来解释对称加密，例如：只有一模一样的钥匙才能打开同一个锁，也只有那把钥匙能锁住那把锁。 AES详解 典型的对称加密算法有DES、
前端用 aes 加解密 详细用法
NancyFyn的博客
01-11 1031
安装crypto-js： npm install crypto-js --save-dev // util.js ： // 加密 const key = CryptoJS.enc.Utf8.parse('321654abecd3ace7') const iv = CryptoJS.enc.Utf8.parse('edcab78965422ed5') export function encrypt(word) { const srcs = CryptoJS.enc.Utf8.parse(word) .
Android编程设计模式之迭代器模式详解
01-04
本文实例讲述了Android编程设计模式之迭代器模式。分享给大家供大家参考，具体如下： 一、介绍 迭代器模式（Iterator Pattern）又称为游标（Cursor）模式，是行为型设计模式之一。迭代器模式算是一个比较古老的设计...
python爬虫 - js逆向之猿人学第一题源码加密.pdf
11-27
python爬虫 - js逆向之猿人学第一题源码加密
小码哥程序猿高阶必备书籍编程原理之三大经书共4页.pdf
12-01
小码哥程序猿高阶必备书籍编程原理之三大经书共4页.pdf.zip
程序猿成长之路之Redis（5）-- redis数据结构之hash类型介绍
zygswo的博客
02-12 8485
redis hash类型是什么？与java hashmap 有什么异同点？hash扩容什么原理？redis hash有哪些命令？
程序猿成长之路之Redis（6）-- redis数据结构之bitmap类型介绍
zygswo的博客
03-06 8279
Bitmap 又称位图，是redis中的一种数据结构，它的出现对于redis来说具有什么意义，它具有哪些作用，它又是如何使用的？它的实现机制又是什么？下面就让我们来走进bitmap的世界。 Bitmap介绍 什么是bitmap？ 在文字说明之前，先来看一张图 这个在二进制里表示数字7 （00000111）2 = （7）10 那么这个在bitmap中表示什么呢？ 它在bitmap中表示6，7, 8号位上都为1，也就是说6, 7, 8号位上都有数据。【注意：bitmap低位在左，高位在右】 总结：bit.
程序猿成长之路之Redis（4）-- redis数据结构之string类型介绍
zygswo的博客
12-18 5326
序言 学过java的同学应该都知道，string在java语言中主要是指字符串类型，并且这不属于java基本数据类型之中。而在redis中，string类型是什么呢？它的常见使用场景有哪些？常见的命令有哪些？ 什么是redis的string类型？ String 类型在redis 中由两部分组成，一部分是key也就是键，另一部分是value，也就是值，redis将键和值进行绑定，通过key查找value 的值。 String类型的使用场景 用于共享session 、验证码等需设置超时时间数据的存储 Se.
程序猿成长之路之Redis（3）-- redis数据结构介绍
zygswo的博客
12-12 4025
序言 正如前文redis介绍所言，redis数据结构种类较多，可以应用于较多场景，如抽奖系统、分享打赏、购物车管理、公共好友推荐等。那么具体来说redis有哪些数据结构，不同的数据结构又有什么不同特征呢？ 图解redis 数据结构 Redis 常见的数据结构有： String类型，典型的键值对，通过key查询value的值。常见的函数有set、get、setex、setnx、mset等，常用于存储不需要复杂处理且数据量不大的数据 Hash类型， 典型的对象类型，可以比作一个类，通过key（可以理解为.
程序猿成长之路番外篇--hashmap介绍
zygswo的博客
01-03 3797
最近在网上看hashmap的相关源码，发现基本的知识有所介绍，但有些地方还是讲的不够透彻，所以我打算再给大家分享一下我的理解。 1. 基础知识介绍 HashMap大家都知道这是java中常见的数据结构，用途广泛，比如可以用作传参的容器，也可以用于spring中bean的管理。它继承了AbstractMap类，是map的后代，所以我们常常可以用向上造型进行创建实例。 如： Map<Type1, Type2> map = new HashMap<>(); 此外，在括号内还可以传入参.
程序猿成长之路之密码学篇-DES介绍
zygswo的博客
12-06 2041
加解密算法基础篇-des算法介绍
php调用es原生api,学习猿地-PHP 调用 ES API 小插曲
最新发布
05-25
很好，学习如何调用 Elasticsearch 的 API 是非常有用的。以下是一个简单的 PHP 示例程序，它演示了如何使用 Elasticsearch 的原生 API 进行搜索操作。 ```php <?php $host = 'localhost:9200'; // Elasticsearch 服务器地址 $index = 'my_index'; // 索引名称 $type = 'my_type'; // 类型名称 // 搜索条件 $searchParams['index'] = $index; $searchParams['type'] = $type; $searchParams['body']['query']['match']['title'] = 'PHP'; // 创建一个 Elasticsearch 客户端 $client = new Elasticsearch\Client([ 'hosts' => [$host], ]); // 执行搜索操作 $results = $client->search($searchParams); // 输出结果 foreach ($results['hits']['hits'] as $hit) { echo $hit['_source']['title'] . "\n"; } ``` 在上面的代码中，我们首先定义了 Elasticsearch 服务器的主机地址、索引名称和类型名称。然后，我们构建了一个包含搜索条件的数组，并创建了一个 Elasticsearch 客户端实例。最后，我们执行了搜索操作，并遍历了搜索结果集。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zygswo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值