MD5的C实现及中间计算数据（学习记录 2020/1/8）

最新推荐文章于 2021-12-19 11:03:42 发布
最新推荐文章于 2021-12-19 11:03:42 发布
阅读量211 收藏 2
点赞数 1
分类专栏： C语言 学习记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Seth423/article/details/112379913
版权

MD5 哈希算法 RFC1321 杂凑函数 四轮运算
关键词由CSDN通过智能技术生成

研二

MD5

今年的目标是要实现20个以上的标准，MD5是第一个。
MD5的相关标准我参考的是RFC1321，但RFC好像并不是真正意义上的标准文件，这个之后再去研究。
根据文档上对算法的描述，我编写出了如下代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define IN
#define OUT

#define LOGE printf
#define LOGD printf
#define LOGI printf

#define ROL(x, n) ((x << n) | ((unsigned int)x >> (32 - n)))

#define F(X, Y, Z) ((X & Y) | ((~X) & Z))
#define G(X, Y, Z) ((X & Z) | (Y & (~Z)))
#define H(X, Y, Z) (X ^ Y ^ Z)
#define I(X, Y, Z) (Y ^ (X | (~Z)))

#define FREE(x) {if (x) free(x); x = NULL;}

#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21

#define Block_Process_1(a, b, c, d, x, s, ac) {        \
  (a) += F ((b), (c), (d)) + (x) + (unsigned int)(ac); \
  (a) = ROL ((a), (s));                                \
  (a) += (b);                                          \
}

#define Block_Process_2(a, b, c, d, x, s, ac) {        \
  (a) += G ((b), (c), (d)) + (x) + (unsigned int)(ac); \
  (a) = ROL ((a), (s));                                \
  (a) += (b);                                          \
}

#define Block_Process_3(a, b, c, d, x, s, ac) {        \
  (a) += H ((b), (c), (d)) + (x) + (unsigned int)(ac); \
  (a) = ROL ((a), (s));                                \
  (a) += (b);                                          \
}

#define Block_Process_4(a, b, c, d, x, s, ac) {        \
  (a) += I ((b), (c), (d)) + (x) + (unsigned int)(ac); \
  (a) = ROL ((a), (s));                                \
  (a) += (b);                                          \
}

unsigned int A = 0x67452301;
unsigned int B = 0xefcdab89;
unsigned int C = 0x98badcfe;
unsigned int D = 0x10325476;


void PrintByte(IN const char *Name, 
               IN unsigned char *Src, IN unsigned int SrcLen)
{
	int i;
	LOGD("%s:\n", Name);
	for (i = 0; i < SrcLen; i++) {
		LOGD("%02X", Src[i]);
	}
	LOGD("\nEND\n");
}

void i2c(IN unsigned int *input, IN unsigned int inputlen, 
		OUT unsigned char *output)
{
	int i, j;
	for (i = j = 0; j < inputlen; j += 4, i++) {
		output[j    ] = (input[i] >>  0) & 0xFF;
		output[j + 1] = (input[i] >>  8) & 0xFF;
		output[j + 2] = (input[i] >> 16) & 0xFF;
		output[j + 3] = (input[i] >> 24) & 0xFF;
	}
}

void c2i(IN unsigned char *input, IN unsigned int inputLen,
		OUT unsigned int *output) 
{
	int i, j;
	for (i = j = 0; i < inputLen; i += 4, j++) {
		output[j] = (((unsigned int)input[i    ]      ) |
				     ((unsigned int)input[i + 1] <<  8) |
				     ((unsigned int)input[i + 2] << 16) |
				     ((unsigned int)input[i + 3] << 24));
	}
}

void Padding(IN unsigned char *Src, IN unsigned int SrcLen, 
			OUT unsigned char *Out, OUT unsigned int *OutLen)
{
	unsigned int KLen = ((SrcLen & 0x3F) < 56 ? 55 : 119) - (SrcLen & 0x3F);
	unsigned char Length_In_Byte[8] = {0};
	unsigned int SrcBitLen = SrcLen << 3;

	i2c(&SrcBitLen, 1, Length_In_Byte);

	memcpy(Out, Src, SrcLen);
	memset(Out + SrcLen, 0x80, 1);
	memset(Out + SrcLen + 1, 0x00, KLen);
	memcpy(Out + SrcLen + 1 + KLen, Length_In_Byte, 8);

	*OutLen = SrcLen + 9 + KLen;
}

