Base64算法及C++实现

最新推荐文章于 2024-04-23 18:00:40 发布
最新推荐文章于 2024-04-23 18:00:40 发布
阅读量7.1k 收藏 9
点赞数 2
分类专栏： Algorithm 文章标签： 算法 c++ buffer class encoding output
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luxiaoxun/article/details/7641338
版权

Base64用途

1. 用于对 SOHO 级路由器（网关设备）管理员帐户密码的加密

2. 流媒体网站对于播放的流媒体文件的路径的加密

3. 迅雷等下载软件对下载链接地址的加密

Base64算法

Base64编码要求把3个8位字节（3*8=24）转化为4个6位的字节（4*6=24），之后在6位的前面补两个0，形成8位一个字节的形式。


Base64类

函数：

unsigned intCreateMatchingEncodingBuffer (unsigned intp_InputByteCount,char**p_ppEncodingBuffer);

创建匹配于编码的缓存空间。参数：1输入字节数，2进行编码需要的缓存空间；返回值：缓存空间大小。

unsigned intCreateMatchingDecodingBuffer (char*p_pInputBufferString,char**p_ppDecodingBuffer);

创建匹配于解码的缓存空间。参数：1解码对象缓存，2进行解码需要的缓存空间；返回值：缓存空间大小。

voidEncodeBuffer (char*p_pInputBuffer,unsigned intp_InputBufferLength,char*p_pOutputBufferString);

进行编码。参数：1明文，2明文长度，3密文输出。

unsigned int DecodeBuffer (char*p_pInputBufferString,char*p_pOutputBuffer);

进行解码。参数：1密文，2明文；返回值：明文长度

C++实现：

/************************************************
*						*
* CBase64.h					*
* Base 64 de- and encoding class		*
*						*
* ============================================  *
*						*
* This class was written on 28.05.2003		*
* by Jan Raddatz [jan-raddatz@web.de]		*
*						*
* ============================================  *
*						*
* Copyright (c) by Jan Raddatz			*
* This class was published @ codeguru.com	*
* 28.05.2003					*
*						*
************************************************/

#pragma once

#include <afx.h>
#include <stdlib.h>
#include <math.h>
#include <memory.h>
const static unsigned int MAX_LINE_LENGTH = 76;

const static char BASE64_ALPHABET [64] = 
{
	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', //   0 -   9
	'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', //  10 -  19
	'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', //  20 -  29
	'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', //  30 -  39
	'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', //  40 -  49
	'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', //  50 -  59
	'8', '9', '+', '/'				  //  60 -  63
};

const static char BASE64_DEALPHABET [128] = 
{
	0,  0,  0,  0,  0,  0,  0,  0,  0,  0, //   0 -   9
	0,  0,  0,  0,  0,  0,  0,  0,  0,  0, //  10 -  19
	0,  0,  0,  0,  0,  0,  0,  0,  0,  0, //  20 -  29
	0,  0,  0,  0,  0,  0,  0,  0,  0,  0, //  30 -  39
	0,  0,  0, 62,  0,  0,  0, 63, 52, 53, //  40 -  49
	54, 55, 56, 57, 58, 59, 60, 61,  0,  0, //  50 -  59
	0, 61,  0,  0,  0,  0,  1,  2,  3,  4, //  60 -  69
	5,  6,  7,  8,  9, 10, 11, 12, 13, 14, //  70 -  79
	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, //  80 -  89
	25,  0,  0,  0,  0,  0,  0, 26, 27, 28, //  90 -  99
	29, 30, 31, 32, 33, 34, 35, 36, 37, 38, // 100 - 109
	39, 40, 41, 42, 43, 44, 45, 46, 47, 48, // 110 - 119
	49, 50, 51,  0,  0,  0,  0,  0		// 120 - 127
};

enum
{
	UNABLE_TO_OPEN_INPUT_FILE,
	UNABLE_TO_OPEN_OUTPUT_FILE,
	UNABLE_TO_CREATE_OUTPUTBUFFER
};

