第一篇 windows驱动之WinRing0.sys的开发及使用（电脑温度监控软件开发）

已于 2023-01-18 10:44:13 修改
阅读量5.4k 收藏 26
点赞数 7
分类专栏： Windows驱动之WinRing0 文章标签： windows windows驱动 DDK CPU温度
于 2022-08-19 14:49:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25231249/article/details/126420278
版权

简介

  从鲁大师的温度监控谈起，现代的CPU、GPU等芯片一般都具有温度监控的功能，比如我们可能会遇到的电脑散热不好导致系统直接关机黑屏，就是cpu检测到当前温度高于额定温度执行的操作。

  鲁大师的温度监控模块就相当于把这些信息从底层硬件读取，然后通过上层UI显示给用户。其核心就是与硬件的通信驱动。现在win10的驱动都可以通过系统更新直接完成，不再需要安装流氓软件“驱动精灵”、“驱动人生”等。我一般只用到温度检测模块，其他功能于我都是鸡肋，为了一个很小的功能，我需要安装一个庞大的鲁大师程序，甚是不划算。故自己动手实现。本文的主题就是如何实现鲁大师的温度检测模块。

  封闭必将导致落后，开放才能共同进步。WinRing0.sys作为一款windows平台下与设备通信的驱动被广泛使用。却由开源成了闭源，由支持读写成了仅支持读。本文花费数个工作日将08年之前开源的文件进行学习整理。便于后期大家的学习和升级优化。

windows驱动预备知识

1.虚拟设备驱动程序

.vxd程序：虚拟设备驱动程序，主要是为了给dos程序提供一个虚拟硬件

dos程序：早于windows的程序，window 3.x时代为了发展就需要兼容这些程序。类似当前鸿蒙兼容安卓，都是为了钱，不磕碜。

.vxd程序：可以把.vxd程序理解为运行在第0级别的dll。

ring0：最高等级权限，可以为所欲为，直接操作硬件。

ring3：用户等级权限，可以调用user32.dll、NTDLL.dll等库间接控制硬件。

WinRing0.vxd：其目的并非要虚拟硬件，只是需要第0级别的权限。

总结一：.vxd程序最新也得win9的系统才能用到，以上当个科普，了解下就行。对应WingRing0驱动的学习聚焦到.sys文件。

2.设备驱动文件

.sys文件：设备驱动文件，常说的声卡、显卡、键盘驱动等，都需要开发这种文件。

.inf文件：驱动安装的配置文件，主要是写注册表，注册接口。必有参数是ClassGUID。

总结二：.sys文件也当做权限等级为0级的.dll文件就行了。.dll文件的使用不熟悉的可以网上了解下。

3.sys驱动使用

.签名：内核级别的驱动都需要微软公司认证过的秘钥进行签名才能直接安装到windows系统中。签名的秘钥文件后缀是.cer。在这里插入图片描述
注册：注册仅仅是完成在注册表里写一个项。下图中的小工具是专门用于内核驱动安装运行的。链接: 下载地址
在这里插入图片描述
在这里插入图片描述

启动：对应缺微软签名或微软认证过的秘钥进行签名的内核级驱动是无法直接启动起来的。这是由于系统对于涉及内核层级的驱动有签名校验导致，简单说就是没有健康码绿码的不能在小区活动。
在这里插入图片描述

禁用强制签名校验：通过修改bcdedit来取消掉这个限制。有点类似安卓手机安装APP的时候经常需要“允许安装未知来源的程序”。逐条执行以下命令即可(管理员权限)：

"Win7系统"

bcdedit.exe -set loadoptions DDISABLE_INTEGRITY_CHECKS

bcdedit /set TESTSIGNING ON

bcdedit /set nointegritychecks yes

如果有失败项，一般需要在BIOS里面关闭安全启动

启动按DEL键 进入BIOS 然后把 Secure Boot Policy 选项设置为关闭

重启电脑

"Win10系统"
bcdedit.exe -set loadoptions DDISABLE_INTEGRITY_CHECKS

bcdedit /set TESTSIGNING ON

bcdedit /set nointegritychecks yes

如果有失败，一般需要在BIOS里面关闭安全启动

