md5.c

最新推荐文章于 2021-12-24 15:25:47 发布
最新推荐文章于 2021-12-24 15:25:47 发布
阅读量894 收藏
点赞数
文章标签： input c output hex string encryption 
#include   <stdio.h>   
#include   <stdlib.h>  
#include   <time.h>   
#include   <string.h>  
typedef   unsigned   char   *POINTER;   
typedef   unsigned   short   int   UINT2;   
typedef   unsigned   long   int   UINT4;  
typedef   struct     
{   
	 UINT4   state[4];   
	 UINT4   count[2];   
	 unsigned   char   buffer[64];   
}   MD5_CTX;  
void   MD5Init(MD5_CTX   *);   
void   MD5Update(MD5_CTX   *,   unsigned   char   *,   unsigned   int);   
void   MD5Final(unsigned   char   [16],   MD5_CTX   *);  
#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  
static   unsigned   char   PADDING[64]   =   {   
 0x80,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0   
};  
#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   ROTATE_LEFT(x,   n)   (((x)   <<   (n))   |   ((x)   >>   (32-(n))))  
#define   FF(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   F   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);       }   
#define   GG(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   G   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);       }   
#define   HH(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   H   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);       }   
#define   II(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   I   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);   }  

inline   void   Encode(unsigned   char   *output,   UINT4   *input,   unsigned   int   len)   
{   
	 unsigned   int   i,   j;   
	    
	 for   (i   =   0,   j   =   0;   j   <   len;   i++,   j   +=   4)   {   
	  output[j]   =   (unsigned   char)(input[i]   &   0xff);   
	  output[j+1]   =   (unsigned   char)((input[i]   >>   8)   &   0xff);   
	  output[j+2]   =   (unsigned   char)((input[i]   >>   16)   &   0xff);   
	  output[j+3]   =   (unsigned   char)((input[i]   >>   24)   &   0xff);   
 }   
}  
inline   void   Decode(UINT4   *output,   unsigned   char   *input,   unsigned   int   len)   
{   
	 unsigned   int   i,   j;   
	    
	 for   (i   =   0,   j   =   0;   j   <   len;   i++,   j   +=   4)   
	  output[i]   =   ((UINT4)input[j])   |   (((UINT4)input[j+1])   <<   8)   |   
	  (((UINT4)input[j+2])   <<   16)   |   (((UINT4)input[j+3])   <<   24);   
}  
inline   void   MD5Transform   (UINT4   state[4],   unsigned   char   block[64])   
{   
	 UINT4   a   =   state[0],   b   =   state[1],   c   =   state[2],   d   =   state[3],   x[16];   
	 Decode   (x,   block,   64);   
	 FF   (a,   b,   c,   d,   x[   0],   S11,   0xd76aa478);   /*   1   */   
	 FF   (d,   a,   b,   c,   x[   1],   S12,   0xe8c7b756);   /*   2   */   
	 FF   (c,   d,   a,   b,   x[   2],   S13,   0x242070db);   /*   3   */   
	 FF   (b,   c,   d,   a,   x[   3],   S14,   0xc1bdceee);   /*   4   */   
	 FF   (a,   b,   c,   d,   x[   4],   S11,   0xf57c0faf);   /*   5   */   
	 FF   (d,   a,   b,   c,   x[   5],   S12,   0x4787c62a);   /*   6   */   
	 FF   (c,   d,   a,   b,   x[   6],   S13,   0xa8304613);   /*   7   */   
	 FF   (b,   c,   d,   a,   x[   7],   S14,   0xfd469501);   /*   8   */   
	 FF   (a,   b,   c,   d,   x[   8],   S11,   0x698098d8);   /*   9   */   
	 FF   (d,   a,   b,   c,   x[   9],   S12,   0x8b44f7af);   /*   10   */   
	 FF   (c,   d,   a,   b,   x[10],   S13,   0xffff5bb1);   /*   11   */   
	 FF   (b,   c,   d,   a,   x[11],   S14,   0x895cd7be);   /*   12   */   
	 FF   (a,   b,   c,   d,   x[12],   S11,   0x6b901122);   /*   13   */   
	 FF   (d,   a,   b,   c,   x[13],   S12,   0xfd987193);   /*   14   */   
	 FF   (c,   d,   a,   b,   x[14],   S13,   0xa679438e);   /*   15   */   
	 FF   (b,   c,   d,   a,   x[15],   S14,   0x49b40821);   /*   16   */   
	 GG   (a,   b,   c,   d,   x[   1],   S21,   0xf61e2562);   /*   17   */   
	 GG   (d,   a,   b,   c,   x[   6],   S22,   0xc040b340);   /*   18   */   
	 GG   (c,   d,   a,   b,   x[11],   S23,   0x265e5a51);   /*   19   */   
	 GG   (b,   c,   d,   a,   x[   0],   S24,   0xe9b6c7aa);   /*   20   */   
	 GG   (a,   b,   c,   d,   x[   5],   S21,   0xd62f105d);   /*   21   */   
	 GG   (d,   a,   b,   c,   x[10],   S22,     0x2441453);   /*   22   */   
	 GG   (c,   d,   a,   b,   x[15],   S23,   0xd8a1e681);   /*   23   */   
	 GG   (b,   c,   d,   a,   x[   4],   S24,   0xe7d3fbc8);   /*   24   */   
	 GG   (a,   b,   c,   d,   x[   9],   S21,   0x21e1cde6);   /*   25   */   
	 GG   (d,   a,   b,   c,   x[14],   S22,   0xc33707d6);   /*   26   */   
	 GG   (c,   d,   a,   b,   x[   3],   S23,   0xf4d50d87);   /*   27   */   
	 GG   (b,   c,   d,   a,   x[   8],   S24,   0x455a14ed);   /*   28   */   
	 GG   (a,   b,   c,   d,   x[13],   S21,   0xa9e3e905);   /*   29   */   
	 GG   (d,   a,   b,   c,   x[   2],   S22,   0xfcefa3f8);   /*   30   */   
	 GG   (c,   d,   a,   b,   x[   7],   S23,   0x676f02d9);   /*   31   */   
	 GG   (b,   c,   d,   a,   x[12],   S24,   0x8d2a4c8a);   /*   32   */   
	 HH   (a,   b,   c,   d,   x[   5],   S31,   0xfffa3942);   /*   33   */   
	 HH   (d,   a,   b,   c,   x[   8],   S32,   0x8771f681);   /*   34   */   
	 HH   (c,   d,   a,   b,   x[11],   S33,   0x6d9d6122);   /*   35   */   
	 HH   (b,   c,   d,   a,   x[14],   S34,   0xfde5380c);   /*   36   */   
	 HH   (a,   b,   c,   d,   x[   1],   S31,   0xa4beea44);   /*   37   */   
	 HH   (d,   a,   b,   c,   x[   4],   S32,   0x4bdecfa9);   /*   38   */   
	 HH   (c,   d,   a,   b,   x[   7],   S33,   0xf6bb4b60);   /*   39   */   
	 HH   (b,   c,   d,   a,   x[10],   S34,   0xbebfbc70);   /*   40   */   
	 HH   (a,   b,   c,   d,   x[13],   S31,   0x289b7ec6);   /*   41   */   
	 HH   (d,   a,   b,   c,   x[   0],   S32,   0xeaa127fa);   /*   42   */   
	 HH   (c,   d,   a,   b,   x[   3],   S33,   0xd4ef3085);   /*   43   */   
	 HH   (b,   c,   d,   a,   x[   6],   S34,     0x4881d05);   /*   44   */   
	 HH   (a,   b,   c,   d,   x[   9],   S31,   0xd9d4d039);   /*   45   */   
	 HH   (d,   a,   b,   c,   x[12],   S32,   0xe6db99e5);   /*   46   */   
	 HH   (c,   d,   a,   b,   x[15],   S33,   0x1fa27cf8);   /*   47   */   
	 HH   (b,   c,   d,   a,   x[   2],   S34,   0xc4ac5665);   /*   48   */   
	 II   (a,   b,   c,   d,   x[   0],   S41,   0xf4292244);   /*   49   */   
	 II   (d,   a,   b,   c,   x[   7],   S42,   0x432aff97);   /*   50   */   
	 II   (c,   d,   a,   b,   x[14],   S43,   0xab9423a7);   /*   51   */   
	 II   (b,   c,   d,   a,   x[   5],   S44,   0xfc93a039);   /*   52   */   
	 II   (a,   b,   c,   d,   x[12],   S41,   0x655b59c3);   /*   53   */   
	 II   (d,   a,   b,   c,   x[   3],   S42,   0x8f0ccc92);   /*   54   */   
	 II   (c,   d,   a,   b,   x[10],   S43,   0xffeff47d);   /*   55   */   
	 II   (b,   c,   d,   a,   x[   1],   S44,   0x85845dd1);   /*   56   */   
	 II   (a,   b,   c,   d,   x[   8],   S41,   0x6fa87e4f);   /*   57   */   
	 II   (d,   a,   b,   c,   x[15],   S42,   0xfe2ce6e0);   /*   58   */   
	 II   (c,   d,   a,   b,   x[   6],   S43,   0xa3014314);   /*   59   */   
	 II   (b,   c,   d,   a,   x[13],   S44,   0x4e0811a1);   /*   60   */   
	 II   (a,   b,   c,   d,   x[   4],   S41,   0xf7537e82);   /*   61   */   
	 II   (d,   a,   b,   c,   x[11],   S42,   0xbd3af235);   /*   62   */   
	 II   (c,   d,   a,   b,   x[   2],   S43,   0x2ad7d2bb);   /*   63   */   
	 II   (b,   c,   d,   a,   x[   9],   S44,   0xeb86d391);   /*   64   */   
	 state[0]   +=   a;   
	 state[1]   +=   b;   
	 state[2]   +=   c;   
	 state[3]   +=   d;   
	 memset   ((POINTER)x,   0,   sizeof   (x));   
}  
inline   void   MD5Init(MD5_CTX   *context)   
{   
	 context->count[0]   =   context->count[1]   =   0;   
	 context->state[0]   =   0x67452301;   
	 context->state[1]   =   0xefcdab89;   
	 context->state[2]   =   0x98badcfe;   
	 context->state[3]   =   0x10325476;   
}  
inline   void   MD5Update(MD5_CTX   *context,   unsigned   char   *input,   unsigned   int   inputLen)   
{   
	 unsigned   int   i,   index,   partLen;   
	    
	 index   =   (unsigned   int)((context->count[0]   >>   3)   &   0x3F);   
	 if   ((context->count[0]   +=   ((UINT4)inputLen   <<   3))   
	  <   ((UINT4)inputLen   <<   3))   
	  context->count[1]++;   
	 context->count[1]   +=   ((UINT4)inputLen   >>   29);   
	    
	 partLen   =   64   -   index;   
	    
	 if   (inputLen   >=   partLen)   {   
	  memcpy((POINTER)&context->buffer[index],   (POINTER)input,   partLen);   
	  MD5Transform(context->state,   context->buffer);   
	  
	  for   (i   =   partLen;   i   +   63   <   inputLen;   i   +=   64)   
	   MD5Transform   (context->state,   &input[i]);   
	  index   =   0;   
 }   
 else   
  i   =   0;   
    
 memcpy((POINTER)&context->buffer[index],   (POINTER)&input[i],   inputLen-i);   
}  
inline   void   MD5Final(unsigned   char   digest[16],   MD5_CTX   *context)   
{   
	 unsigned   char   bits[8];   
	 unsigned   int   index,   padLen;   
	    
	 Encode   (bits,   context->count,   8);   
	 index   =   (unsigned   int)((context->count[0]   >>   3)   &   0x3f);   
	 padLen   =   (index   <   56)   ?   (56   -   index)   :   (120   -   index);   
	 MD5Update   (context,   PADDING,   padLen);   
	 MD5Update   (context,   bits,   8);   
	 Encode   (digest,   context->state,   16);   
	 memset   ((POINTER)context,   0,   sizeof   (*context));   
}  
void   MD5Digest(char   *pszInput,   unsigned   long   nInputSize,   char   *pszOutPut)   
{   
	 MD5_CTX   context;   
	 unsigned   int   len   =   strlen   (pszInput);   
	    
	 MD5Init   (&context);   
	 MD5Update   (&context,   (unsigned   char   *)pszInput,   len);   
	 MD5Final   ((unsigned   char   *)pszOutPut,   &context);   
}  