class CBase64
{
public:
	CBase64 ();

	unsigned int CalculateRecquiredEncodeOutputBufferSize (unsigned int p_InputByteCount);
	unsigned int CalculateRecquiredDecodeOutputBufferSize (char* p_pInputBufferString);

	void EncodeByteTriple  (char* p_pInputBuffer, unsigned int InputCharacters, char* p_pOutputBuffer);
	unsigned int DecodeByteQuartet (char* p_pInputBuffer, char* p_pOutputBuffer);

	void EncodeBuffer (char* p_pInputBuffer, unsigned int p_InputBufferLength, char*p_pOutputBufferString);
	unsigned int DecodeBuffer (char* p_pInputBufferString, char* p_pOutputBuffer);

	unsigned int CreateMatchingEncodingBuffer (unsigned int p_InputByteCount, char** p_ppEncodingBuffer);
	unsigned int CreateMatchingDecodingBuffer (char* p_pInputBufferString, char** p_ppDecodingBuffer);

	unsigned int EncodeFile (char* p_pSourceFileName, char* p_pEncodedFileName);
	unsigned int DecodeFile (char* p_pSourceFileName, char* p_pDecodedFileName);
};

/************************************************
*						*
* CBase64.cpp					*
* Base 64 de- and encoding class		*
*						*
* ============================================  *
*						*
* This class was written on 28.05.2003		*
* by Jan Raddatz [jan-raddatz@web.de]		*
*						*
* ============================================  *
*						*
* Copyright (c) by Jan Raddatz			*
* This class was published @ codeguru.com	*
* 28.05.2003					*
*						*
************************************************/
#include "stdafx.h"
#include "CBase64.h"


CBase64::CBase64 ()
{
}

unsigned int CBase64::CalculateRecquiredEncodeOutputBufferSize (unsigned int p_InputByteCount)
{
	div_t result = div (p_InputByteCount, 3);

	unsigned int RecquiredBytes = 0;
	if (result.rem == 0)
	{
		// Number of encoded characters
		RecquiredBytes = result.quot * 4;

		// CRLF -> "\r\n" each 76 characters
		result = div (RecquiredBytes, 76);
		RecquiredBytes += result.quot * 2;

		// Terminating null for the Encoded String
		RecquiredBytes += 1;

		return RecquiredBytes;
	}
	else
	{
		// Number of encoded characters
		RecquiredBytes = result.quot * 4 + 4;

		// CRLF -> "\r\n" each 76 characters
		result = div (RecquiredBytes, 76);
		RecquiredBytes += result.quot * 2;

		// Terminating null for the Encoded String
		RecquiredBytes += 1;

		return RecquiredBytes;
	}
}

unsigned int CBase64::CalculateRecquiredDecodeOutputBufferSize (char* p_pInputBufferString)
{
	unsigned int BufferLength = strlen (p_pInputBufferString);

	div_t result = div (BufferLength, 4);

	if (p_pInputBufferString [BufferLength - 1] != '=')
	{
		return result.quot * 3;
	}
	else
	{
		if (p_pInputBufferString [BufferLength - 2] == '=')
		{
			return result.quot * 3 - 2;
		}
		else
		{
			return result.quot * 3 - 1;
		}
	}
}