启动按DEL键 进入BIOS 然后把 Secure Boot Policy 选项设置为关闭

重启电脑

代码分析

  通过以上的知识大致了解了windows驱动程序是啥，怎么用。接下来就进入较难的实战部分，写代码调用驱动获取有效信息。.sys驱动是用c语言写的，具体代码如下三部分。

1、驱动入口函数


NTSTATUS DriverEntry(	IN PDRIVER_OBJECT  DriverObject,	IN PUNICODE_STRING RegistryPath	)
{
	NTSTATUS		status;
	UNICODE_STRING  ntDeviceName;
	UNICODE_STRING  win32DeviceName;
	PDEVICE_OBJECT  deviceObject = NULL;

	RtlInitUnicodeString(&ntDeviceName, NT_DEVICE_NAME);

	status = IoCreateDevice(
		DriverObject,					// Our Driver Object
		0,								// We don't use a device extension
		&ntDeviceName,					// Device name 
		OLS_TYPE,						// Device type  自定义的值
		FILE_DEVICE_SECURE_OPEN,		// Device characteristics
		FALSE,							// Not an exclusive device 非排他性设备
		&deviceObject );				// Returned ptr to Device Object

	if(!NT_SUCCESS(status))
	{
		refCount = (ULONG)-1;
		return status;
	}
	else
	{
		refCount = 0;
	}

	// Initialize the driver object with this driver's entry points.
	// 构造DriverObject这个结构体变量
	DriverObject->MajorFunction[IRP_MJ_CREATE] = OlsDispatch;// 1.注册函数，就是把函数指针告诉操作系统。当操作系统发送 IRP_MJ_CREATE 请求时，会调用这个函数
	DriverObject->MajorFunction[IRP_MJ_CLOSE] = OlsDispatch;// 2.
	DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = OlsDispatch;// 3.
	DriverObject->DriverUnload = Unload;//驱动卸载函数

	// Initialize a Unicode String containing the Win32 name for our device.
	RtlInitUnicodeString(&win32DeviceName, DOS_DEVICE_NAME);

	// Create a symbolic link between our device name  and the Win32 name
	status = IoCreateSymbolicLink(&win32DeviceName, &ntDeviceName);

	if (!NT_SUCCESS(status))
	{
		// Delete everything that this routine has allocated.
		IoDeleteDevice( deviceObject );
	}

	return status;
}

2、调度函数

  实际读取CPU信息的实现代码在此处，主要涉及两个参数，其一是：DEVICE_OBJECT ，其二是：I/O Request Packet (IRP) 。OlsDispatch()这个函数根据传进来的请求信息调用具体的执行函数。