void Hex2String(unsigned char *pSrc, unsigned char *dest,int nL)  
{  
	char buf[256];  
	int i = 0;
      
	memset((char *)buf,0,sizeof(buf));  

	unsigned char hb;  
	unsigned char lb;  

	for(i=0;i<nL;i++)  
	{  
		hb=(pSrc[i]&0xf0)>>4;  

		if( hb>=0 && hb<=9 )  
		    	hb += 0x30;  
		else if( hb>=10 &&hb <=15 )  
			hb = hb -10 + 'a';  

		lb = pSrc[i]&0x0f;  
		if( lb>=0 && lb<=9 )  
			lb += 0x30;  
		else if( lb>=10 && lb<=15 )  
			lb = lb - 10 + 'a';  

		buf[i*2]   = hb;  
		buf[i*2+1] = lb;  
	}  
	buf[32] = '\0';
	
	//printf("buf = %s\n", buf);
	//dest = buf;  
	strcpy(dest,buf);  
	//return true;  
}  

char string[80] = {0};

char *MD5Encryption (unsigned char *encrypt)
{
	char szDigest[16] = {0};  
	char hex[64] = {0};
	
	MD5Digest(encrypt,strlen(encrypt),szDigest);   
	Hex2String(szDigest,hex,sizeof(hex));

	strcpy(string, hex);
	return string;
}