void CBase64::EncodeByteTriple (char* p_pInputBuffer, unsigned int InputCharacters, char* p_pOutputBuffer)
{
	unsigned int mask = 0xfc000000;
	unsigned int buffer = 0;


	char* temp = (char*) &buffer;
	temp [3] = p_pInputBuffer [0];
	if (InputCharacters > 1)
		temp [2] = p_pInputBuffer [1];
	if (InputCharacters > 2)
		temp [1] = p_pInputBuffer [2];

	switch (InputCharacters)
	{
	case 3:
		{
			p_pOutputBuffer [0] = BASE64_ALPHABET [(buffer & mask) >> 26];
			buffer = buffer << 6;
			p_pOutputBuffer [1] = BASE64_ALPHABET [(buffer & mask) >> 26];
			buffer = buffer << 6;
			p_pOutputBuffer [2] = BASE64_ALPHABET [(buffer & mask) >> 26];
			buffer = buffer << 6;
			p_pOutputBuffer [3] = BASE64_ALPHABET [(buffer & mask) >> 26];
			break;
		}
	case 2:
		{
			p_pOutputBuffer [0] = BASE64_ALPHABET [(buffer & mask) >> 26];
			buffer = buffer << 6;
			p_pOutputBuffer [1] = BASE64_ALPHABET [(buffer & mask) >> 26];
			buffer = buffer << 6;
			p_pOutputBuffer [2] = BASE64_ALPHABET [(buffer & mask) >> 26];
			p_pOutputBuffer [3] = '=';
			break;
		}
	case 1:
		{
			p_pOutputBuffer [0] = BASE64_ALPHABET [(buffer & mask) >> 26];
			buffer = buffer << 6;
			p_pOutputBuffer [1] = BASE64_ALPHABET [(buffer & mask) >> 26];
			p_pOutputBuffer [2] = '=';
			p_pOutputBuffer [3] = '=';
			break;
		}
	}
}

unsigned int CBase64::DecodeByteQuartet (char* p_pInputBuffer, char* p_pOutputBuffer)
{
	unsigned int buffer = 0;

	if (p_pInputBuffer[3] == '=')
	{
		if (p_pInputBuffer[2] == '=')
		{
			buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[0]]) << 6;
			buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[1]]) << 6;
			buffer = buffer << 14;

			char* temp = (char*) &buffer;
			p_pOutputBuffer [0] = temp [3];

			return 1;
		}
		else
		{
			buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[0]]) << 6;
			buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[1]]) << 6;
			buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[2]]) << 6;
			buffer = buffer << 8;

			char* temp = (char*) &buffer;
			p_pOutputBuffer [0] = temp [3];
			p_pOutputBuffer [1] = temp [2];

			return 2;
		}
	}
	else
	{
		buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[0]]) << 6;
		buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[1]]) << 6;
		buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[2]]) << 6;
		buffer = (buffer | BASE64_DEALPHABET [p_pInputBuffer[3]]) << 6; 
		buffer = buffer << 2;

		char* temp = (char*) &buffer;
		p_pOutputBuffer [0] = temp [3];
		p_pOutputBuffer [1] = temp [2];
		p_pOutputBuffer [2] = temp [1];

		return 3;
	}

	return -1;
}

void CBase64::EncodeBuffer(char* p_pInputBuffer, unsigned int p_InputBufferLength, char* p_pOutputBufferString)
{
	unsigned int FinishedByteQuartetsPerLine = 0;
	unsigned int InputBufferIndex  = 0;
	unsigned int OutputBufferIndex = 0;

	memset (p_pOutputBufferString, 0, CalculateRecquiredEncodeOutputBufferSize (p_InputBufferLength));

	while (InputBufferIndex < p_InputBufferLength)
	{
		if (p_InputBufferLength - InputBufferIndex <= 2)
		{
			FinishedByteQuartetsPerLine ++;
			EncodeByteTriple (p_pInputBuffer + InputBufferIndex, p_InputBufferLength - InputBufferIndex, p_pOutputBufferString + OutputBufferIndex);
			break;
		}
		else
		{
			FinishedByteQuartetsPerLine++;
			EncodeByteTriple (p_pInputBuffer + InputBufferIndex, 3, p_pOutputBufferString + OutputBufferIndex);
			InputBufferIndex  += 3;
			OutputBufferIndex += 4;
		}

		if (FinishedByteQuartetsPerLine == 19)
		{
			p_pOutputBufferString [OutputBufferIndex  ] = '\r';
			p_pOutputBufferString [OutputBufferIndex+1] = '\n';
			p_pOutputBufferString += 2;
			FinishedByteQuartetsPerLine = 0;
		}
	}
}