/*++

Routine Description:
	This routine is the dispatch handler for the driver.  It is responsible
	for processing the IRPs.

Arguments:
	
	pDO - Pointer to device object.

	pIrp - Pointer to the current IRP.

Return Value:

	STATUS_SUCCESS if the IRP was processed successfully, otherwise an erroror
	indicating the reason for failure.

--*/
NTSTATUS OlsDispatch( 	IN	PDEVICE_OBJECT pDO,	IN	PIRP pIrp	)
{
	PIO_STACK_LOCATION pIrpStack;
	NTSTATUS status;
	int index;

	//  Initialize the irp info field.
	//	  This is used to return the number of bytes transfered.
	pIrp->IoStatus.Information = 0;
	pIrpStack = IoGetCurrentIrpStackLocation(pIrp);

	//  Set default return status
	status = STATUS_NOT_IMPLEMENTED;

	// Dispatch based on major fcn code.
	switch(pIrpStack->MajorFunction)
	{
		case IRP_MJ_CREATE:
			if(refCount != (ULONG)-1){refCount++;}
			status = STATUS_SUCCESS;
			break;
		case IRP_MJ_CLOSE:
			if(refCount != (ULONG)-1){refCount--;}
			status = STATUS_SUCCESS;
			break;

		case IRP_MJ_DEVICE_CONTROL:
			//  Dispatch on IOCTL
			switch(pIrpStack->Parameters.DeviceIoControl.IoControlCode)
			{
			case IOCTL_OLS_GET_DRIVER_VERSION:
				*(PULONG)pIrp->AssociatedIrp.SystemBuffer = OLS_DRIVER_VERSION;
				pIrp->IoStatus.Information = 4;
				status = STATUS_SUCCESS;
				break;

			case IOCTL_OLS_GET_REFCOUNT:
				*(PULONG)pIrp->AssociatedIrp.SystemBuffer = refCount;
				pIrp->IoStatus.Information = sizeof(refCount);
				status = STATUS_SUCCESS;
				break;

			case IOCTL_OLS_READ_MSR:
				status = ReadMsr(
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
					(ULONG*)&pIrp->IoStatus.Information
					);
				break;
			case IOCTL_OLS_WRITE_MSR:
				status = WriteMsr(
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
					(ULONG*)&pIrp->IoStatus.Information
					);
				break;
			case IOCTL_OLS_READ_PMC:
				status = ReadPmc(
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
					(ULONG*)&pIrp->IoStatus.Information
					);
				break;
			case IOCTL_OLS_HALT:
				__halt();
				status = STATUS_SUCCESS;
				break;

			case IOCTL_OLS_READ_IO_PORT:
			case IOCTL_OLS_READ_IO_PORT_BYTE:
			case IOCTL_OLS_READ_IO_PORT_WORD:
			case IOCTL_OLS_READ_IO_PORT_DWORD:
				status = ReadIoPort(
					pIrpStack->Parameters.DeviceIoControl.IoControlCode,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
					(ULONG*)&pIrp->IoStatus.Information
					);
				break;
			case IOCTL_OLS_WRITE_IO_PORT:
			case IOCTL_OLS_WRITE_IO_PORT_BYTE:
			case IOCTL_OLS_WRITE_IO_PORT_WORD:
			case IOCTL_OLS_WRITE_IO_PORT_DWORD:
				status = WriteIoPort(
					pIrpStack->Parameters.DeviceIoControl.IoControlCode,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
					(ULONG*)&pIrp->IoStatus.Information
					);
				break;

			case IOCTL_OLS_READ_PCI_CONFIG:
				status = ReadPciConfig(
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
					(ULONG*)&pIrp->IoStatus.Information
					);
				break;
			case IOCTL_OLS_WRITE_PCI_CONFIG:
				status = WritePciConfig(
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
					(ULONG*)&pIrp->IoStatus.Information
					);
				break;

			case IOCTL_OLS_READ_MEMORY:
				status = ReadMemory(
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
					(ULONG*)&pIrp->IoStatus.Information
					);
				break;
			case IOCTL_OLS_WRITE_MEMORY:
				status = WriteMemory(
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
					pIrp->AssociatedIrp.SystemBuffer,
					pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
					(ULONG*)&pIrp->IoStatus.Information
					);
				break;


			}
			break;
	}

	// We're done with I/O request.  Record the status of the I/O action.
	pIrp->IoStatus.Status = status;

	// Don't boost priority when returning since this took little time.
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);

	return status;
}

  下面的代码是具体每个case的实现部分，直接在注释里面做介绍：

//-----------------------------------------------------------------------------
//
// CPU
//
//-----------------------------------------------------------------------------

NTSTATUS
ReadMsr(	void	*lpInBuffer, 
			ULONG	nInBufferSize, 
			void	*lpOutBuffer, 
			ULONG	nOutBufferSize, 
			ULONG	*lpBytesReturned)
{
	__try
	{
		//MSR是CPU的一组64位寄存器，可以分别通过RDMSR和WRMSR 两条指令进行读和写的操作。
		//__readmsr就是生成指令并执行。此函数仅在内核模式下可用，且对应程序仅可用作内部函数，
		//这也就是为啥需要Ring0权限的原因。
		ULONGLONG data = __readmsr(*(ULONG*)lpInBuffer);
		memcpy((PULONG)lpOutBuffer, &data, 8);
		*lpBytesReturned = 8;
		return STATUS_SUCCESS;
	}
	__except(EXCEPTION_EXECUTE_HANDLER)
	{
		*lpBytesReturned = 0;
		return STATUS_UNSUCCESSFUL;
	}
}