void Block_Process(IN unsigned int *M, IN unsigned int MLen)
{
	int i, j;
	unsigned int X[16] = {0};
	unsigned int AA, BB, CC, DD;

	for (i = 0; i < MLen / 16; i++) {
		for (j = 0; j < 16; j++)
			X[j] = M[i * 16 + j];

		AA = A; BB = B; CC = C; DD = D;

		/* Round 1 */
		Block_Process_1(A, B, C, D, X[ 0], S11, 0xd76aa478); /*  1 */
		Block_Process_1(D, A, B, C, X[ 1], S12, 0xe8c7b756); /*  2 */
		Block_Process_1(C, D, A, B, X[ 2], S13, 0x242070db); /*  3 */
		Block_Process_1(B, C, D, A, X[ 3], S14, 0xc1bdceee); /*  4 */
		Block_Process_1(A, B, C, D, X[ 4], S11, 0xf57c0faf); /*  5 */
		Block_Process_1(D, A, B, C, X[ 5], S12, 0x4787c62a); /*  6 */
		Block_Process_1(C, D, A, B, X[ 6], S13, 0xa8304613); /*  7 */
		Block_Process_1(B, C, D, A, X[ 7], S14, 0xfd469501); /*  8 */
		Block_Process_1(A, B, C, D, X[ 8], S11, 0x698098d8); /*  9 */
		Block_Process_1(D, A, B, C, X[ 9], S12, 0x8b44f7af); /* 10 */
		Block_Process_1(C, D, A, B, X[10], S13, 0xffff5bb1); /* 11 */
		Block_Process_1(B, C, D, A, X[11], S14, 0x895cd7be); /* 12 */
		Block_Process_1(A, B, C, D, X[12], S11, 0x6b901122); /* 13 */
		Block_Process_1(D, A, B, C, X[13], S12, 0xfd987193); /* 14 */
		Block_Process_1(C, D, A, B, X[14], S13, 0xa679438e); /* 15 */
		Block_Process_1(B, C, D, A, X[15], S14, 0x49b40821); /* 16 */

		/* Round 2 */
		Block_Process_2(A, B, C, D, X[ 1], S21, 0xf61e2562); /* 17 */
		Block_Process_2(D, A, B, C, X[ 6], S22, 0xc040b340); /* 18 */
		Block_Process_2(C, D, A, B, X[11], S23, 0x265e5a51); /* 19 */
		Block_Process_2(B, C, D, A, X[ 0], S24, 0xe9b6c7aa); /* 20 */
		Block_Process_2(A, B, C, D, X[ 5], S21, 0xd62f105d); /* 21 */
		Block_Process_2(D, A, B, C, X[10], S22,  0x2441453); /* 22 */
		Block_Process_2(C, D, A, B, X[15], S23, 0xd8a1e681); /* 23 */
		Block_Process_2(B, C, D, A, X[ 4], S24, 0xe7d3fbc8); /* 24 */
		Block_Process_2(A, B, C, D, X[ 9], S21, 0x21e1cde6); /* 25 */
		Block_Process_2(D, A, B, C, X[14], S22, 0xc33707d6); /* 26 */
		Block_Process_2(C, D, A, B, X[ 3], S23, 0xf4d50d87); /* 27 */
		Block_Process_2(B, C, D, A, X[ 8], S24, 0x455a14ed); /* 28 */
		Block_Process_2(A, B, C, D, X[13], S21, 0xa9e3e905); /* 29 */
		Block_Process_2(D, A, B, C, X[ 2], S22, 0xfcefa3f8); /* 30 */
		Block_Process_2(C, D, A, B, X[ 7], S23, 0x676f02d9); /* 31 */
		Block_Process_2(B, C, D, A, X[12], S24, 0x8d2a4c8a); /* 32 */

		/* Round 3 */
		Block_Process_3(A, B, C, D, X[ 5], S31, 0xfffa3942); /* 33 */
		Block_Process_3(D, A, B, C, X[ 8], S32, 0x8771f681); /* 34 */
		Block_Process_3(C, D, A, B, X[11], S33, 0x6d9d6122); /* 35 */
		Block_Process_3(B, C, D, A, X[14], S34, 0xfde5380c); /* 36 */
		Block_Process_3(A, B, C, D, X[ 1], S31, 0xa4beea44); /* 37 */
		Block_Process_3(D, A, B, C, X[ 4], S32, 0x4bdecfa9); /* 38 */
		Block_Process_3(C, D, A, B, X[ 7], S33, 0xf6bb4b60); /* 39 */
		Block_Process_3(B, C, D, A, X[10], S34, 0xbebfbc70); /* 40 */
		Block_Process_3(A, B, C, D, X[13], S31, 0x289b7ec6); /* 41 */
		Block_Process_3(D, A, B, C, X[ 0], S32, 0xeaa127fa); /* 42 */
		Block_Process_3(C, D, A, B, X[ 3], S33, 0xd4ef3085); /* 43 */
		Block_Process_3(B, C, D, A, X[ 6], S34,  0x4881d05); /* 44 */
		Block_Process_3(A, B, C, D, X[ 9], S31, 0xd9d4d039); /* 45 */
		Block_Process_3(D, A, B, C, X[12], S32, 0xe6db99e5); /* 46 */
		Block_Process_3(C, D, A, B, X[15], S33, 0x1fa27cf8); /* 47 */
		Block_Process_3(B, C, D, A, X[ 2], S34, 0xc4ac5665); /* 48 */

		/* Round 4 */
		Block_Process_4(A, B, C, D, X[ 0], S41, 0xf4292244); /* 49 */
		Block_Process_4(D, A, B, C, X[ 7], S42, 0x432aff97); /* 50 */
		Block_Process_4(C, D, A, B, X[14], S43, 0xab9423a7); /* 51 */
		Block_Process_4(B, C, D, A, X[ 5], S44, 0xfc93a039); /* 52 */
		Block_Process_4(A, B, C, D, X[12], S41, 0x655b59c3); /* 53 */
		Block_Process_4(D, A, B, C, X[ 3], S42, 0x8f0ccc92); /* 54 */
		Block_Process_4(C, D, A, B, X[10], S43, 0xffeff47d); /* 55 */
		Block_Process_4(B, C, D, A, X[ 1], S44, 0x85845dd1); /* 56 */
		Block_Process_4(A, B, C, D, X[ 8], S41, 0x6fa87e4f); /* 57 */
		Block_Process_4(D, A, B, C, X[15], S42, 0xfe2ce6e0); /* 58 */
		Block_Process_4(C, D, A, B, X[ 6], S43, 0xa3014314); /* 59 */
		Block_Process_4(B, C, D, A, X[13], S44, 0x4e0811a1); /* 60 */
		Block_Process_4(A, B, C, D, X[ 4], S41, 0xf7537e82); /* 61 */
		Block_Process_4(D, A, B, C, X[11], S42, 0xbd3af235); /* 62 */
		Block_Process_4(C, D, A, B, X[ 2], S43, 0x2ad7d2bb); /* 63 */
		Block_Process_4(B, C, D, A, X[ 9], S44, 0xeb86d391); /* 64 */

		A += AA; B += BB; C += CC; D += DD;
	}
}

