遍历读取驱动的签名

于 2023-04-26 17:43:46 发布
阅读量239 收藏
点赞数 1
分类专栏： Windows 文章标签： windows 内核 安全 驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Misaka10046/article/details/130391235
版权

win7 X86

驱动

#include <ntifs.h>

#define DEVICE_NAME L"\\Device\\wangliang"
#define SYM_NAME L"\\??\\wangliang"

#define _COMM_ID 0x12345678

typedef struct _KLDR_DATA_TABLE_ENTRY {
	LIST_ENTRY InLoadOrderLinks;
	LIST_ENTRY exp;
	ULONG un;
	ULONG NonPagedDebugInfo;
	ULONG DllBase;
	ULONG EntryPoint;
	ULONG SizeOfImage;
	UNICODE_STRING FullDllName;
	UNICODE_STRING BaseDllName;
	ULONG Flags;
	USHORT LoadCount;
	USHORT __Undefined5;
	ULONG  __Undefined6;
	ULONG  CheckSum;
	ULONG  TimeDateStamp;
} KLDR_DATA_TABLE_ENTRY, * PKLDR_DATA_TABLE_ENTRY;


NTKERNELAPI NTSTATUS ObReferenceObjectByName(
	__in PUNICODE_STRING ObjectName,
	__in ULONG Attributes,
	__in_opt PACCESS_STATE AccessState,
	__in_opt ACCESS_MASK DesiredAccess,
	__in POBJECT_TYPE ObjectType,
	__in KPROCESSOR_MODE AccessMode, 
	__inout_opt PVOID ParseContext,
	__out PVOID* Object 
);


extern POBJECT_TYPE* IoDriverObjectType;

typedef struct _CommPackage {
	ULONG64 id;
	ULONG64 pid;
	ULONG DllBase;
	CHAR name[64];
	CHAR name2[64];
}CommPackage, * PCommPackage;

typedef NTSTATUS(NTAPI* CommCallback)(PCommPackage package);

CommCallback gCommCallback = NULL;


NTSTATUS DefDispatch(DEVICE_OBJECT* DeviceObject, IRP* Irp)
{
	Irp->IoStatus.Status = STATUS_SUCCESS;
	IoCompleteRequest(Irp, 0);
	return STATUS_SUCCESS;
}