unsigned int CBase64::DecodeBuffer (char* p_pInputBufferString, char* p_pOutputBuffer)
{
	unsigned int InputBufferIndex  = 0;
	unsigned int OutputBufferIndex = 0;
	unsigned int InputBufferLength = strlen (p_pInputBufferString);

	char ByteQuartet [4];

	while (InputBufferIndex < InputBufferLength)
	{
		for (int i = 0; i < 4; i++)
		{
			ByteQuartet [i] = p_pInputBufferString [InputBufferIndex];

			// Ignore all characters except the ones in BASE64_ALPHABET
			if ((ByteQuartet [i] >= 48 && ByteQuartet [i] <=  57) ||
				(ByteQuartet [i] >= 65 && ByteQuartet [i] <=  90) ||
				(ByteQuartet [i] >= 97 && ByteQuartet [i] <= 122) ||
				ByteQuartet [i] == '+' || ByteQuartet [i] == '/' || ByteQuartet [i] == '=')
			{
			}
			else
			{
				// Invalid character
				i--;
			}

			InputBufferIndex++;
		}

		OutputBufferIndex += DecodeByteQuartet (ByteQuartet, p_pOutputBuffer + OutputBufferIndex);
	}

	// OutputBufferIndex gives us the next position of the next decoded character
	// inside our output buffer and thus represents the number of decoded characters
	// in our buffer.
	return OutputBufferIndex;
}

unsigned int CBase64::CreateMatchingEncodingBuffer (unsigned int p_InputByteCount, char** p_ppEncodingBuffer)
{
	unsigned int Size = CalculateRecquiredEncodeOutputBufferSize (p_InputByteCount);
	(*p_ppEncodingBuffer) = (char*) malloc (Size);
	memset (*p_ppEncodingBuffer, 0, Size);
	return Size;
}

unsigned int CBase64::CreateMatchingDecodingBuffer (char* p_pInputBufferString, char** p_ppDecodingBuffer)
{
	unsigned int Size = CalculateRecquiredDecodeOutputBufferSize (p_pInputBufferString);
	(*p_ppDecodingBuffer) = (char*) malloc (Size+1);
	memset (*p_ppDecodingBuffer, 0, Size+1);
	return Size+1;
}

unsigned int CBase64::EncodeFile (char* p_pSourceFileName, char* p_pEncodedFileName)
{
	CFile InputFile;
	CFile OutputFile;

	if (!InputFile.Open (p_pSourceFileName, CFile::modeRead))
		return UNABLE_TO_OPEN_INPUT_FILE;

	if (!OutputFile.Open (p_pEncodedFileName, CFile::modeCreate|CFile::modeWrite))
		return UNABLE_TO_OPEN_OUTPUT_FILE;

	char InputBuffer [19 * 3];
	char* pOutputBuffer;
	CreateMatchingEncodingBuffer (sizeof (InputBuffer), &pOutputBuffer);

	if (pOutputBuffer == 0)
		return UNABLE_TO_CREATE_OUTPUTBUFFER;

	unsigned int ReadBytes = 0;
	while ((ReadBytes = InputFile.Read (InputBuffer, sizeof (InputBuffer))) != 0)
	{
		EncodeBuffer (InputBuffer, ReadBytes, pOutputBuffer);
		OutputFile.Write (pOutputBuffer, strlen (pOutputBuffer));
	}

	OutputFile.Flush ();
	OutputFile.Close ();
	InputFile.Close  ();

	return 0;
}