void MD5(IN unsigned char *Msg, IN unsigned int MsgLen,
		OUT unsigned char *Hash)
{
	int i;
	unsigned int PadMsgLen = 128;
	unsigned char *PadMsg = (unsigned char *)calloc(PadMsgLen, sizeof(char));
	unsigned int IntPadMsgLen = PadMsgLen / 4;
	unsigned int *IntPadMsg = (unsigned int *)calloc(IntPadMsgLen, sizeof(int));

	Padding(Msg, MsgLen, PadMsg, &PadMsgLen);

	c2i(PadMsg, PadMsgLen, IntPadMsg);
	Block_Process(IntPadMsg, IntPadMsgLen);

	i2c(&A, 1, Hash);
	i2c(&B, 1, Hash + 4);
	i2c(&C, 1, Hash + 8);
	i2c(&D, 1, Hash + 12);

	FREE(PadMsg); FREE(IntPadMsg);
}

int main(int argc, char *argv[])
{
	unsigned char Hash[16] = { 0 };

	MD5(argv[1], strlen(argv[1]), Hash);
	PrintByte("MD5", Hash, 16);
}

由于第一次写这种程序，很多地方有待改进。该程序中，我将所有代码都放到了一个文件中，没有使用init update以及final三段式的标准写法，因此不能接受过长的输入。而且由于没有采用循环update的形式，所以不得不动态使用malloc函数动态开辟内存空间，显得很蠢。
该RFC文档提供了可借鉴的代码，为之后写杂凑函数以及对称加密函数提供了很好的样板。
另外网上并没有找到MD5的过程数据供对照，因此我将RFC提供的代码的部分计算数据打印了出来供参考。