NTSTATUS
WriteMsr(	void	*lpInBuffer, 
			ULONG	nInBufferSize, 
			void	*lpOutBuffer, 
			ULONG	nOutBufferSize, 
			ULONG	*lpBytesReturned)
{
	__try
	{
		//与上面的__readmsr类似
		OLS_WRITE_MSR_INPUT* param;
		param = (OLS_WRITE_MSR_INPUT*)lpInBuffer;

		__writemsr(param->Register, param->Value.QuadPart);
		*lpBytesReturned = 0;
		return STATUS_SUCCESS;
	}
	__except(EXCEPTION_EXECUTE_HANDLER)
	{
		*lpBytesReturned = 0;
		return STATUS_UNSUCCESSFUL;
	}
}

NTSTATUS
ReadPmc(	void	*lpInBuffer, 
			ULONG	nInBufferSize, 
			void	*lpOutBuffer, 
			ULONG	nOutBufferSize, 
			ULONG	*lpBytesReturned)
{
	__try
	{   //pmc 性能计数器
		ULONGLONG data = __readpmc(*(ULONG*)lpInBuffer);
		memcpy((PULONG)lpOutBuffer, &data, 8);
		*lpBytesReturned = 8;
		return STATUS_SUCCESS;
	}
	__except(EXCEPTION_EXECUTE_HANDLER)
	{
		*lpBytesReturned = 0;
		return STATUS_UNSUCCESSFUL;
	}
}

//-----------------------------------------------------------------------------
//
// IO Port IO口
//
//-----------------------------------------------------------------------------

NTSTATUS
ReadIoPort( ULONG	ioControlCode,
			void	*lpInBuffer, 
			ULONG	nInBufferSize, 
			void	*lpOutBuffer, 
			ULONG	nOutBufferSize, 
			ULONG	*lpBytesReturned)
{
	ULONG nPort = *(ULONG*)lpInBuffer;
	
	switch(ioControlCode)
	{
		case IOCTL_OLS_READ_IO_PORT_BYTE://从指定的端口地址读取单个字节
			*(PUCHAR)lpOutBuffer = READ_PORT_UCHAR((PUCHAR)(ULONG_PTR)nPort);
			break;
		case IOCTL_OLS_READ_IO_PORT_WORD://从指定的端口地址读取单个字
			*(PUSHORT)lpOutBuffer = READ_PORT_USHORT((PUSHORT)(ULONG_PTR)nPort);
			break;
		case IOCTL_OLS_READ_IO_PORT_DWORD://从指定的端口地址读取双字节
			*(PULONG)lpOutBuffer = READ_PORT_ULONG((PULONG)(ULONG_PTR)nPort);
			break;
		default:
			*lpBytesReturned = 0;
			return STATUS_INVALID_PARAMETER;
			break;
	}
	
	*lpBytesReturned = nInBufferSize;
	return STATUS_SUCCESS;
}

NTSTATUS
WriteIoPort(ULONG	ioControlCode,
			void	*lpInBuffer, 
			ULONG	nInBufferSize, 
			void	*lpOutBuffer, 
			ULONG	nOutBufferSize, 
			ULONG	*lpBytesReturned)
{
	ULONG nPort;
	OLS_WRITE_IO_PORT_INPUT* param;
	
	param = (OLS_WRITE_IO_PORT_INPUT*)lpInBuffer;
	nPort = param->PortNumber;

	switch(ioControlCode)
	{

		case IOCTL_OLS_WRITE_IO_PORT_BYTE:
			WRITE_PORT_UCHAR((PUCHAR)(ULONG_PTR)nPort, param->CharData);
			break;
		case IOCTL_OLS_WRITE_IO_PORT_WORD:
			WRITE_PORT_USHORT((PUSHORT)(ULONG_PTR)nPort, param->ShortData);
			break;
		case IOCTL_OLS_WRITE_IO_PORT_DWORD:
			WRITE_PORT_ULONG((PULONG)(ULONG_PTR)nPort, param->LongData);
			break;
		default:
			return STATUS_INVALID_PARAMETER;
			break;
	}

	return STATUS_SUCCESS;
}

//-----------------------------------------------------------------------------
//
// PCI
//
//-----------------------------------------------------------------------------