NTSTATUS ReadDispatch(DEVICE_OBJECT* DeviceObject, IRP* Irp)
{
	//DbgBreakPoint();
	
	PIO_STACK_LOCATION ioStack = IoGetCurrentIrpStackLocation(Irp);
	LARGE_INTEGER ByteOffset = ioStack->Parameters.Read.ByteOffset;
	int Length = ioStack->Parameters.Read.Length;
	PCommPackage package = Irp->UserBuffer;
	NTSTATUS status = STATUS_UNSUCCESSFUL;
	
	PVOID DllBase = NULL;
	PKLDR_DATA_TABLE_ENTRY ldr = (PKLDR_DATA_TABLE_ENTRY)DeviceObject->DeviceExtension;
	PKLDR_DATA_TABLE_ENTRY pre = (PKLDR_DATA_TABLE_ENTRY)ldr->InLoadOrderLinks.Flink;
	PKLDR_DATA_TABLE_ENTRY next = (PKLDR_DATA_TABLE_ENTRY)pre->InLoadOrderLinks.Flink;

	if (package->pid > 1) {
		ULONG64 i = (ULONG64)1;
		for (; i < package->pid; i++) {
			next = (PKLDR_DATA_TABLE_ENTRY)next->InLoadOrderLinks.Flink;
		}
	}
	if (Length == sizeof(CommPackage) ) {

		UNICODE_STRING  driverName1 = next->FullDllName;
		UNICODE_STRING  driverName2 = next->BaseDllName;
		PDRIVER_OBJECT Driver = NULL;
		ANSI_STRING ansi_buffer_target = { 0 };

		//DbgBreakPoint();
		DllBase = next->DllBase;
		package->DllBase = DllBase;

		NTSTATUS status = ObReferenceObjectByName(&driverName1, FILE_ALL_ACCESS, 0, 0, *IoDriverObjectType, KernelMode, NULL, &Driver);//通过驱动的到驱动的对象

		if (package->id == _COMM_ID) {

			RtlUnicodeStringToAnsiString(&ansi_buffer_target, &driverName1, TRUE);
			strcpy(package->name, ansi_buffer_target.Buffer);
			RtlFreeAnsiString(&ansi_buffer_target);
			
			RtlUnicodeStringToAnsiString(&ansi_buffer_target, &driverName2, TRUE);			
			strcpy(package->name2, ansi_buffer_target.Buffer);
			RtlFreeAnsiString(&ansi_buffer_target);

		}
	
	};
	
	Irp->IoStatus.Information = 0;
	Irp->IoStatus.Status = status;
	IoCompleteRequest(Irp, 0);
	
	return status;
}
VOID DriverUnload(PDRIVER_OBJECT pDriver)
{
	UNICODE_STRING symName = { 0 };
	RtlInitUnicodeString(&symName, SYM_NAME);
	IoDeleteSymbolicLink(&symName);

	IoDeleteDevice(pDriver->DeviceObject);
	DbgPrint("END\r\n");
}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING pReg)
{
	PKLDR_DATA_TABLE_ENTRY ldr = (PKLDR_DATA_TABLE_ENTRY)pDriver->DriverSection;

	UNICODE_STRING unName = { 0 };
	RtlInitUnicodeString(&unName, DEVICE_NAME);

	UNICODE_STRING symName = { 0 };
	RtlInitUnicodeString(&symName, SYM_NAME);

	PDEVICE_OBJECT pDevice = NULL;

	NTSTATUS status = IoCreateDevice(pDriver, sizeof(PKLDR_DATA_TABLE_ENTRY)+1, &unName, FILE_DEVICE_UNKNOWN, FILE_DEVICE_SECURE_OPEN, FALSE, &pDevice);//创建一个驱动设备使用的设备对象
	
	if (!NT_SUCCESS(status))
	{
		DbgPrint("[db]:%x\r\n", status);
		return status;
	}

	memcpy(pDevice->DeviceExtension, ldr, sizeof(PKLDR_DATA_TABLE_ENTRY));
	status = IoCreateSymbolicLink(&symName, &unName);
	
	if (!NT_SUCCESS(status))
	{
		IoDeleteDevice(pDevice);
		DbgPrint("[db]:%x\r\n", status);
		return status;
	}

	pDevice->Flags &= ~DO_DEVICE_INITIALIZING;
	pDevice->Flags |= DO_BUFFERED_IO;

	pDriver->MajorFunction[IRP_MJ_CREATE] = DefDispatch;
	pDriver->MajorFunction[IRP_MJ_CLOSE] = DefDispatch;
	pDriver->MajorFunction[IRP_MJ_READ] = ReadDispatch;

	pDriver->DriverUnload = DriverUnload;
	
	return STATUS_SUCCESS;
}

R3

#ifndef UNICODE
#define UNICODE
#endif

#ifndef _UNICODE
#define _UNICODE
#endif

#define _WIN32_WINNT 0x0500
#define WINVER       0x0500

#include <windows.h>
#include <Softpub.h>
#include <Wincrypt.h>
#include <stdio.h>
#include <tchar.h>
#include<psapi.h>


#pragma comment(lib, "Crypt32.lib")
#pragma comment(lib, "Wintrust.lib")
#pragma comment(lib, "Psapi.lib")


#define SYM_NAME   "\\\\.\\wangliang"

typedef struct _CommPackage {
	ULONG64 id;
	ULONG64 pid;
	ULONG DllBase;
	CHAR name[64];
	CHAR name2[64];
}CommPackage, * PCommPackage;

#define _COMM_ID 0x12345678