对abc进行杂凑：
block[0]: 80636261 /* 填充后的数据 */
block[1]: 00000000
block[2]: 00000000
block[3]: 00000000
block[4]: 00000000
block[5]: 00000000
block[6]: 00000000
block[7]: 00000000
block[8]: 00000000
block[9]: 00000000
block[10]: 00000000
block[11]: 00000000
block[12]: 00000000
block[13]: 00000000
block[14]: 00000018
block[15]: 00000000
Transform过程中A， B， C， D的值
a b c d
D6D117B4 EFCDAB89 98BADCFE 10325476
D6D117B4 EFCDAB89 98BADCFE 344A8432
D6D117B4 EFCDAB89 2F6FBD72 344A8432
D6D117B4 7AD956F2 2F6FBD72 344A8432
C73741EF 7AD956F2 2F6FBD72 344A8432
C73741EF 7AD956F2 2F6FBD72 8BAC3051
C73741EF 7AD956F2 207DC67B 8BAC3051
C73741EF 928D99F6 207DC67B 8BAC3051
854B3712 928D99F6 207DC67B 8BAC3051
854B3712 928D99F6 207DC67B 74E2F284
854B3712 928D99F6 3020401C 74E2F284
854B3712 5ED49596 3020401C 74E2F284
DDA9B9A6 5ED49596 3020401C 74E2F284
DDA9B9A6 5ED49596 3020401C A1051895
DDA9B9A6 5ED49596 E396856B A1051895
DDA9B9A6 72AFF2E0 E396856B A1051895

3E9E9126 72AFF2E0 E396856B A1051895
3E9E9126 72AFF2E0 E396856B 4A1D804E
3E9E9126 72AFF2E0 E25E1652 4A1D804E
3E9E9126 B5B204E4 E25E1652 4A1D804E
59A8FFDA B5B204E4 E25E1652 4A1D804E
59A8FFDA B5B204E4 E25E1652 6D002F1E
59A8FFDA B5B204E4 ABFC7920 6D002F1E
59A8FFDA 47092C07 ABFC7920 6D002F1E
B7F268CF 47092C07 ABFC7920 6D002F1E
B7F268CF 47092C07 ABFC7920 09388EFF
B7F268CF 47092C07 FE1623B1 09388EFF
B7F268CF 786ACB8F FE1623B1 09388EFF
790A77FB 786ACB8F FE1623B1 09388EFF
790A77FB 786ACB8F A62884AA 9F47E4F8
790A77FB 726342D3 A62884AA 9F47E4F8

