rtmpdump源代码分析------HandShake

最新推荐文章于 2023-05-10 11:31:41 发布
最新推荐文章于 2023-05-10 11:31:41 发布
阅读量193 收藏
点赞数
分类专栏： rtmp协议
原文链接：https://blog.csdn.net/xwjazjx1314/article/details/51518094?ops_request_misc=%7B%22request%5Fid%22%3A%22158207580619725222407291%22%2C%22scm%22%3A%2220140713.130056874..%22%7D&request_id=158207580619725222407291&biz_id=0&utm_source=distribute.pc_search_res
版权

HandShake的流程图：

１：握手以客户端发送 C0 和 C1 块开始。
２：客户端必须等待接收到 S1 才能发送 C2。
３：客户端必须等待接收到 S2 才能发送任何其他数据。
４：服务器端必须等待接收到 C0 才能发送 S0 和 S1，也可以等待接收到 C1 再发送 S0 和 S1。服务器端必须等待接收到 C1 才能发送 S2。服务器端必须等待接收到 C2 才能发送任何其他数据。
C0 和 S0 的格式
C0 和 S0 包都是一个单一的八位字节，以一个单独的八位整型域进行处理：
在这里插入图片描述
以下是 C0/S0 包中的字段：
版本号 (八位)：在 C0 中，这一字段指示出客户端要求的 RTMP 版本号。在 S0 中，这一字段指示出服务器端选择的 RTMP 版本号。本文档中规范的版本号为 3。0、1、2 三个值是由早期其他产品使用的，是废弃值；4 - 31 被保留为 RTMP 协议的未来实现版本使用；32 - 255 不允许使用 (以区分开 RTMP 和其他常以一个可打印字符开始的文本协议)。无法识别客户端所请求版本号的服务器应该以版本 3 响应，(收到响应的) 客户端可以选择降低到版本 3，或者放弃握手。
C1 和 S1 的格式
C1 和 S1 数据包的长度都是 1536 字节，包含以下字段：
在这里插入图片描述
Time (四个字节)：这个字段必须包含终端在 S1 (给 C2) 或者 C1 (给 S2) 发的 timestamp。
Time2 (四个字节)：这个字段必须包含终端先前发出数据包 (s1 或者 c1) timestamp。
Random echo (1528 个字节)：这个字段必须包含终端发的 S1 (给 C2) 或者 S2 (给 C1) 的随机数。两端都可以一起使用 time 和 time2 字段再加当前 timestamp 以快速估算带宽和/或者连接延迟，但这不太可能是有多大用处。
握手示意图
在这里插入图片描述
如果觉得上面的流程相对来说比较难理解的话：

代码的实现:

static int HandShake(RTMP * r, int FP9HandShake)
{
	int i, offalg = 0;
	int dhposClient = 0;
	int digestPosClient = 0;
	int encrypted = r->Link.protocol & RTMP_FEATURE_ENC;
 
	RC4_handle keyIn = 0;
	RC4_handle keyOut = 0;
 
	int32_t *ip;
	uint32_t uptime;
 
	uint8_t clientbuf[RTMP_SIG_SIZE + 4], *clientsig = clientbuf + 4;
	uint8_t serversig[RTMP_SIG_SIZE], client2[RTMP_SIG_SIZE], *reply;
	uint8_t type;
	getoff *getdh = NULL, *getdig = NULL;
 
	if (encrypted || r->Link.SWFSize)
		FP9HandShake = TRUE;//加密的
	else
		FP9HandShake = FALSE;//普通的
 
	r->Link.rc4keyIn = r->Link.rc4keyOut = 0;
 
	if (encrypted)
	{
		clientsig[-1] = 0x06; /* 0x08 is RTMPE as well */
		offalg = 1;
	}
	else
		clientsig[-1] = 0x03;//普通rtmp的Version
 
	uptime = htonl(RTMP_GetTime());//获取的时间戳
	memcpy(clientsig, &uptime, 4);
 
	if (FP9HandShake)
	{
		/* set version to at least 9.0.115.0 */
		if (encrypted)
		{
			clientsig[4] = 128;
			clientsig[6] = 3;
		}
		else
		{
			clientsig[4] = 10;
			clientsig[6] = 45;
		}
		clientsig[5] = 0;
		clientsig[7] = 2;
 
		RTMP_Log(RTMP_LOGDEBUG, "%s: Client type: %02X", __FUNCTION__, clientsig[-1]);
		getdig = digoff[offalg];
		getdh = dhoff[offalg];
	}
	else
	{
		memset(&clientsig[4], 0, 4);//zero,占据４ byte
	}
 
	/* generate random data */
#ifdef _DEBUG
	memset(clientsig+8, 0, RTMP_SIG_SIZE-8);
#else
	ip = (int32_t *)(clientsig + 8);//从第八位开始，随机数据，进行填充clientsig
	for (i = 2; i < RTMP_SIG_SIZE / 4; i++)
		*ip++ = rand();
#endif
 
	/* set handshake digest */
	if (FP9HandShake)
	{
		if (encrypted)
		{
			/* generate Diffie-Hellmann parameters */
			r->Link.dh = DHInit(1024);
			if (!r->Link.dh)
			{
				RTMP_Log(RTMP_LOGERROR, "%s: Couldn't initialize Diffie-Hellmann!", __FUNCTION__);
				return FALSE;
			}
 
			dhposClient = getdh(clientsig, RTMP_SIG_SIZE);
			RTMP_Log(RTMP_LOGDEBUG, "%s: DH pubkey position: %d", __FUNCTION__, dhposClient);
 
			if (!DHGenerateKey(r->Link.dh))
			{
				RTMP_Log(RTMP_LOGERROR, "%s: Couldn't generate Diffie-Hellmann public key!", __FUNCTION__);
				return FALSE;
			}
 
			if (!DHGetPublicKey(r->Link.dh, &clientsig[dhposClient], 128))
			{
				RTMP_Log(RTMP_LOGERROR, "%s: Couldn't write public key!", __FUNCTION__);
				return FALSE;
			}
		}
 
		digestPosClient = getdig(clientsig, RTMP_SIG_SIZE); /* reuse this value in verification */
		RTMP_Log(RTMP_LOGDEBUG, "%s: Client digest offset: %d", __FUNCTION__, digestPosClient);
 
		CalculateDigest(digestPosClient, clientsig, GenuineFPKey, 30, &clientsig[digestPosClient]);
 
		RTMP_Log(RTMP_LOGDEBUG, "%s: Initial client digest: ", __FUNCTION__);
		RTMP_LogHex(RTMP_LOGDEBUG, clientsig + digestPosClient,
		SHA256_DIGEST_LENGTH);
	}
 
#ifdef _DEBUG
	RTMP_Log(RTMP_LOGDEBUG, "Clientsig: ");
	RTMP_LogHex(RTMP_LOGDEBUG, clientsig, RTMP_SIG_SIZE);
#endif
 
	//sed to rtmp server,主要发送的是c0+c1,其中c0为version,c1为1536 byte,包裹时间戳以及zero及填充的信息
	if (!WriteN(r, (char *)clientsig - 1, RTMP_SIG_SIZE + 1))
		return FALSE;
 
	//recv version,一般是0x03 or 0x06
	if (ReadN(r, (char *)&type, 1) != 1) /* 0x03 or 0x06 */
		return FALSE;
 
	RTMP_Log(RTMP_LOGDEBUG, "%s: Type Answer   : %02X", __FUNCTION__, type);
	//比较版本是否一致，也就是发送的c0 给服务器，服务器寻找所支持的版本后，返回给client.
	if (type != clientsig[-1])
		RTMP_Log(RTMP_LOGWARNING, "%s: Type mismatch: client sent %d, server answered %d", __FUNCTION__, clientsig[-1], type);
	//获取Ｓ1的数据，这部分的数据，用于Ｃ２发送的数据.
	if (ReadN(r, (char *)serversig, RTMP_SIG_SIZE) != RTMP_SIG_SIZE)
		return FALSE;
 
	/* decode server response */
	memcpy(&uptime, serversig, 4);
	uptime = ntohl(uptime);//大小端转换
 
	RTMP_Log(RTMP_LOGDEBUG, "%s: Server Uptime : %d", __FUNCTION__, uptime);
	RTMP_Log(RTMP_LOGDEBUG, "%s: FMS Version   : %d.%d.%d.%d", __FUNCTION__, serversig[4], serversig[5], serversig[6], serversig[7]);
 
	if (FP9HandShake && type == 3 && !serversig[4])
		FP9HandShake = FALSE;
 
#ifdef _DEBUG
	RTMP_Log(RTMP_LOGDEBUG, "Server signature:");
	RTMP_LogHex(RTMP_LOGDEBUG, serversig, RTMP_SIG_SIZE);
#endif
 
	if (FP9HandShake)
	{
		uint8_t digestResp[SHA256_DIGEST_LENGTH];
		uint8_t *signatureResp = NULL;
 
		/* we have to use this signature now to find the correct algorithms for getting the digest and DH positions */
		int digestPosServer = getdig(serversig, RTMP_SIG_SIZE);
 
		if (!VerifyDigest(digestPosServer, serversig, GenuineFMSKey, 36))
		{
			RTMP_Log(RTMP_LOGWARNING, "Trying different position for server digest!");
			offalg ^= 1;
			getdig = digoff[offalg];
			getdh = dhoff[offalg];
			digestPosServer = getdig(serversig, RTMP_SIG_SIZE);
 
			if (!VerifyDigest(digestPosServer, serversig, GenuineFMSKey, 36))
			{
				RTMP_Log(RTMP_LOGERROR, "Couldn't verify the server digest"); /* continuing anyway will probably fail */
				return FALSE;
			}
		}
 
		/* generate SWFVerification token (SHA256 HMAC hash of decompressed SWF, key are the last 32 bytes of the server handshake) */
		if (r->Link.SWFSize)
		{
			const char swfVerify[] = {0x01, 0x01};
			char *vend = r->Link.SWFVerificationResponse + sizeof(r->Link.SWFVerificationResponse);
 
			memcpy(r->Link.SWFVerificationResponse, swfVerify, 2);
			AMF_EncodeInt32(&r->Link.SWFVerificationResponse[2], vend, r->Link.SWFSize);
			AMF_EncodeInt32(&r->Link.SWFVerificationResponse[6], vend, r->Link.SWFSize);
			HMACsha256(r->Link.SWFHash, SHA256_DIGEST_LENGTH, &serversig[RTMP_SIG_SIZE - SHA256_DIGEST_LENGTH],
			SHA256_DIGEST_LENGTH, (uint8_t *)&r->Link.SWFVerificationResponse[10]);
		}
 
		/* do Diffie-Hellmann Key exchange for encrypted RTMP */
		if (encrypted)
		{
			/* compute secret key */
			uint8_t secretKey[128] = {0};
			int len, dhposServer;
 
			dhposServer = getdh(serversig, RTMP_SIG_SIZE);
			RTMP_Log(RTMP_LOGDEBUG, "%s: Server DH public key offset: %d", __FUNCTION__, dhposServer);
			len = DHComputeSharedSecretKey(r->Link.dh, &serversig[dhposServer], 128, secretKey);
			if (len < 0)
			{
				RTMP_Log(RTMP_LOGDEBUG, "%s: Wrong secret key position!", __FUNCTION__);
				return FALSE;
			}
 
			RTMP_Log(RTMP_LOGDEBUG, "%s: Secret key: ", __FUNCTION__);
			RTMP_LogHex(RTMP_LOGDEBUG, secretKey, 128);
 
			InitRC4Encryption(secretKey, (uint8_t *)&serversig[dhposServer], (uint8_t *)&clientsig[dhposClient], &keyIn, &keyOut);
		}
 
		reply = client2;
#ifdef _DEBUG
		memset(reply, 0xff, RTMP_SIG_SIZE);
#else
		ip = (int32_t *)reply;
		for (i = 0; i < RTMP_SIG_SIZE / 4; i++)
			*ip++ = rand();
#endif
		/* calculate response now */
		signatureResp = reply + RTMP_SIG_SIZE - SHA256_DIGEST_LENGTH;
 
		HMACsha256(&serversig[digestPosServer], SHA256_DIGEST_LENGTH, GenuineFPKey, sizeof(GenuineFPKey), digestResp);
		HMACsha256(reply, RTMP_SIG_SIZE - SHA256_DIGEST_LENGTH, digestResp,
		SHA256_DIGEST_LENGTH, signatureResp);
 
		/* some info output */
		RTMP_Log(RTMP_LOGDEBUG, "%s: Calculated digest key from secure key and server digest: ", __FUNCTION__);
		RTMP_LogHex(RTMP_LOGDEBUG, digestResp, SHA256_DIGEST_LENGTH);
 
#ifdef FP10
		if (type == 8)
		{
			uint8_t *dptr = digestResp;
			uint8_t *sig = signatureResp;
			/* encrypt signatureResp */
			for (i = 0; i < SHA256_DIGEST_LENGTH; i += 8)
				rtmpe8_sig(sig + i, sig + i, dptr[i] % 15);
		}
#if 0
		else if (type == 9))
		{
			uint8_t *dptr = digestResp;
			uint8_t *sig = signatureResp;
			/* encrypt signatureResp */
			for (i=0; i<SHA256_DIGEST_LENGTH; i+=8)
			rtmpe9_sig(sig+i, sig+i, dptr[i] % 15);
		}
#endif
#endif
		RTMP_Log(RTMP_LOGDEBUG, "%s: Client signature calculated:", __FUNCTION__);
		RTMP_LogHex(RTMP_LOGDEBUG, signatureResp, SHA256_DIGEST_LENGTH);
	}
	else
	{
		reply = serversig;
#if 0
		uptime = htonl(RTMP_GetTime());
		memcpy(reply+4, &uptime, 4);
#endif
	}
 