NTSTATUS
ReadPciConfig(	void	*lpInBuffer, 
				ULONG	nInBufferSize, 
				void	*lpOutBuffer, 
				ULONG	nOutBufferSize, 
				ULONG	*lpBytesReturned)
{
	OLS_READ_PCI_CONFIG_INPUT *param;
	NTSTATUS status;

	if(nInBufferSize != sizeof(OLS_READ_PCI_CONFIG_INPUT))
	{
		return STATUS_INVALID_PARAMETER;
	}
	param = (OLS_READ_PCI_CONFIG_INPUT *)lpInBuffer;

	status = pciConfigRead(param->PciAddress, param->PciOffset,
						lpOutBuffer, nOutBufferSize);//最终调用的是HalGetBusDataByOffset，这是硬件抽象层函数，获取总线数据

	if(status == STATUS_SUCCESS)
	{
		*lpBytesReturned = nOutBufferSize;
	}
	else
	{
		*lpBytesReturned = 0;
	}

	return status;
}

NTSTATUS
WritePciConfig(	void *lpInBuffer, 
				ULONG nInBufferSize, 
				void *lpOutBuffer, 
				ULONG nOutBufferSize, 
				ULONG *lpBytesReturned)

{
	OLS_WRITE_PCI_CONFIG_INPUT *param;
	ULONG writeSize;
	NTSTATUS status;

	if(nInBufferSize < offsetof(OLS_WRITE_PCI_CONFIG_INPUT, Data))
	{
		return STATUS_INVALID_PARAMETER;
	}

	param = (OLS_WRITE_PCI_CONFIG_INPUT *)lpInBuffer;
	writeSize = nInBufferSize - offsetof(OLS_WRITE_PCI_CONFIG_INPUT, Data);
	
	*lpBytesReturned = 0;

	return pciConfigWrite(param->PciAddress, param->PciOffset,
							&param->Data, writeSize);

}

//-----------------------------------------------------------------------------
//
// Support Function
//
//-----------------------------------------------------------------------------

NTSTATUS pciConfigRead(ULONG pciAddress, ULONG offset, void *data, int length)
{
	PCI_SLOT_NUMBER slot;
	int error;
	ULONG busNumber;

	busNumber = PciGetBus(pciAddress);
	slot.u.AsULONG = 0;
	slot.u.bits.DeviceNumber = PciGetDev(pciAddress);
	slot.u.bits.FunctionNumber = PciGetFunc(pciAddress);
	error =	HalGetBusDataByOffset(PCIConfiguration, busNumber, slot.u.AsULONG,
									data, offset, length);

	if(error == 0)
	{
		return OLS_ERROR_PCI_BUS_NOT_EXIST;
	}
	else if(length != 2 && error == 2)
	{
		return OLS_ERROR_PCI_NO_DEVICE;
	}
	else if(length != error)
	{
		return OLS_ERROR_PCI_READ_CONFIG;
	}

	return STATUS_SUCCESS;
}

NTSTATUS pciConfigWrite(ULONG pciAddress, ULONG offset, void *data, int length)
{
	PCI_SLOT_NUMBER slot;
	int error;
	ULONG busNumber;

	busNumber = PciGetBus(pciAddress);

	slot.u.AsULONG = 0;
	slot.u.bits.DeviceNumber = PciGetDev(pciAddress);
	slot.u.bits.FunctionNumber = PciGetFunc(pciAddress);
	error = HalSetBusDataByOffset(PCIConfiguration, busNumber, slot.u.AsULONG,
									data, offset, length);

	if(error != length)
	{
		return OLS_ERROR_PCI_WRITE_CONFIG;
	}

	return STATUS_SUCCESS;
}


//-----------------------------------------------------------------------------
//
// Physical Memory
//
//-----------------------------------------------------------------------------