B3707EBF 726342D3 A62884AA 9F47E4F8
B3707EBF 726342D3 A62884AA 60127B2E
B3707EBF 726342D3 8D212FF5 60127B2E
B3707EBF 3B0875C7 8D212FF5 60127B2E
21B117B9 3B0875C7 8D212FF5 60127B2E
21B117B9 3B0875C7 8D212FF5 6E7429D5
21B117B9 3B0875C7 3575227E 6E7429D5
21B117B9 5A2F5EA5 3575227E 6E7429D5
11DE1779 5A2F5EA5 3575227E 6E7429D5
11DE1779 5A2F5EA5 3575227E FADCAA38
11DE1779 5A2F5EA5 31C465CA FADCAA38
11DE1779 4C6124F4 31C465CA FADCAA38
7F2E507B 4C6124F4 31C465CA FADCAA38
7F2E507B 4C6124F4 31C465CA 99D9679D
7F2E507B 4C6124F4 8FAE6399 99D9679D
7F2E507B 7BEB9700 8FAE6399 99D9679D

7B201DF8 7BEB9700 8FAE6399 99D9679D
7B201DF8 7BEB9700 8FAE6399 F4E8E96E
7B201DF8 7BEB9700 B298CEFD F4E8E96E
7B201DF8 8BF025C4 B298CEFD F4E8E96E
06CC5E8A 8BF025C4 B298CEFD F4E8E96E
06CC5E8A 8BF025C4 B298CEFD 5B0D97AA
06CC5E8A 8BF025C4 7D632DD0 5B0D97AA
06CC5E8A 3BFA2C27 7D632DD0 5B0D97AA
7F81CC35 3BFA2C27 7D632DD0 5B0D97AA
7F81CC35 3BFA2C27 7D632DD0 094454AB
7F81CC35 3BFA2C27 4F9DBE3F 094454AB
7F81CC35 7327D604 4F9DBE3F 094454AB
310ADE8F 7327D604 4F9DBE3F 094454AB
310ADE8F 7327D604 4F9DBE3F 624D8CB2
310ADE8F 7327D604 E484B9D8 624D8CB2
310ADE8F C08226B3 E484B9D8 624D8CB2
杂凑结果：
900150983cd24fb0d6963f7d28e17f72