unsigned int CBase64::DecodeFile (char* p_pSourceFileName, char* p_pDecodedFileName)
{
	CStdioFile	InputFile;
	CFile		OutputFile;

	if (!InputFile.Open (p_pSourceFileName, CFile::modeRead))
		return UNABLE_TO_OPEN_INPUT_FILE;

	if (!OutputFile.Open (p_pDecodedFileName, CFile::modeCreate|CFile::modeWrite))
		return UNABLE_TO_OPEN_OUTPUT_FILE;

	CString InputBuffer;
	char	OutputBuffer[64];

	unsigned int ReadBytes = 0;
	while ((ReadBytes = InputFile.ReadString (InputBuffer)) != 0)
	{
		InputBuffer.Remove ('\r');
		InputBuffer.Remove ('\n');
		unsigned int DecodedBytes = DecodeBuffer ((LPTSTR) (LPCTSTR) InputBuffer, OutputBuffer);
		OutputFile.Write (&OutputBuffer [0], DecodedBytes);
	}

	OutputFile.Flush ();
	OutputFile.Close ();
	InputFile.Close  ();

	return 0;
}

参考网站：

1.Base64-维基百科（ http://zh.wikipedia.org/wiki/Base64）
2. BASE 64 Decoding and Encoding Class2003 (http://www.codeguru.com/cpp/cpp/algorithms/article.php/c5099 )


luxiaoxun
关注
专栏目录
c++实现base64算法加密解密
06-18
c++实现base64算法加密解密，不需要修改，直接运行即可
C/C++学习 -- Base64算法
weixin_41489908的博客
10-07 2543
这两个示例中的C和C++代码都实现了Base64编码，将原始数据转换为Base64格式的字符串。Base64编码的原理非常简单，它将3个字节的二进制数据分为4个6位的块，然后将这些6位块映射到Base64字符集中的相应字符。可打印字符: Base64编码产生的字符全部来自可打印ASCII字符集，这意味着编码后的数据可以轻松地嵌入到文本中，不会引起编码后数据的不可读性。固定长度: Base64编码的结果长度总是4的倍数，这有助于对齐和分割编码后的数据。将6位块映射到Base64字符集中的字符。
C/C++编程：实现Base64编码/解码
OceanStar的博客
05-09 2万+
Bse64是一种以64个可打印字符对二进制数据进行编码的编码算法。base64在对数据进行编码时以三个8位字符型数据为一组，取这三个字符型数据的ASCII码，然后以6位为一组组成4个新的数据，这4个新的数据有6位，所以它的最大值为2^6=64。我们以4个6位数据的十进制数从base64表中得到最终编码后的字符。 Base64 编码表 由于base64编码是将编码前的3*8位数据，分解成4个6位的数据，所以经过base64编码后的字符串长度是4的倍数。但往往我们进行编码的数据长度并不是3的倍数，这就造成了“
Base64编解码及C++代码实现
mickey2007的博客
03-25 4059
Base64是一种二进制到文本的编码方式。如果要更具体一点的话，可以认为它是一种将byte数组编码为字符串的方法，而且编码出的字符串只包含ASCII基础字符。例如字符串 mickey0380 对应的Base64为 bWlja2V5MDM4MA==。其中那个 = 比较特殊，是填充符。值得注意的是Base64不是加密算法，其仅仅是一种编码方式，算法也是公开的，所以不能依赖它进行加密。
C++——实现base64编码
qq_46095850的博客
02-01 2910
C++——实现base64编码 不废话，直接开整 使用C++的文件操作，读取图片，实现base64编码，编码结果打印到控制台（未实现文件写入），测试可通过????图片转Base64编码 - 在线工具 - OKTools 代码如下 #include <iostream> #include <fstream> #define MAX 1200 using namespace std; const char *base64_code = "ABCDEFGHIJKLMNOPQRSTUVW
Base64 C++实现
LINKAIS的博客
06-22 3143
Base64
BASE64算法基于C++控制台实现
08-27
BASE64算法基于C++控制台实现
BASE64算法基于C++MFC实现
08-27
BASE64算法基于C++MFC实现
c++如何实现Base64算法
01-19
Base64算法 Base64编码要求把3个8位字节（3*8=24）转化为4个6位的字节（4*6=24），之后在6位的前面补两个0，形成8位一个字节的形式。 Base64类 函数： unsigned int CreateMatchingEncodingBuffer (unsigned int ...
base64的C++实现
zyj_zhouyongjun183的博客
09-20 2583
base64简介base64网络上已经有很多人有讲述，下面摘录wiki上的简述： Base64是一种基于64个可打印字符来表示二进制数据的表示方法。由于2的6次方等于64，所以每6个比特为一个单元，对应某个可打印字符。三个字节有24个比特，对应于4个Base64单元，即3个字节可表示4个可打印字符。它可用来作为电子邮件的传输编码。在Base64中的可打印字符包括字母A-Z、a-z、数字0-9，这
base64编码c++实现
watqw的博客
09-20 2904
base64编码原理 base64编码按照三个字节为一组，编码成四个字节。如果不够三个字节，则两个字节编码成三个字节加上一个‘=’，一个字节编码成两个字节加上‘==’。 首先将三个字节转换成二进制，共24位。然后，将24位分成四组，每组6个位，并在前面添加00，组成一个字节，共四个字节。由于分成的四个字节只有6位，故最大小于64。然后，按照表，将分成的四个字节代换成可打印字符。 代换表为 0 : A 1 : B 2 : C 3 : D 4 : E 5 : F 6 : G 7 : H 8 : I 9
基于c++实现的base64编解码过程详解
qq_43373952的博客
08-17 1186
base64编码是一种基于不可见字符编码成可见字符，再将可见字符解码成不可见字符串的方法。也可当作一种简单的加密解密过程，通常用于编码后作为数据传输，接收方再进行解码，从而还原数据。下面我们直接上干货。
Base64编解码及其C++实现
热门推荐
FlushHip
09-07 2万+
这两天在为公司的框架添加一个Base64加解密的模块，于是就想分享一下Base64的原理及自己的C++实现，借鉴了poco库。博文中的代码都是这两天写的代码的简洁版，可以完成Base64的编解码，方便易用。 不推荐造轮子，但是轮子在别的车上，你得自己拆下来，然后根据自己车的尺寸DIY你的轮子，安在自己的车上，当然，你还需要了解这个轮子的原理，万一哪天轮子坏了要你来修呢。 Base64简介 B...
base64编码解码器【C++】
ljl2107的博客
09-09 5569
base64编解码器，C+++++++++++++++C
base64编解码
how0723的博客
12-18 304
#include &lt;string&gt; void base64Decode(const std::string &amp;input, std::string &amp;output) { //解码表 const char DecodeTable[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,...
16进制转Base64的实现原理及代码
迷失蒲公英
05-07 3521
随着计算机技术的发展，数据的存储和传输方式也在不断更新，其中十六进制字符串和Base64编码是两种常见的数据表示方式。本文将介绍16进制字符串和Base64编码的原理，并提供Java代码实现16进制字符串转Base64的方法。
用C/C++实现Base64编码和解码
OrientalGlass的博客
12-19 4568
2022.12.19日,看了一下base64原理,然后想用代码实现一下,改了好久的bug终于完美成功了。
C++实现BASE64编码及解码
最新发布
download3564124的博客
04-23 1594
/[密文]第4字节的345678位组成明文第3字节的低6位,[密文]第3字节的78位组成明文第3字节的高2位.//[密文]第3字节的3456位组成明文第2字节的低4位,[密文]第2字节的5678位组成明文第2字节的高4位.//[密文]第2字节的34位组成明文第1字节的低2位,[密文]第1字节的345678位组成明文第1字节的高6位.//[密文]1~4字节中仅后6位是需要的字节位,共24位(即转换后的3字节);//对明文进行编码,每3字节明文转换成4字节编码文本,不足3字节的部分补充“填充符”.
C++ 使用base64进行编码和解码
小米的修行之路
08-01 3454
使用base64对中文或者英文数据进行编码和解密操作
C++实现Base64算法详解及应用
在C++中实现Base64算法是网络通信和数据安全中的常见操作，特别是在需要保护敏感信息传输场景中。Base64编码是一种将二进制数据转换为可打印字符的机制，常用于跨平台数据交换，如在URL、电子邮件、HTTP头部等地方。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值