NTSTATUS
ReadMemory(	void	*lpInBuffer, 
			ULONG	nInBufferSize, 
			void	*lpOutBuffer, 
			ULONG	nOutBufferSize, 
			ULONG	*lpBytesReturned)
{
	OLS_READ_MEMORY_INPUT *param;
	ULONG	size;
	PHYSICAL_ADDRESS address;
	PVOID	maped;
	BOOLEAN	error;

	if(nInBufferSize != sizeof(OLS_READ_MEMORY_INPUT))
	{
		return STATUS_INVALID_PARAMETER;
	}

	param = (OLS_READ_MEMORY_INPUT *)lpInBuffer;
	size = param->UnitSize * param->Count;

	if(nOutBufferSize < size)
	{
		return STATUS_INVALID_PARAMETER;
	}

	address.QuadPart = param->Address.QuadPart;

#ifndef _PHYSICAL_MEMORY_SUPPORT

	if(0x000C0000 > address.QuadPart 
	|| (address.QuadPart + size - 1) > 0x000FFFFF)
	{
		return STATUS_INVALID_PARAMETER;
	}

#endif

	maped = MmMapIoSpace(address, size, FALSE);//把物理地址 转为虚拟地址，比如我们要读取物理地址为100的一个字节数据，
	//其通过系统被映射到虚拟内存的地址是200，那我们就通过读虚拟内存的200位置来实现

	error = FALSE;
	switch(param->UnitSize){
		case 1:
			READ_REGISTER_BUFFER_UCHAR(maped, lpOutBuffer, param->Count);//从虚拟地址里间接读物理地址的信息
			break;
		case 2:
			READ_REGISTER_BUFFER_USHORT(maped, lpOutBuffer, param->Count);
			break;
		case 4:
			READ_REGISTER_BUFFER_ULONG(maped, lpOutBuffer, param->Count);
			break;
		default:
			error = TRUE;
			break;
	}

	MmUnmapIoSpace(maped, size);

	if(error)
	{
		return STATUS_INVALID_PARAMETER;
	}

	*lpBytesReturned = nOutBufferSize;

	return STATUS_SUCCESS;
}

NTSTATUS
WriteMemory(void	*lpInBuffer, 
			ULONG	nInBufferSize, 
			void	*lpOutBuffer, 
			ULONG	nOutBufferSize, 
			ULONG	*lpBytesReturned)
{
#ifdef _PHYSICAL_MEMORY_SUPPORT

	OLS_WRITE_MEMORY_INPUT *param;
	ULONG size;
	PHYSICAL_ADDRESS address;
	PVOID	maped;
	BOOLEAN	error;

	if(nInBufferSize < offsetof(OLS_WRITE_MEMORY_INPUT, Data))
	{
		return STATUS_INVALID_PARAMETER;
	}

	param = (OLS_WRITE_MEMORY_INPUT *)lpInBuffer;

	size = param->UnitSize * param->Count;
	if (nInBufferSize < size + offsetof(OLS_WRITE_MEMORY_INPUT, Data))
	{
		return STATUS_INVALID_PARAMETER;
	}

	address.QuadPart = param->Address.QuadPart;

	maped = MmMapIoSpace(address, size, FALSE);

	error = FALSE;
	switch(param->UnitSize){
		case 1:
			WRITE_REGISTER_BUFFER_UCHAR(maped, 
										(UCHAR*)&param->Data, param->Count);
			break;
		case 2:
			WRITE_REGISTER_BUFFER_USHORT(maped,
										(USHORT*)&param->Data, param->Count);
			break;
		case 4:
			WRITE_REGISTER_BUFFER_ULONG(maped,
										(ULONG*)&param->Data, param->Count);
			break;
		default:
			error = TRUE;
			break;
	}

	MmUnmapIoSpace(maped, size);

	if(error)
	{
		return STATUS_INVALID_PARAMETER;
	}

	*lpBytesReturned = 0;

	return STATUS_SUCCESS;

#else

	*lpBytesReturned = 0;
	
	return STATUS_INVALID_PARAMETER;

#endif
}

3、驱动卸载函数

  实际的卸载工作被IRP_MN_REMOVE_DEVICE对应的派发函数处理了，不需要自己实现。这里的DriverUnload主要处理在DriverEntry中申请的内存，也就是“new”出的“win32NameString”。

/*++

Routine Description:

	This routine is called by the I/O system to unload the driver.

	Any resources previously allocated must be freed.

Arguments:

	DriverObject - a pointer to the object that represents our driver.

Return Value:

	None
--*/
VOID Unload(	PDRIVER_OBJECT DriverObject	)
{
	PDEVICE_OBJECT deviceObject = DriverObject->DeviceObject;
	UNICODE_STRING win32NameString;

	PAGED_CODE();

	// Create counted string version of our Win32 device name.
	RtlInitUnicodeString(&win32NameString, DOS_DEVICE_NAME);

	// Delete the link from our device name to a name in the Win32 namespace.
	IoDeleteSymbolicLink(&win32NameString);

	if(deviceObject != NULL)
	{
		IoDeleteDevice(deviceObject);
	}
}