Seth423
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
密码学 MD5信息摘要算法
爬虫进击之路
01-26 1268
MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。
MD5算法C语言实现
11-14
### MD5算法C语言实现详解 #### 一、概述 MD5是一种广泛使用的散列算法，主要用于确保数据的完整性。它的全称是Message-Digest Algorithm 5，即第五种消息摘要算法，由MIT的教授Ron Rivest在1991年设计。MD5算法...
MD5加密——C
有人_295的博客
11-17 444
MD5 MD5消息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代MD4算法。这套算法的程序在 RFC 1321 中被加以规范。 将数据（如一段文字）运算变为另一固定长度值，是散列算法的基础原理。 1. 历史与密码学 1992年8月，罗纳德·李维斯特向
MD5原理分析
居贝比的博客
10-05 316
·
md5加密数据结果对比
weixin_33881140的博客
05-08 680
64位机器，与32位机器，加密结果对比 转载于:https://blog.51cto.com/49054/1408450
XCTF-攻防世界CTF平台-Reverse逆向类——65、reverse-box（Linux32位ELF文件、gdb脚本调试）
Onlyone_1314的博客
09-11 2140
这里写目录标题1、查看程序信息2、main函数3、sub_804858D()函数：4、程序逻辑5、方法一：gdb脚本获得内存中的数组6、gdb脚本分析：7、将输出转换会输入的flag8、C语言复现程序得到数组 挑战描述 $ ./reverse_box ${FLAG} 95eeaf95ef94234999582f722f492f72b19a7aaf72e6e776b57aee722fe77ab5ad9aaeb156729676ae7a236d99b1df4a flag格式：TWCTF{} 1、查看程序信息 先
c++实现MD5算法实现代码
09-04
1. **初始化**：设置四个32位的变量A、B、C和D，它们是计算过程中的中间结果。在`MD5`类中，这些变量被定义为`uint32`类型。 2. **预处理**：对输入数据进行填充，确保其长度是512位的倍数。在C++代码中，`remain_`...
MD5.c.zip_hash_md5_md5 hash_md5_hash_woodennfx
最新发布
09-21
这个标题"MD5.c.zip_hash_md5_md5_hash_woodennfx"可能指的是一个包含有关MD5哈希计算源代码的压缩文件，其中可能包含了名为"MD5.c"的C语言源代码文件。 MD5的主要特性是它的单向性，即从任意长度的消息生成固定...
纯C的MD5加密可直接编译和交叉编译计算字符的MD5值
11-17
编译这个C语言的MD5实现，通常会使用`gcc`或者`clang`这样的C编译器，命令可能是`gcc -o md5 md5.c`，这会产生一个名为`md5`的可执行文件。如果需要在其他平台上运行，比如嵌入式系统，可以进行交叉编译，这通常需要...
MD5详解
xcxhzjl的博客
12-19 6699
一、介绍 二、特点 三、性质 四、用途 五、算法原理 六、破解 七、MD5较MD4所做的改进
数据的加密和解密（MD5）
Hannah1221的博客
07-28 637
class Program { static void Main(string[] args) { string path = @"C:\Users\EDZ\Desktop\Test1\userData11.luxin"; if (!File.Exists(path)) { Console.WriteLine("文件不包含")...
MD5 加密结果
yun_ld的博客
01-08 1943
MD5的典型应用是对一段信息（Message）产生信息摘要（Message-Digest），以防止被篡改。MD5加密是无法解密的，网上有一些在线工具解密，但这个解密并不是真正的解密，只是通过穷举法，明文密文对应查询数据库来达到解密的目的。 MD5 加密后的位数有两种：16 位与 32 位。16 位实际上是从 32 位字符串中取中间的第 9 位到第 24 位的部分，用 Java 语言来说，即： ...
算法--MD5--如何保证MD5加密结果在不同的环境下都相同
04-02 8569
首先我们来看一下Java是如何实现MD5的：   import java.io.UnsupportedEncodingException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class MD5Digest {     priv
同一字符串，MD5加密后出现不同的结果
热门推荐
Peiel
08-24 3万+
同一字符串，MD5加密后出现不同的结果背景 公司数据采用MD5加密和ssl双向认证，最近把项目部署到服务器进行测试，结果MD5验证总是通不过，服务器在请求过来的加密32位串和本地加密32位串作对比时，总是返回false，那么问题来了，加密之前的明文是相同的，为何同样的加密方法却得到了不同的结果？ 问题分析 首先考虑到的是操作系统的不同，win下运行正常的代码为何到linux下就不行了，但是M
两种MD5最后的值不一样，因为两种做法不一样
07-19 238
//MD5加密 private static string Md5Hash(string input) { MD5CryptoServiceProvider md5Hasher = new MD5CryptoServiceProvider(); byte[] data = md5Hasher.ComputeHash...
获取md5值的方法（自带方法，直接调用）
shuai的博客
06-21 1万+
32位MD5值DigestUtils.md5Hex(newPassword);
计算MD5值有几种方式
kevinhanser
02-23 7295
想知道计算”hello“的MD5值有几种方式 linux 命令行： [sm2env ~]# echo &quot;hello&quot; | md5sum | cut -d ' ' -f1 b1946ac92492d2347c6235b4d2611184 说明：如果想获取字符串的其他哈希值，只要把命令中的md5sum 换成其他哈希命令就可以了。例如sha1sum，sha224sum，sha256sum，...
md5码值计算
weixin_37281967的博客
07-15 1010
前面搞了个md5码计算页面，思路是利用php调用python的hashlib库计算，其实比较绕路。 1是资源占用，2是需要上传文件。 其实用js可以在本地计算，这样就不用占用服务器资源。 采用的是开源的spark-md5库，可以在GIT上下到，主要是在开源库的基础上实现了多文件计算。 原理不难，但是网上找了半天资料零零散散，自己的js又是个半路出家，所以改了个基础的，能够左右显示文件和码值。 蓝色按钮是想基于bootstrap把界面改一下，但是实在太困，有需要的自己动下小手即可。 git链接
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值