carlostyq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MD5C语言实现
12-24
MD5C语言实现，欢迎大家使用
前端加密插件md5.js
02-24
前端加密插件md5.js MD5.js是对前端的明文数据进行MD5加密方式。是一个前端加密插件。 MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的...
C语言实现md5函数代码
アーキテクトがしたい！
06-10 884
原文链接：http://blog.csdn.net/xhhjin/article/details/8450686 网上找到的实现md5函数代码，包括一个头文件md5.h和一个源文件md5.c，用下面的测试代码test.c测试通过，各文件依次如下： 头文件md5.h [cpp] view plaincopy #ifndef MD
MD5的C源码
管子（zero）的杂乱空间
12-07 295
关于MD5的C＋＋源码，请参考我的另外一篇文章:MD5的C＋＋源码 md5c.h: /* POINTER defines a generic pointer type */ typedef unsigned char * POINTER; /* UINT2 defines a two byte word */ //typedef unsigned short int UINT2; ...
MD5实现C语言
jun2016425的博客
01-03 733
copy国外网址的代码，只是备份一下，方便查找!注意: 这里写的是要安装环境OpenSSL头文件md5.h/* * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. * MD5 Message-Digest Algorithm (RFC 1321). * * Homepage: * htt
MD5jiamisuanfa.rar_emu.h_global.h md5.h_md5.c_md5.c md5.h_md5.h
09-19
1. **md5.c**：这是MD5算法的C语言实现源代码。它包含了计算MD5哈希值的主要函数和逻辑，如初始化MD5上下文、处理数据块以及生成最终哈希值的步骤。MD5算法通常包含四个内部函数（F, G, H, I）和四个32位的中间变量...
C语言描述MD5实例——MD5.c
07-30
readme： 先调用MD5Init初始化一个MD5_CTX类型结构体，再使用MD5Update计算MD5码，最后调用MD5Final获取，使用示例见资源。
md5.min.js
02-24
在JavaScript中，`md5.min.js` 和 `md5.js` 是两个实现MD5算法的库，用于对字符串进行MD5加密。这两个文件通常在Web开发中用于处理用户密码存储、数据验证或生成唯一标识等场景。 `md5.js` 是原始的、未压缩的源...
hmac-md5.zip
07-06
HMACMD5 是从 MD5 哈希函数构造的一种键控哈希算法，被用作基于哈希的消息验证代码 (HMAC)。此 HMAC 进程将密钥与消息数据混合，使用哈希函数对混合结果进行哈希计算，将所得哈希值与该密钥混合，然后再次应用哈希...
C版本MD5库
09-21
C版本MD5库 参考README.md 内容 #file list makefile #编译文件 md5.c md5.h test_md5_hash.c #测试样例文件 README.md #帮助文件 ========== 该库目前仅仅支持Gun/Linux/Unix 系列的编译 若是winxp/win7/win8 系列请自己包含进去，或者自己重新打包 代码是从bPostgreSQL中的库文件copy出来的，经过自己的测试，重新提取打包出来的 目前这个库的代码是在 PG 的 8.5RS 里面用的 MD5 返回的是一个 32位的消息hash因此需要一个char 类型的返回buf query_md5 =(char *)malloc(33); 函数调用 md5_hash(argv[1],query_len,query_md5); argv1 需要加密的数据 argv2 加密数据长度 argv3 密文 MD5.c 里面其他函数不常用，有兴趣的自己看一下吧，注释是用英文写的，基本上都能看 懂，不能看懂的，Google翻译一下就行了 自己的文件编译已测试样例文件为例 make后同时生成静态库和动态库 libminmd5.a 静态库 libminmd5.so 动态库 1、静态库的用法 gcc -o test test_md5_hash.c -L. -lminmd5 -I. -L #库文件的路径， -l #库名字，通常情况下就是 去掉后缀和前缀lib的名字 -I #头文件的路径 PS：动态库和静态库文件同名的建议不要放在一起，不然 ld的时候有可能找错文件 2、动态库的用法 gcc -o test test_md5_hash.c -g -L. -lminmd5 -I. 编译完后，建议将so 文件copy 到/usr/lib 然后执行 ldconfig 或者写死一点 gcc -o test test_md5_hash.c -g -L. -lminmd5 -I. -Wl,-rpath,. -Wl，-rpath,. #告诉ld 从本地找库（W后面是L小写的），rpath里面接的是库文件存在 的路径，正常应用建议用第一种方案，第二种方案在写小测试程序的时候，可以考虑。 至于选静态库还是动态库，就看具体应用场景了，静态库的坏处是把库代码编译进去了， 若是程序按字节收费还是可以的，（PS，吐槽那个写了一个10w，10G的程序中国神童）
C语言实现获取字符串的MD5码
06-27
计算一个字符串的md5码C语言实现！ 该压缩包包含：封装后的实现包含三部分：md5.h头文件、md5.c实现文件、test.c测试文件 md5.c文件最后实现了char* getMd5(char* str)获取字符串strmd5码的接口；可以直接调用。
MD5算法C语言实现
保持每天的清醒
11-14 4176
转自http://witmax.cn/c-md5-code.html，作者也是网上转载的，但没标明出处。 网上找到的md5函数的代码，试了一下，可以用，记录一下。包括三个文件，依次如下： 头文件md5.h 01 02 03 04 05 06 07 08 09 10 11 12 13 ...
MD5算法 —— C语言实现（字符串的加密）
热门推荐
杰儿__er 的博客
07-25 2万+
网上找到的实现md5函数代码，包括一个头文件md5.h和一个源文件md5.c，用下面的测试代码test.c测试通过，各文件依次如下： .h文件——md5.h #ifndef MD5_H #define MD5_H typedef struct { unsigned int count[2]; unsigned int state[4]; unsigned char...
解析MD5加密算法(C语言)
沐一 · 林 的博客
12-24 4046
目录 前提概要： MD5加密4步骤： C语言实现MD5算法：（假设加密 iscbupt ） 附上运行中间结果图： 字符串和文件加密实例： 前提概要： 本篇内容基于haroroda博客的MD5加密算法（c语言实现）和 艾蔓草博客的C语言实现md5函数代码，只是进行简单的融合并附上自己的理解而已，有需要的可以自己浏览上面两篇优秀的博客。 MD5加密4步骤： （1）附加填充位 课本原话：填充一个 ‘1’ 和若干个 ‘0’ 使其长度模 512 与 448 同余，然后再将...
linux采用c语言计算文件的md5，程序分为md5main.c和md5.c和md5.h三部分
最新发布
09-20
好的，我明白了。对于计算文件的MD5，你可以在Linux下使用C语言编写一个程序，由md5main.c、md5.c和md5.h三个文件组成。以下是一个示例的实现： 1. 首先，需要定义md5.h头文件，其中包含了函数的声明和结构体的定义。例如： ```c #ifndef MD5_H #define MD5_H #include <stdint.h> typedef struct { uint32_t state[4]; uint32_t count[2]; uint8_t buffer[64]; } MD5_CTX; void MD5_Init(MD5_CTX *context); void MD5_Update(MD5_CTX *context, const uint8_t *input, size_t inputLen); void MD5_Final(uint8_t digest[16], MD5_CTX *context); #endif ``` 2. 然后，在md5.c文件中实现MD5算法的具体逻辑。可以使用一些开源的MD5实现库或者自己编写。以下是一个示例的实现： ```c #include "md5.h" void MD5_Init(MD5_CTX *context) { // 初始化上下文 // ... } void MD5_Update(MD5_CTX *context, const uint8_t *input, size_t inputLen) { // 更新上下文 // ... } void MD5_Final(uint8_t digest[16], MD5_CTX *context) { // 完成计算并返回结果 // ... } ``` 3. 最后，在md5main.c文件中编写主函数，调用md5.c中的函数来计算文件的MD5值。以下是一个示例的实现： ```c #include <stdio.h> #include "md5.h" int main(int argc, char *argv[]) { if (argc != 2) { printf("Usage: %s <filename>\n", argv[0]); return 1; } FILE *file = fopen(argv[1], "rb"); if (file == NULL) { printf("Failed to open file\n"); return 1; } MD5_CTX context; MD5_Init(&context); size_t bytesRead; uint8_t buffer[1024]; while ((bytesRead = fread(buffer, 1, sizeof(buffer), file)) != 0) { MD5_Update(&context, buffer, bytesRead); } uint8_t digest[16]; MD5_Final(digest, &context); fclose(file); printf("MD5: "); for (int i = 0; i < 16; i++) { printf("%02x", digest[i]); } printf("\n"); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值