革命尚未成功，以上只是.sys驱动的代码实现，主要目的是获取Ring0权限，为了给开发者使用，需要做一个DLL提供对外的接口。请参阅第二篇。。。

MFC不精通不改名
关注
  • 7
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WinRing0 模拟按键 驱动级 sys lib dll 64 32.rar
03-29
WinRing0 模拟按键 驱动级 sys lib dll 64 32.rar
WInRing0中的需要用到的
04-20
WinRing0中需要用到的文件
Windows10驱动安装
最新发布
weixin_72946687的博客
04-19 1531
Windows10驱动安装
无驱动执行Ring0代码
wowbell的专栏
02-23 1032
<br />// 原理：通过/Device/PhysicalMemory修改NtVdmControl入口，跳转到Ring0Code<br /> //************************************************************************<br /> #include<br /> #include<br /> #include<br /><br /> #pragma comment (lib,"ntdll.lib") // Copy From
WinRing0 GPIO IO 详解——Windows平台
保持一颗敬畏之心，简单地调用C++，适当地向C++妥协，让以后的自己看懂代码，让别人看懂代码。
11-27 9108
WinRing0 GPIO 由于工作的需求，需要做一个工控机的GPIO的输出，也就不可避免的接触到WinRing IO了。基本上要控制这种通用型的GPIO，有两种方式，一种是winRing0,一种就是WinIO了。但由于WinIO需要让系统进行windows签名模式，这就比较烦人了。但关于WinIO我之前也有一个项目设计到了，我也稍微记录了一下，大家如果感兴趣，可以去看看，地址为[最新WinIO驱动测试GPIO口](https://blog.csdn.net/weixin_
内存映射IO（MMIO）
Charles Ren's Tech Blog
01-29 1053
种隐藏的接口芯片也不在少数，很多都是我们不能直观看到的。DRAM Controller View就是内存控制器能够控制的内存地址的范围，那顾名思义，内存控制器的这个控制范围主要肯定就是内存的大小范围，在内存还没有增长到今天这个范围的以前，内存控制器能够识别的大小可能只有2G，而今天它能够识别的范围远远超过之前。在早期的CPU中，CPU的位宽为32，而地址线能够达到36根（是的没错，并不是大多数人以为的32位地址线），此时限制physical address space的主要因素就是CPU的位宽了。
使用Winring0
weixin_43587848的博客
07-16 4720
项目中需要查询CPU温度，所以用到winring0.dll,需要知道自己系统是32位还是64位，然后选择winring032.dll还是winring064.dll. 使用步骤： 1.在项目生成执行文件的目录下放入dll文件（WinRing0x32.dll/WinRing0x64.dll）以及sys文件（WinRing0x32.sys/WinRing0x64.sys） 2.在cpp源文件中包含头文件“OlsApiInit.h”以及“OlsDef.h” 3.工程项目设置为管理员权限：项目右击->项目属性
WinRing0 文件集合
02-26
https://blog.csdn.net/qq_43211060/article/details/121578762 这个就是关于这个文件的博客。
winring0 初始化失败问题
baidu_40624101的博客
06-16 1559
winring0初始化失败查找方法之一
Windows下QT使用WinRing0控制主板的蜂鸣器响
qq_38203996的博客
07-03 1515
最近在windows10下用QT做项目，需要在用户进行某项操作时进行声音提示，扬声器的话一来增加成本，二来也受系统提示音困扰。搜索网上有两种解决办法，一个是WinIO的方式，这种处理起来比较麻烦，量产时费人费力还容易造成系统不稳定。另外一种就是WinRing0了，也就是这篇博客讲的。Q_OBJECT;private ://声明所用到的dll文件 };
WinRing0 源码
12-20
WinRing0 dll 源码 window 系统操作底层必备
WinRing0(1.2.0.5)驱动
10-19
WinRing0 是一个强大的驱动程序，可以直接通过这个驱动读取CPUID，CPU MSR，TSC，IO port，PCI config等硬件信息。
鲁大师温度监控（3.0.0.1020）提取版.zip
06-05
小鲁温度监控是一款电脑硬件温度监控软件，可以实时监控您的电脑温度，并提供了节能降温功能， 防止电脑过热导致硬件的硬件寿命缩短，并且体用了浏览器主页防护功能，有效保护您的浏览器主页不被恶意篡改， 小鲁温度监控集成在360安全卫士的旧版本中，新版本中去掉了这个功能，如果您想使用这个功能， 可以在此下载小鲁温度监控独立版，该版本是从以前的360安全卫士中提取出来的，不需要安装就能使用。
winio3.0+WinRing0_1_3_1a_驱动级端口访问
04-13
C++ Ring0级系统硬件和内存访问 访问硬件端口用来模拟按键什么都挡不住，模拟按键只是大材小用了 WinIO 和 Winring0 都非常强大 由于驱动的签名问题.WinIO在Win7 x64 上目前运行不能，也许我没找对方法 所以转而 Winring0。(注: Winring0 以前是开源项目,后来关闭.最后能找到的版本是1.3.1a) Winring0这个驱动有数字签名！！！能在64位WIN7下工作！ WinIO 最新版本3.0 Winring0 最新版本 1.3.1a (只有二进制文件) Winring0 1.3.0 （源码+二进制文件+自带示例） 两个项目都有chm帮助文档（很简单的英语）
WinRing0 1.20 支持64位带数签名
05-27
非常难找的硬件I/O的库，现在sourceforge上都不能下载， 本压缩文件包含所有WinRing0 1.2源代码及二进制文件，具有驱动数字签名，适合在64位OS下做开发。 此库支持C#和C++。
winring.zip
05-21
底层端口操作必备，C语言类编程，支持操作系统的
WinRing0.zip
07-22
文件里含有简单的使用说明，若想要WinRing0的帮助文件请另寻资源，文件包括OlsApi.h头文件，WinRing0Debug.dll文件，WinRing0Debug.lib文件和WinRing0x64.sys文件(带数字签名)
驱动开发之磁盘读写文件监控.sys驱动程序.zip
01-27
本压缩包文件"驱动开发之磁盘读写文件监控.sys驱动程序.zip"包含了关于如何开发一个用于监控磁盘文件读写操作的系统驱动的详细资料。下面将深入探讨相关知识点。 首先，驱动程序是操作系统与硬件设备之间的桥梁，...
windows驱动开发技术详解 加载和卸载.sys驱动程序的exe源代码.zip
01-28
1. **驱动程序类型**：Windows驱动程序分为内核模式驱动（如.sys文件）和用户模式驱动。内核模式驱动运行在操作系统核心层，拥有更高的权限，可以直接访问硬件，而用户模式驱动则运行在较低的权限级别，通常用于与...
微软 storahci.sys 驱动
11-21
微软的storahci.sys是存储控制器驱动程序，通常用于处理系统的硬盘和固态硬盘的读写操作。这个驱动程序是Windows操作系统的一部分，主要负责管理存储设备的数据传输和存储功能，确保系统能够快速、稳定地读写数据。 storahci.sys 驱动程序通常与AHCI（高级主机控制器接口）技术密切相关，AHCI是一种用于SATA接口的高级控制器标准，它能够提供更好的性能和更多的功能，如热插拔、NCQ和TRIM等。而storahci.sys 驱动程序就是为了充分发挥AHCI的性能而设计的，它能够充分利用AHCI的高级功能，提供更好的存储性能和更稳定的数据传输。 不过，有时候用户可能会遇到storahci.sys 驱动程序的问题，比如驱动程序损坏、版本不匹配等，导致系统出现存储设备无法识别、读写速度变慢等情况。这时候，用户可以通过更新驱动程序、修复系统文件等方法来解决问题。 总的来说，微软的storahci.sys 驱动程序在Windows系统中扮演着重要的角色，它能够确保存储设备的高效运行，提升系统的整体性能。用户在使用过程中需要注意及时更新驱动程序，以确保系统的稳定和安全。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值