LPTSTR GetCertificateDescription(PCCERT_CONTEXT pCertCtx)
{
	DWORD dwStrType;
	DWORD dwCount;
	LPTSTR szSubjectRDN = NULL;

	dwStrType = CERT_X500_NAME_STR;
	dwCount = CertGetNameString(pCertCtx,
		CERT_NAME_RDN_TYPE,
		0,
		&dwStrType,
		NULL,
		0);
	if (dwCount)
	{
		szSubjectRDN = (LPTSTR)LocalAlloc(0, dwCount * sizeof(TCHAR));
		CertGetNameString(pCertCtx,
			CERT_NAME_RDN_TYPE,
			0,
			&dwStrType,
			szSubjectRDN,
			dwCount);
	}

	return szSubjectRDN;
}


int main(int argc, _TCHAR* argv[])
{
	CommPackage packag;
	packag.id = _COMM_ID;
	packag.pid = (ULONG64)1;
	for (int i = 0; i < 64; i++) {
		packag.name[i] = 0;
	}
	HANDLE hDevice = CreateFileA(SYM_NAME, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	
	
	if (hDevice == NULL || hDevice == INVALID_HANDLE_VALUE)
	{
		printf("%d", hDevice);
		system("pause");
		return 0;
	}

	DWORD p = 0;
	

	ReadFile(hDevice, &packag, sizeof(CommPackage), &p, NULL);
	char First[64] = {0};
	strcpy_s(First, 64, packag.name);
	printf("%s\r\n", packag.name);
	
	do{
		
		packag.pid = packag.pid + 1;
		for (int i = 0; i < 64; i++) {
			packag.name[i] = 0;
		}
		for (int i = 0; i < 64; i++) {
			packag.name2[i] = 0;
		}
		ReadFile(hDevice, &packag, sizeof(CommPackage), &p, NULL);
		printf("%s %s\r\n", packag.name, packag.name2);
			
	

		char fullPath[256];
		char fullPath2[256];
		int j = 0;
		for (int i = 0; i < 256; i++) {
			fullPath[i] = 0;
			fullPath2[i] = 0;
		} 
		fullPath2[0] = 67;
		fullPath2[1] = 58;
		fullPath2[2] = 92;
		fullPath2[3] = 87;
		fullPath2[4] = 105;
		fullPath2[5] = 110;
		fullPath2[6] = 100;
		fullPath2[7] = 111;
		fullPath2[8] = 119;
		fullPath2[9] = 115;
		//_asm int 3;
		GetDeviceDriverFileNameA(packag.DllBase, fullPath, sizeof(fullPath));
		if (fullPath[0] == 92) {
			if (fullPath[1] == 83) {
				if (fullPath[2] == 121) {
					if (fullPath[3] == 115) {
						if (fullPath[4] == 116) {
							if (fullPath[5] == 101) {
								if (fullPath[6] == 109) {
									if (fullPath[7] == 82) {
										if (fullPath[8] == 111) {
											if (fullPath[9] == 111) {
												if (fullPath[10] == 116) {
													if (fullPath[11] == 92) {
														for (int i = 10; i < 240; i++) {
															fullPath2[i] = fullPath[i + 1];
															j = 1;
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
		
		if (j == 0) {
			int x = 0;
			_asm int 3;
			for (x = 0; x < 256; x++) {
				if (65 <= fullPath[x] && fullPath[x] <= 90) {
					break;
				}
			}
			for (int i = 0; i+x < 256; i++) {
				fullPath2[i] = fullPath[i+x];
			}
		}
//写的垃圾过滤。。

		printf("Full path for driver file is: %s\n", fullPath2);



		//_asm int 3;



		GUID guidAction = WINTRUST_ACTION_GENERIC_VERIFY_V2;
		WINTRUST_FILE_INFO sWintrustFileInfo;
		WINTRUST_DATA      sWintrustData;
		HRESULT            hr;

		if (argc != 2)
		{
			_tprintf(_T("Usage: VerifyExeSignature file_name\n"));
			//    return -1;
		}

		//_asm int 3;
		
		
		int size_needed = MultiByteToWideChar(CP_UTF8, 0, fullPath2, strlen(fullPath2), NULL, 0); // 获取需要的空间大小

		wchar_t* wstr = malloc(sizeof(wchar_t)*(size_needed + 1)); // 分配内存给wchar_t*

		memset(wstr,0, size_needed+1);

		MultiByteToWideChar(CP_UTF8, 0, fullPath2, strlen(fullPath2), wstr, size_needed); // 进行转换


		wstr[size_needed] = L'\0'; // 添加结尾字符，形成一个null-terminated字符串

		
		argv[1] = wstr;
		memset((void*)&sWintrustFileInfo, 0x00, sizeof(WINTRUST_FILE_INFO));
		memset((void*)&sWintrustData, 0x00, sizeof(WINTRUST_DATA));

		sWintrustFileInfo.cbStruct = sizeof(WINTRUST_FILE_INFO);
		sWintrustFileInfo.pcwszFilePath = argv[1];
		sWintrustFileInfo.hFile = NULL;

		sWintrustData.cbStruct = sizeof(WINTRUST_DATA);
		sWintrustData.dwUIChoice = WTD_UI_NONE;
		sWintrustData.fdwRevocationChecks = WTD_REVOKE_NONE;
		sWintrustData.dwUnionChoice = WTD_CHOICE_FILE;
		sWintrustData.pFile = &sWintrustFileInfo;
		sWintrustData.dwStateAction = WTD_STATEACTION_VERIFY;

		hr = WinVerifyTrust((HWND)INVALID_HANDLE_VALUE, &guidAction, &sWintrustData);

		if (TRUST_E_NOSIGNATURE == hr)
		{
			_tprintf(_T("No signature found on the file.\n"));
		}
		else if (TRUST_E_BAD_DIGEST == hr)
		{
			_tprintf(_T("The signature of the file is invalid\n"));
		}
		else if (TRUST_E_PROVIDER_UNKNOWN == hr)
		{
			_tprintf(_T("No trust provider on this machine can verify this type of files.\n"));
		}
		else if (S_OK != hr)
		{
			_tprintf(_T("WinVerifyTrust failed with error 0x%.8X\n"), hr);
		}
		else
		{
			_tprintf(_T("File signature is OK.\n"));

			
			CRYPT_PROVIDER_DATA const* psProvData = NULL;
			CRYPT_PROVIDER_SGNR* psProvSigner = NULL;
			CRYPT_PROVIDER_CERT* psProvCert = NULL;
			FILETIME                   localFt;
			SYSTEMTIME                 sysTime;

			psProvData = WTHelperProvDataFromStateData(sWintrustData.hWVTStateData);
			if (psProvData)
			{
				psProvSigner = WTHelperGetProvSignerFromChain((PCRYPT_PROVIDER_DATA)psProvData, 0, FALSE, 0);
				if (psProvSigner)
				{
					FileTimeToLocalFileTime(&psProvSigner->sftVerifyAsOf, &localFt);
					FileTimeToSystemTime(&localFt, &sysTime);

					_tprintf(_T("Signature Date = %.2d/%.2d/%.4d at %.2d:%2.d:%.2d\n"), sysTime.wDay, sysTime.wMonth, sysTime.wYear, sysTime.wHour, sysTime.wMinute, sysTime.wSecond);

					psProvCert = WTHelperGetProvCertFromChain(psProvSigner, 0);
					if (psProvCert)
					{
						LPTSTR szCertDesc = GetCertificateDescription(psProvCert->pCert);
						if (szCertDesc)
						{
							_tprintf(_T("File Signer = %s\n"), szCertDesc);
							LocalFree(szCertDesc);
						}
					}

					if (psProvSigner->csCounterSigners)
					{
						_tprintf(_T("\n"));
						// Timestamp
						FileTimeToLocalFileTime(&psProvSigner->pasCounterSigners[0].sftVerifyAsOf, &localFt);
						FileTimeToSystemTime(&localFt, &sysTime);

						_tprintf(_T("Timestamp Date = %.2d/%.2d/%.4d at %.2d:%2.d:%.2d\n"), sysTime.wDay, sysTime.wMonth, sysTime.wYear, sysTime.wHour, sysTime.wMinute, sysTime.wSecond);
						psProvCert = WTHelperGetProvCertFromChain(&psProvSigner->pasCounterSigners[0], 0);
						if (psProvCert)
						{
							LPTSTR szCertDesc = GetCertificateDescription(psProvCert->pCert);
							if (szCertDesc)
							{
								_tprintf(_T("Timestamp Signer = %s\n"), szCertDesc);
								LocalFree(szCertDesc);
							}
						}
					}
				}
			}
		}

		sWintrustData.dwUIChoice = WTD_UI_NONE;
		sWintrustData.dwStateAction = WTD_STATEACTION_CLOSE;
		WinVerifyTrust((HWND)INVALID_HANDLE_VALUE, &guidAction, &sWintrustData);
		
		
		Sleep(1000);
	} while (strcmp(First, packag.name) != NULL);
		

	CloseHandle(hDevice);
	
	system("pause");
	return 0;
}

效果

在这里插入图片描述

0xwangliang
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
遍历系统中加载的驱动程序以及通过设备对象指针获取设备对象名称
Masimaro的专栏
03-01 2387
遍历系统中加载的驱动以及通过设备对象指针获取设备对象名称
win7-32、驱动模块遍历、驱动模块隐藏
Windows内核学习笔记
07-08 857
打印日志前缀，过滤掉不是我们的日志，只会显示我们自己的日志
简单地隐藏驱动分析
liujiayu2的专栏
06-30 1292
当系统加载一个驱动时，会为这个驱动建立一个_KLDR_DATA_TABLE_ENTRY结构体，DRIVER_OBJECT结构体的DriverSection成员指向这个结构体。以下是WRK中_KLDR_DATA_TABLE_ENTRY结构体的定义： typedef struct _KLDR_DATA_TABLE_ENTRY {     LIST_ENTRY InLoadOrderLinks;
枚举和隐藏内核模块
liuhaidon1992的博客
01-08 1007
在 WIN64 上枚举内核模块有两种方法：使用 ZwQuerySystemInformation 的第 11 号功能(SystemModuleInformation)和枚举 KLDR_DATA_TABLE_ENTRY 中的 InLoadOrderLinks 双向链表； 隐藏内核模块的通用方法是把指定的驱动对象从 KLDR_DATA_TABLE_ENTRY中的 InLoadOrderLinks 双向...
内核驱动隐藏自身【断链】
WorryFree
02-08 1085
内核驱动加载时断链式隐藏自身！
JAVA上百实例源码以及开源项目
01-03
　关于数字签名：产生RSA密钥对(myKeyPair)，得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥...
java源码包---java 源码 大量 实例
04-18
　关于数字签名：产生RSA密钥对(myKeyPair)，得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥...
java源码包2
04-20
　关于数字签名：产生RSA密钥对(myKeyPair)，得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥...
java源码包3
04-20
　关于数字签名：产生RSA密钥对(myKeyPair)，得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥...
java源码包4
04-20
　关于数字签名：产生RSA密钥对(myKeyPair)，得到RSA密钥对，产生Signature对象,对用私钥对信息(info)签名，用指定算法产生签名对象，用私钥初始化签名对象，将待签名的数据传送给签名对象(须在初始化之后)，用公钥...
内核态进行进程与线程的监控
輚至消亡
03-21 817
进程监控主要使用PsSetCreateProcessNotifyEx 线程监控主要使用PsSetCreateThreadNotify 主要需要注意一点就是，这种方式的使用条件是需要强制完整性检查。可以通过/integritycheck选项添加。 或者网上有一种绕过方式, 在调用上面那两个函数前首先调用下面这个函数，如果执行成功即可绕过强制完整性检查。 BOOLEAN BypassCheckSign(PDRIVER_OBJECT pDriverObject) { #ifdef _WIN64 ..
Windows10 x64 Ring0实现进程创建监控
zcy5157912的博客
03-23 247
win10 x64 亲测可用
通过驱动断链来隐藏驱动
Misaka10046的博客
07-12 2828
隐藏指定驱动 尝试隐藏这个驱动 #include <ntifs.h> typedef struct _KLDR_DATA_TABLE_ENTRY { LIST_ENTRY InLoadOrderLinks; LIST_ENTRY exp; ULONG un; ULONG NonPagedDebugInfo; ULONG DllBase; ULONG EntryPoint; ULONG SizeOfImage; UNICODE_STRING FullDllName; UNICO
驱动开发：内核测试模式过DSE签名
热门推荐
CSDN
10-22 1万+
该保护机制的核心就是任何驱动程序或者是第三方驱动如果想要在正常模式下被加载则必须要经过微软的认证，当驱动程序被加载到内存时会验证签名的正确性，如果签名不正常则系统会拒绝运行驱动，这种机制也被称为驱动强制签名，该机制的作用是保护系统免受恶意软件的破坏，是提高系统安全性的一种手段。在Windows操作系统中，为了保护系统安全性，有一个叫做驱动程序签名验证的机制，它的作用是验证驱动程序是否来自受信任的发行者（也就是签名）。置位，则在调试模式下就不会在验证签名了，省去了重复签名的麻烦。保护机制，DSE全称。
DKOM隐藏驱动
weixin_33919941的博客
08-31 196
DKOM(Direct Kernel Object Manipulation)就是直接内核对象操作技术。所有的操作系统都在内存中存储记账信息，他们通常采用结构或对象的形式,由对象管理器管理。当用户空间进程请求操作系统信息例如进程、线程或设备驱动程序列表时，这些对象被报告给用户。这些对象或结构位于内存中，因此可以直接对其进行修改。隐藏进程主要关注的windows关键数据结构是：...
Win64 驱动内核编程-25.X64枚举和隐藏内核模块
天使也掉毛
03-26 4676
X64枚举和隐藏内核模块     在 WIN64 上枚举内核模块的人方法：使用 ZwQuerySystemInformation 的第 11 号功能和枚举 KLDR_DATA_TABLE_ENTRY 中的 InLoadOrderLinks 双向链表；隐藏内核模块的通用方法是把指定的驱动对象从 KLDR_DATA_TABLE_ENTRY中的 InLoadOrderLinks 双向链表上摘除。 X
遍历内核驱动模块
HXC_HUANG的博客
03-05 5268
PsLoadedModuleList是Windows加载的所有内核模块构成的链表的表头，利用它可以枚举所有这些模块的信息，下面是WRK中对PsLoadedModuleList的定义：LIST_ENTRYPsLoadedModuleList; 内核在加载驱动时，会为每一个驱动创建一个驱动对象（DRIVER_OBJECT），下面是驱动对象的数据结构：
遍历所有驱动的名_根据本驱动对象的成员(DriverObject->DriverSection)_对应LDR_DATA_TABLE_ENTRY结构体_双向链表使用
01-27 3366
#include"ntddk.h" typedef struct _LDR_DATA_TABLE_ENTRY { LIST_ENTRY InLoadOrderLinks;//这个成员把系统所有加载(可能是停止没被卸载)已经读取到内存中 我们关系第一个 我们要遍历链表 双链表 不管中间哪个节点都可以遍历整个链表 本驱动的驱动对象就是一个节点 LIST_ENTRY InMemoryOrderL...
隐藏驱动模块
125096
10-20 2043
#include typedef unsigned long DWORD; typedef struct _KLDR_DATA_TABLE_ENTRY { LIST_ENTRY InLoadOrderLinks; PVOID ExceptionTable; ULONG ExceptionTableSize; PVOID GpValue; DWORD U
python遍历读取csv文件
最新发布
07-28
您可以使用Python的csv模块来遍历和读取CSV文件。下面是一个示例代码，演示了如何使用csv模块来遍历读取CSV文件中的数据： ```python import csv # 打开CSV文件 with open('filename.csv', 'r') as file: # 创建...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值