#ifdef _DEBUG
	RTMP_Log(RTMP_LOGDEBUG, "%s: Sending handshake response: ",
			__FUNCTION__);
	RTMP_LogHex(RTMP_LOGDEBUG, reply, RTMP_SIG_SIZE);
#endif
	//send C2到服务器
	if (!WriteN(r, (char *)reply, RTMP_SIG_SIZE))
		return FALSE;
 
	/* 2nd part of handshake */
	//read到s2的内容
	if (ReadN(r, (char *)serversig, RTMP_SIG_SIZE) != RTMP_SIG_SIZE)
		return FALSE;
 
#ifdef _DEBUG
	RTMP_Log(RTMP_LOGDEBUG, "%s: 2nd handshake: ", __FUNCTION__);
	RTMP_LogHex(RTMP_LOGDEBUG, serversig, RTMP_SIG_SIZE);
#endif
 
	if (FP9HandShake)
	{
		uint8_t signature[SHA256_DIGEST_LENGTH];
		uint8_t digest[SHA256_DIGEST_LENGTH];
 
		if (serversig[4] == 0 && serversig[5] == 0 && serversig[6] == 0 && serversig[7] == 0)
		{
			RTMP_Log(RTMP_LOGDEBUG, "%s: Wait, did the server just refuse signed authentication?", __FUNCTION__);
		}
		RTMP_Log(RTMP_LOGDEBUG, "%s: Server sent signature:", __FUNCTION__);
		RTMP_LogHex(RTMP_LOGDEBUG, &serversig[RTMP_SIG_SIZE - SHA256_DIGEST_LENGTH],
		SHA256_DIGEST_LENGTH);
 
		/* verify server response */
		HMACsha256(&clientsig[digestPosClient], SHA256_DIGEST_LENGTH, GenuineFMSKey, sizeof(GenuineFMSKey), digest);
		HMACsha256(serversig, RTMP_SIG_SIZE - SHA256_DIGEST_LENGTH, digest,
		SHA256_DIGEST_LENGTH, signature);
 
		/* show some information */
		RTMP_Log(RTMP_LOGDEBUG, "%s: Digest key: ", __FUNCTION__);
		RTMP_LogHex(RTMP_LOGDEBUG, digest, SHA256_DIGEST_LENGTH);
 
#ifdef FP10
		if (type == 8)
		{
			uint8_t *dptr = digest;
			uint8_t *sig = signature;
			/* encrypt signature */
			for (i = 0; i < SHA256_DIGEST_LENGTH; i += 8)
				rtmpe8_sig(sig + i, sig + i, dptr[i] % 15);
		}
#if 0
		else if (type == 9)
		{
			uint8_t *dptr = digest;
			uint8_t *sig = signature;
			/* encrypt signatureResp */
			for (i=0; i<SHA256_DIGEST_LENGTH; i+=8)
			rtmpe9_sig(sig+i, sig+i, dptr[i] % 15);
		}
#endif
#endif
		RTMP_Log(RTMP_LOGDEBUG, "%s: Signature calculated:", __FUNCTION__);
		RTMP_LogHex(RTMP_LOGDEBUG, signature, SHA256_DIGEST_LENGTH);
		if (memcmp(signature, &serversig[RTMP_SIG_SIZE - SHA256_DIGEST_LENGTH],
		SHA256_DIGEST_LENGTH) != 0)
		{
			RTMP_Log(RTMP_LOGWARNING, "%s: Server not genuine Adobe!", __FUNCTION__);
			return FALSE;
		}
		else
		{
			RTMP_Log(RTMP_LOGDEBUG, "%s: Genuine Adobe Flash Media Server", __FUNCTION__);
		}
 
		if (encrypted)
		{
			char buff[RTMP_SIG_SIZE];
			/* set keys for encryption from now on */
			r->Link.rc4keyIn = keyIn;
			r->Link.rc4keyOut = keyOut;
 
			/* update the keystreams */
			if (r->Link.rc4keyIn)
			{
				RC4_encrypt(r->Link.rc4keyIn, RTMP_SIG_SIZE, (uint8_t * ) buff);
			}
 
			if (r->Link.rc4keyOut)
			{
				RC4_encrypt(r->Link.rc4keyOut, RTMP_SIG_SIZE, (uint8_t * ) buff);
			}
		}
	}
	else
	{
		//比较c1的内容跟s2的内容是否一致。
		//其实验证支持的协议版本号、服务器的时间戳等等。确保连接的对端真的是RTMP支持。
		if (memcmp(serversig, clientsig, RTMP_SIG_SIZE) != 0)
		{
			RTMP_Log(RTMP_LOGWARNING, "%s: client signature does not match!", __FUNCTION__);
		}
	}
 
	RTMP_Log(RTMP_LOGDEBUG, "%s: Handshaking finished....", __FUNCTION__);
	return TRUE;
}
没有飘柔不洗头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rtmp抓包工具
09-21
rtmpdump-2.3-windows.zip　rtmp抓包工具， 支持协议：rtmp/rtmpe/rtmps
RTMPdump（libRTMP）源代码分析 4： 连接第一步——握手（Hand Shake）
dianyimo9099的博客
10-22 223
注：此前写了一些列的分析RTMPdump（libRTMP）源代码的文章，在此列一个列表： RTMPdump 源代码分析 1： main()函数 RTMPDump（libRTMP）源代码分析 2：解析RTMP地址——RTMP_ParseURL() RTMPdump（libRTMP） 源代码分析 3： AMF编码 RTMPdump（libRTMP）源代码分析 4： 连接第...
RTMPDump（libRTMP）源代码分析 2：解析RTMP地址——RTMP_ParseURL()
cchao985771161的博客
02-27 224
===================================================== RTMPdump(libRTMP) 源代码分析系列文章： RTMPdump 源代码分析 1： main()函数 RTMPDump (libRTMP) 源代码分析2：解析RTMP地址——RTMP_ParseURL() RTMPdump (libRTMP) 源代码分析3： AMF编码 RTMPd...
rtmp数据抓取保存
07-11
rtmp rtmp协议 amf rtmp协议学习 可以学习rtmp协议与AMF协议 有疑问可以与我联系~
rtmp源码分析---握手
叮咚的博客
05-11 813
握手：
rtmpdump-2.3.rar_rtmpdump-2.3_arm64
09-21
rtmpdump是一款强大的RTMP协议数据抓取和分析工具，主要用于从RTMP流媒体服务器上下载或播放视频内容。在标题“rtmpdump-2.3.rar_rtmpdump-2.3_arm64”中，我们关注的是rtmpdump的2.3版本，这个版本是为arm64架构...
rtmpdump-2.3_add_note
09-20
rtmpdump-2.3 add useful notes for developers。rtmpdump is a toolkit for RTMP streams. All forms of RTMP are supported, including rtmp://, rtmpt://, rtmpe://, rtmpte://, and rtmps://.
nginx-rtmp-win32.rar
11-21
总结来说，"nginx-rtmp-win32.rar"提供了一个在Windows上快速搭建和运行RTMP直播服务器的解决方案，通过Nginx-RTMP模块，我们可以实现直播流的接收、转发、存储以及转换为适应不同设备的协议，从而构建起一套完整的...
obs-multi-rtmp_Windows_0.2.4.zip
07-10
OBS多路推流插件obs-multi-rtmp
nginx-rtmp-win32-master.zip
01-08
1. **下载Nginx-RTMP**：Nginx-RTMP-win32-master.zip包含了预编译的Windows版本Nginx服务器，以及Nginx-RTMP模块。 2. **配置Nginx**：解压后，需要编辑`nginx.conf`配置文件，添加RTMP模块的相关设置，如服务器...
安卓7.0 在加载某些https资源的时会出现证书验证错误OS Error(handshake.cc:)解决方案
曹世鑫的杂谈
05-10 789
安卓7.0 在加载某些https网站的时会出现类似这样的错误OS Error(handshake.cc:)
RTMPdump源码分析： HandShake(4)
mandagod的博客
12-06 421
函数调用结构图 RTMPDump (libRTMP)的整体的函数调用结构图如下图所示。 单击查看大图 详细分析 在这里分析一下RTMPdump（libRTMP）连接到支持RTMP协议的服务器的第一步：握手（Hand Shake）。 RTMP连接的过程曾经分析过：RTMP流媒体播放过程 在这里不再细说，分析一下位于han
rtmp学习-handshake
fxbjye的博客
07-25 1186
最近在学习OBS开源项目，借此学习流媒体方面的知识。 1)简介 rtmp 是Adobe公司为FLASH和服务器之间传输音视频数据开发的一种数据。基于TCP协议，使用1935默认端口。 2）一个RTMP连接已握手开始，握手以三个固定大小的块组成chunk[0]1字节，chunk[1]1536字节chunk[2]1536字节。客户端和服务端各自发送三个相同的块。client:c0,c1,c2;s
RTMP推流及协议学习
热门推荐
菜鸟的学习笔记
03-13 4万+
前期准备 了解RTMP定义 准备RTMPDump中的librtmp 使用openssl中的libssllibcrypto 推流工作 整体框架图 使用libtrmp提供的API 将streaming封装成为RTMP格式 进阶 RTMP client与RTMP server交互流程 RTMPDump源码分析 参考资料
rtmp握手过程
sxc1989的博客
03-04 1295
rtmp通信以握手开始，即客户端与服务端相互发消息块。其中客户端发送的消息块被指定为C0,C1,C2, 服务端发送的消息块指定为S1,S2,S3。握手顺序 客户端主动发送C0，C1；客户端必须等待S1到达才能发送C2;必须等待S2到达才能发送其他数据； 服务端必须等待C0到达才能发送S0和S1；必须等待C1到达才能发送S2；必须等待C2到达才能发送其他数据； C0和S0格式 长度：1字节 C0表示客
排查rtmp协议推流时握手bug
职场亮哥
03-12 523
转推流程序的过程：从一个观看地址拉流，然后推流到另一个推流地址。主要用于cdn之间转推，目前市面上大多数cdn厂商都愿意不支持动态转推，因此只能通过转推流程序进行转推。 bug现象：使用obs studio推流到微赞可以成功，但是使用Erlang版本的转推流程序推流到微赞却失败。 日志如下： 14:12:35.926 [debug] payload [{amf,["onBWDone",0,null]}], msgtype[command_msg_4_amf0] 14:12:35.949
RTMP 抓包分析
linux_arm_c的博客
09-28 1万+
交互流程为： 下图 Handshake部分为： 1、 客户端向服务端发送 C0、C1。 2、服务端相应S0、S1、S2。 3、客户端回应C2。 c0与s0格式 c0和s0包是一个1字节,可以看作是一个byte 目前rtmp版本定义为3,0-2是早期的专利产品所使用的值,现已经废弃,4-31是预留值,32-255是禁用值(这样做是为了区分基于文本的协议,因为这些协议通常
nginx-rtmp-module-master
最新发布
07-29
nginx-rtmp-module-master是一个开源的NGINX模块，它扩展了NGINX服务器的功能，使其能够支持实时流媒体传输。 该模块提供了一种流媒体服务器的框架，允许用户使用NGINX来构建自己的实时流媒体平台。通过nginx-rtmp-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值