Ring0文件操作

最新推荐文章于 2019-05-13 20:00:36 发布
最新推荐文章于 2019-05-13 20:00:36 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： 内核 windows 驱动开发 文章标签： 文件操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youyou519/article/details/83376974
版权
windows 同时被 3 个专栏收录
105 篇文章 15 订阅
订阅专栏
内核
85 篇文章 6 订阅
订阅专栏
驱动开发
83 篇文章 9 订阅
订阅专栏

 Ring0文件操作，文件复制，移动，删除，删除使用设置属性，路径硬编码

#include <ntifs.h>
#include <ntddk.h>

NTSTATUS ntCreateFile(WCHAR *szFileName);
NTSTATUS ntCreateDirectory(WCHAR *szDirName);

NTSTATUS ntWriteFile(WCHAR *szFileName);
NTSTATUS ntReadFile(WCHAR *szFileName);
NTSTATUS ntCopyFile(const WCHAR *src, const WCHAR *dst);
NTSTATUS ntMoveFile(const WCHAR *src, const WCHAR *dst);
NTSTATUS ntDeleteFile(const WCHAR *szFileName);//删除 (设置属性的方式)
NTSTATUS ntNormalDeleteFile(const WCHAR *szFileName);//普通删除

ULONG ntGetFileAttributes(const WCHAR *szFileName);
NTSTATUS ntSetFileAttributes(WCHAR *szFileName);

VOID DriverUnload(PDRIVER_OBJECT pDriverObject)
{
	NTSTATUS ntStatus = 0;
	WCHAR *szFileName1 = L"\\??\\C:\\DriStu\\1.txt";//采用硬编码，写死文件，为了测试
	WCHAR *szFileName2 = L"\\??\\C:\\DriStu\\2.txt";//同上

	ntStatus = ntDeleteFile(szFileName1);
	if (!NT_SUCCESS(ntStatus))
	{
		DbgPrint("ntDeleteFile() failed %d \n", ntStatus);
	}
	ntStatus = ntDeleteFile(szFileName2);
	if (!NT_SUCCESS(ntStatus))
	{
		DbgPrint("ntDeleteFile() failed%ws,%x\n", szFileName2, ntStatus);
		return;
	}
	DbgPrint("Driver Unloaded\n");
	
}

NTSTATUS FileOper(VOID);

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegPath)
{
	DbgPrint("Driver begin\n");
	pDriverObject->DriverUnload = DriverUnload;
	FileOper();
	return STATUS_SUCCESS;
}

NTSTATUS FileOper(VOID)
{
	NTSTATUS ntStatus = STATUS_SUCCESS;
	ULONG ulAttributes = 0;
	WCHAR *szDirName = L"\\??\\C:\\DriStu\\Mallocfree\\";
	WCHAR *szFileName1 = L"\\??\\C:\\DriStu\\1.txt";
	WCHAR *szFileName2 = L"\\??\\C:\\DriStu\\2.txt";
	WCHAR *szFileName3 = L"\\??\\C:\\DriStu\\Mallocfree\\3.txt";
	WCHAR *szFileName4 = L"\\??\\C:\\DriStu\\Mallocfree\\4.txt";
	ntStatus = ntCreateFile(szFileName1);
	if (!NT_SUCCESS(ntStatus))
	{
		DbgPrint("ntCreateFile() failed:%x\n", ntStatus);
		return ntStatus;
	}

	ntStatus = ntCreateDirectory(szDirName);
	if (!NT_SUCCESS(ntStatus))
	{
		DbgPrint("ntCreateDirectory() failed %x\n", ntStatus);
		return ntStatus;
	}

	ntStatus = ntWriteFile(szFileName1);
	if (!NT_SUCCESS(ntStatus))
	{
		DbgPrint("ntWriteFile() failed %x\n", ntStatus);
	}

	ntStatus = ntReadFile(szFileName1);
	if (!NT_SUCCESS(ntStatus))
	{
		DbgPrint("ntReadFile() failed:%x\n", ntStatus);
		return ntStatus;
	}

	ntStatus = ntCopyFile(szFileName1, szFileName2);
	if (!NT_SUCCESS(ntStatus))
	{
		DbgPrint("ntCopyFile() failed:%x\n", ntStatus);
		return ntStatus;
	}

	ntStatus = ntCopyFile(szFileName1, szFileName3);
	if (!NT_SUCCESS(ntStatus))
	{
		DbgPrint("ntCopyFile() failed:%x\n", ntStatus);
		return ntStatus;
	}

	ntStatus = ntMoveFile(szFileName1, szFileName4);
	if (!NT_SUCCESS(ntStatus))
	{
		DbgPrint("ntMoveFile() failed:%x\n", ntStatus);
		return ntStatus;
	}

	ulAttributes = ntGetFileAttributes(szFileName1);
	if (ulAttributes & FILE_ATTRIBUTE_DIRECTORY)
	{
		DbgPrint("%S is a directory\n", szFileName1);
	}
	else
	{
		DbgPrint("%S is not a directory\n", szFileName1);

	}

	ulAttributes = ntGetFileAttributes(szDirName);
	if (ulAttributes & FILE_ATTRIBUTE_DIRECTORY)
	{
		DbgPrint("%S is a directory\n", szDirName);
	}
	else
	{
		DbgPrint("%S is not a directory\n", szDirName);

	}

	return ntStatus;

}


NTSTATUS ntCreateFile(WCHAR *szFileName)
{
	OBJECT_ATTRIBUTES objAttrib = { 0 };
	UNICODE_STRING uFileName = { 0 };
	IO_STATUS_BLOCK io_status = { 0 };
	HANDLE hFile = NULL;
	NTSTATUS status = 0;

	RtlInitUnicodeString(&uFileName, szFileName);
	InitializeObjectAttributes(
		&objAttrib,
		&uFileName,
		OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
		NULL,
		NULL
	);

	status = ZwCreateFile(
		&hFile,
		GENERIC_WRITE,
		&objAttrib,
		&io_status,
		NULL,
		FILE_ATTRIBUTE_NORMAL,
		FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
		FILE_OPEN_IF,
		FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE,
		NULL,
		0);
	if (NT_SUCCESS(status))
	{
		ZwClose(hFile);
	}
	return status;
}

NTSTATUS ntCreateDirectory(WCHAR *szDirName)
{
	OBJECT_ATTRIBUTES objAttrib = { 0 };
	UNICODE_STRING uDirName = { 0 };
	IO_STATUS_BLOCK io_status = { 0 };
	HANDLE hFile = NULL;
	NTSTATUS status = 0;
	RtlInitUnicodeString(&uDirName, szDirName);
	InitializeObjectAttributes(
		&objAttrib,
		&uDirName,
		OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
		NULL,
		NULL);

	status = ZwCreateFile(
		&hFile,
		GENERIC_READ | GENERIC_WRITE,
		&objAttrib,
		&io_status,
		NULL,
		FILE_ATTRIBUTE_DIRECTORY,
		FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
		FILE_OPEN_IF,
		FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
		NULL,
		0
	);
	if (NT_SUCCESS(status))
	{
		ZwClose(hFile);
	}
	return status;
}

ULONG ntGetFileAttributes(const WCHAR *filename)
{
	ULONG dwRtn = 0;
	NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;
	OBJECT_ATTRIBUTES objAttr = { 0 };
	UNICODE_STRING uName = { 0 };
	FILE_NETWORK_OPEN_INFORMATION info = { 0 };

	if (NULL == filename)
	{
		return ntStatus;
	}

	RtlInitUnicodeString(&uName, filename);
	RtlZeroMemory(&info, sizeof(FILE_NETWORK_OPEN_INFORMATION));

	InitializeObjectAttributes(
		&objAttr,
		&uName,
		OBJ_CASE_INSENSITIVE|OBJ_KERNEL_HANDLE,
		NULL,
		NULL);

	ntStatus = ZwQueryFullAttributesFile(
		&objAttr,
		&info
	);
	if (NT_SUCCESS(ntStatus))
	{
		dwRtn = info.FileAttributes;
	}
	if (dwRtn&FILE_ATTRIBUTE_DIRECTORY)
	{
		DbgPrint("%S is a directory\n", filename);
	}
	return dwRtn;

}


NTSTATUS ntSetFileAttributes(WCHAR *szFileName)
{
	UNICODE_STRING uFileName = { 0 };
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	HANDLE hFile = NULL;
	NTSTATUS ntStatus = 0;
	IO_STATUS_BLOCK ioStatus = { 0 };
	FILE_STANDARD_INFORMATION fsi = { 0 };
	FILE_POSITION_INFORMATION fpi = { 0 };


	RtlInitUnicodeString(&uFileName, szFileName);

	InitializeObjectAttributes(
		&objectAttributes,
		&uFileName,
		OBJ_CASE_INSENSITIVE|OBJ_KERNEL_HANDLE,
		NULL,
		NULL
	);
	
	ntStatus = ZwCreateFile(
		&hFile,
		GENERIC_READ,
		&objectAttributes,
		&ioStatus,
		NULL,
		FILE_ATTRIBUTE_NORMAL,
		0,
		FILE_OPEN,
		FILE_SYNCHRONOUS_IO_NONALERT,
		NULL,
		0
	);
	if (!NT_SUCCESS(ntStatus))
	{
		return ntStatus;
	}
	ntStatus = ZwQueryInformationFile(
		hFile,
		&ioStatus,
		&fsi,
		sizeof(FILE_STANDARD_INFORMATION),
		FileStandardInformation
	);
	if (!NT_SUCCESS(ntStatus))
	{
		ZwClose(hFile);
		return ntStatus;
	}

	fpi.CurrentByteOffset.QuadPart = 100i64;
	ntStatus = ZwSetInformationFile(
		hFile,
		&ioStatus,
		&fpi,
		sizeof(FILE_POSITION_INFORMATION),
		FilePositionInformation
	);

	ZwClose(hFile);
	return ntStatus;
}


NTSTATUS ntWriteFile(WCHAR *szFileName)
{
	UNICODE_STRING uFileName = { 0 };
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	NTSTATUS ntStatus = STATUS_SUCCESS;
	HANDLE hFile = NULL;
	IO_STATUS_BLOCK ioStatus = { 0 };
	PUCHAR pBuffer = NULL;

	RtlInitUnicodeString(&uFileName, szFileName);

	InitializeObjectAttributes(
		&objectAttributes,
		&uFileName,
		OBJ_CASE_INSENSITIVE|OBJ_KERNEL_HANDLE,
		NULL,
		NULL
	);

	ntStatus = ZwCreateFile(
		&hFile,
		GENERIC_WRITE,
		&objectAttributes,
		&ioStatus,
		NULL,
		FILE_ATTRIBUTE_NORMAL,
		FILE_SHARE_WRITE,
		FILE_OPEN_IF,
		FILE_SYNCHRONOUS_IO_NONALERT,
		NULL,
		0
	);

	if (!NT_SUCCESS(ntStatus))
	{
		return ntStatus;
	}

	pBuffer = (PUCHAR)ExAllocatePoolWithTag(PagedPool, 1024, 'ELIF');
	if (NULL == pBuffer)
	{
		ZwClose(hFile);
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	RtlZeroMemory(pBuffer, 1024);

	RtlCopyMemory(pBuffer, L"Hello World!", wcslen(L"Hello World!") * sizeof(WCHAR));
	ntStatus = ZwWriteFile(
		hFile,
		NULL,
		NULL,
		NULL,
		&ioStatus,
		pBuffer,
		1024,
		NULL,
		NULL
	);
	ZwClose(hFile);
	ExFreePool(pBuffer);
	return ntStatus;

}

NTSTATUS ntReadFile(WCHAR *szFileName)
{

	NTSTATUS ntStatus = 0;
	UNICODE_STRING uFileName = { 0 };
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	IO_STATUS_BLOCK ioStatus = { 0 };
	HANDLE hFile = NULL;
	PUCHAR pBuffer = NULL;
	FILE_STANDARD_INFORMATION fsi = { 0 };

	RtlInitUnicodeString(&uFileName, szFileName);
	InitializeObjectAttributes(
		&objectAttributes,
		&uFileName,
		OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
		NULL,
		NULL
	);

	ntStatus = ZwCreateFile(
		&hFile,
		GENERIC_READ,
		&objectAttributes,
		&ioStatus,
		NULL,
		FILE_ATTRIBUTE_NORMAL,
		FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
		FILE_OPEN,
		FILE_SYNCHRONOUS_IO_NONALERT,
		NULL,
		0
	);
	if (!NT_SUCCESS(ntStatus))
	{
		return ntStatus;
	}
	ntStatus = ZwQueryInformationFile(
		hFile,
		&ioStatus,
		&fsi,
		sizeof(FILE_STANDARD_INFORMATION),
		FileStandardInformation
	);

	if (!NT_SUCCESS(ntStatus))
	{
		ZwClose(hFile);
		return ntStatus;
	}
	pBuffer = (PUCHAR)ExAllocatePoolWithTag(
		PagedPool, (LONG)fsi.EndOfFile.QuadPart, 'ELIF'
	);
	if (NULL == pBuffer)
	{
		ZwClose(hFile);
		return STATUS_INSUFFICIENT_RESOURCES;
	}
	
	ntStatus = ZwReadFile(
		hFile,
		NULL,
		NULL,
		NULL,
		&ioStatus,
		pBuffer,
		(LONG)fsi.EndOfFile.QuadPart,
		NULL,
		NULL
	);
	ZwClose(hFile);
	ExFreePool(pBuffer);
	return ntStatus;
}

NTSTATUS ntCopyFile(const WCHAR *src, const WCHAR *dst)
{
	UNICODE_STRING uSrc = { 0 };
	UNICODE_STRING uDst = { 0 };
	NTSTATUS ntStatus = 0;
	HANDLE hSrcFile = NULL;
	HANDLE hDstFile = NULL;
	OBJECT_ATTRIBUTES objectSrcAttrib = { 0 };
	OBJECT_ATTRIBUTES objectDstAttrib = { 0 };
	ULONG uReadSize = 0;
	ULONG uWriteSize = 0;
	ULONG length = 0;
	PVOID pBuffer = NULL;
	IO_STATUS_BLOCK io_status = { 0 };
	LARGE_INTEGER offset = { 0 };

	RtlInitUnicodeString(&uSrc, src);
	RtlInitUnicodeString(&uDst, dst);

	InitializeObjectAttributes(
		&objectSrcAttrib,
		&uSrc,
		OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
		NULL,
		NULL
	);
	InitializeObjectAttributes(
		&objectDstAttrib,
		&uDst,
		OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
		NULL,
		NULL
	);

	ntStatus = ZwCreateFile(
		&hSrcFile,
		FILE_READ_DATA | FILE_READ_ATTRIBUTES,
		&objectSrcAttrib,
		&io_status,
		NULL,
		FILE_ATTRIBUTE_NORMAL,
		FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
		FILE_OPEN,
		FILE_SYNCHRONOUS_IO_NONALERT,
		NULL,
		0
		);
	if (!NT_SUCCESS(ntStatus))
	{
		return ntStatus;
	}

	ntStatus = ZwCreateFile(
		&hDstFile,
		GENERIC_WRITE,
		&objectDstAttrib,
		&io_status,
		NULL,
		FILE_ATTRIBUTE_NORMAL,
		FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
		FILE_OPEN_IF,
		FILE_SYNCHRONOUS_IO_NONALERT,
		NULL,
		0
	);
	if (!NT_SUCCESS(ntStatus))
	{
		ZwClose(hSrcFile);
		return ntStatus;
	}
	pBuffer = ExAllocatePoolWithTag(PagedPool, 1024, 'ELIF');
	if (NULL == pBuffer)
	{
		ZwClose(hSrcFile);
		ZwClose(hDstFile);
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	while (1)
	{
		ntStatus = ZwReadFile(
			hSrcFile,
			NULL,
			NULL,
			NULL,
			&io_status,
			pBuffer,
			PAGE_SIZE,
			&offset,
			NULL
		);
		if (!NT_SUCCESS(ntStatus))
		{
			if (STATUS_END_OF_FILE == ntStatus)
			{
				ntStatus = STATUS_SUCCESS;
			}
			break;
		}
		length = (ULONG)io_status.Information;

		ntStatus = ZwWriteFile(
			hDstFile,
			NULL,
			NULL,
			NULL,
			&io_status,
			pBuffer,
			length,
			&offset,
			NULL
		);
		if (!NT_SUCCESS(ntStatus))
		{
			break;
		}
		offset.QuadPart += length;

	}
	ExFreePool(pBuffer);
	ZwClose(hSrcFile);
	ZwClose(hDstFile);
	return ntStatus;

}

NTSTATUS ntMoveFile(const WCHAR *src, const WCHAR *dst)
{
	NTSTATUS ntStatus = 0;
	ntStatus = ntCopyFile(src, dst);
	if (NT_SUCCESS(ntStatus))
	{
		ntStatus = ntDeleteFile(src);
	}
	return ntStatus;
}


NTSTATUS ntNormalDeleteFile(const WCHAR *szFileName)//普通删除
{
	NTSTATUS ntStatus = 0;
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	UNICODE_STRING uFileName = { 0 };

	RtlInitUnicodeString(&uFileName, szFileName);
	InitializeObjectAttributes(
		&objectAttributes,
		&uFileName,
		OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
		NULL,
		NULL
	);
	ntStatus = ZwDeleteFile(&objectAttributes);
	return ntStatus;

}


//1.下面这种删除通过设置属性，ZwCreateFile设置Delete
//2.如果不成功，ZwCreateFile with FILE_READ_ATTRIBUTES  FILE_WRITE_ATTRIBUTES，转入3
//3.如果成功，FILE_ATTRIBUTE_NORMAL
//ZwSetInformationFile,以 SYNCHRONIZE | FILE_WRITE_DATA | DELETE 打开文件




NTSTATUS ntDeleteFile(const WCHAR *szFileName)//删除 (设置属性的方式)
{
	UNICODE_STRING uFileName = { 0 };
	OBJECT_ATTRIBUTES objectAttributes = { 0 };
	HANDLE hFile = NULL;
	IO_STATUS_BLOCK ioStatus = { 0 };
	NTSTATUS ntStatus = 0;
	FILE_DISPOSITION_INFORMATION disInfo = { 0 };

	RtlInitUnicodeString(&uFileName, szFileName);

	InitializeObjectAttributes(
		&objectAttributes,
		&uFileName,
		OBJ_CASE_INSENSITIVE|OBJ_KERNEL_HANDLE,
		NULL,
		NULL
	);

	ntStatus = ZwCreateFile(
		&hFile,
		SYNCHRONIZE | FILE_WRITE_DATA | DELETE,
		&objectAttributes,
		&ioStatus,
		NULL,
		FILE_ATTRIBUTE_NORMAL,
		FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
		FILE_OPEN,
		FILE_SYNCHRONOUS_IO_NONALERT | FILE_DELETE_ON_CLOSE,
		NULL,
		0
	);
	if (!NT_SUCCESS(ntStatus))
	{
		if (STATUS_ACCESS_DENIED == ntStatus)
		{
			ntStatus = ZwCreateFile(
				&hFile,
				SYNCHRONIZE | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
				&objectAttributes,
				&ioStatus,
				NULL,
				FILE_ATTRIBUTE_NORMAL,
				FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
				FILE_OPEN,
				FILE_SYNCHRONOUS_IO_NONALERT,
				NULL,
				0
			);

			if (NT_SUCCESS(ntStatus))
			{
				FILE_BASIC_INFORMATION basicInfo = { 0 };

				ntStatus = ZwQueryInformationFile(
					hFile,
					&ioStatus,
					&basicInfo,
					sizeof(basicInfo),
					FileBasicInformation
				);
				if (!NT_SUCCESS(ntStatus))
				{
					DbgPrint("ZwQueryInformationFile(%wZ) failed(%x)\n", &uFileName, ntStatus);

				}
				basicInfo.FileAttributes = FILE_ATTRIBUTE_NORMAL;
				//The file does not have other attributes set. This attribute is valid only if used alone.
				//我的理解是设置为默认，其他属性就都没了
				ntStatus = ZwSetInformationFile(
					hFile,
					&ioStatus,
					&basicInfo,
					sizeof(basicInfo),
					FileBasicInformation
				);
				if (!NT_SUCCESS(ntStatus))
				{
					DbgPrint("ZwSetInformationFile(%wZ) failed(%x)\n", &uFileName, ntStatus);

				}

				ZwClose(hFile);
				ntStatus = ZwCreateFile(
					&hFile,
					SYNCHRONIZE | FILE_WRITE_DATA | DELETE,
					&objectAttributes,
					&ioStatus,
					NULL,
					FILE_ATTRIBUTE_NORMAL,
					FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
					FILE_OPEN,
					FILE_SYNCHRONOUS_IO_NONALERT | FILE_DELETE_ON_CLOSE,
					NULL,
					0
				);

			}

		}

		if (!NT_SUCCESS(ntStatus))
		{
			DbgPrint("ZwCreateFile(%wZ) failed(%x)\n", &uFileName, ntStatus);
			return ntStatus;
		}
	}
	disInfo.DeleteFile = TRUE;
	ntStatus = ZwSetInformationFile(
		hFile,
		&ioStatus,
		&disInfo,
		sizeof(disInfo),
		FileDispositionInformation
	);
	if (!NT_SUCCESS(ntStatus))
	{
		DbgPrint("ZwSetInformationFile(%wZ) failed(%x)\n", &uFileName, ntStatus);
	}
	ZwClose(hFile);
	return ntStatus;
}

 

kernweak
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
什么是ring0-ring3
黄腾霄的博客
03-01 6220
大家可能听说过某个代码需要运行在ring 0的说法。但是ring 0究竟是什么，今天就给大家介绍下。 权限控制 我们都知道计算机中运行着许多的软件，有些软件是和硬件打交道的，比如驱动软件，操作系统软件，有些软件只是运行在操作系统之上的，比如浏览器，文本编辑软件等。 为什么要这样设计？ 这是为了控制运行软件的权限，让一些特定的软件才能执行某些“危险”的行为，比如读写特定的内存等。 这里就引申出了我...
Ring0删除文件.rar
10-26
Ring0删除文件.rarRing0删除文件.rarRing0删除文件.rarRing0删除文件.rarRing0删除文件.rarRing0删除文件.rarRing0删除文件.rarRing0删除文件.rar
RING0.zip_ring0_强制删除_文件强删_驱动删除_驱动强删
07-14
强删文件RING0代码，驱动强制删除文件
文件操作-Malloc笔记
zhuhuibeishadiao
04-02 947
创建文件/文件夹 读/写 拷贝 移动 删除 属性访问与设置 应用层：”c:\\hi.txt” 内核：L”\\??\\c:\\hi.txt” R3: 设备名：L”\\\\.\\xxxDrv” R0 设备名：”\\device\\xxxDrv” 符号连接名：”\\dosdevices\\xxxDrv” 常用API ZwCreateFile //集创建
删除或重命名正在打开的文件
axit27651846的博客
01-02 228
删除或重命名正在打开的文件 Windows NT中有一个函数MoveFileEx，若使用MOVEFILE_DELAY_UNTIL_REBOOT 标记，它可以在重启过程中删除文件。但是，Windows 9x 并不支持这个标记。怎么办呢？ 每次当你重启，windows会在Windows目录下寻找文件WININIT.INI。这个文件包含删除/复制/重命名文件的命令，它可以在任何东西（实...
驱动开发之 ZwCreateFile函数
Lydia的博客
06-13 8810
函数原型： NTSTATUS ZwCreateFile( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_
SSDT.rar_ring0_ssdt
09-19
操作系统内核就运行在Ring0，因此它具有无限制的权力，能够执行所有硬件操作。 Ring3则对应用户模式，是应用程序通常运行的地方，它受到很多安全限制，无法直接访问硬件资源，必须通过系统调用来请求Ring0的服务。...
任意用户模式下执行 ring 0 代码.rar_ring_ring 0
09-21
在计算机系统中，Ring 0 是操作系统的内核态，拥有最高的权限级别，它能够访问所有的硬件资源并执行任何操作。通常，用户模式的应用程序是不允许直接运行在 Ring 0 的，因为这样可能会引发安全问题，如数据破坏、...
编写ring0内核驱动程序,检测隐藏进程.zip
01-25
Ring0内核驱动程序运行在操作系统的最底层，拥有最高的权限，能够直接访问硬件和系统资源，包括管理和控制进程。这篇内容将深入探讨如何编写Ring0内核驱动来检测隐藏进程，并结合"驱动加载软件"、"ring3 exe加载ring...
ring0驱动层上实现 隐藏进程(无进程 无端口 无服务)的简单demo.zip
01-24
在IT领域，尤其是在系统安全和恶意软件分析中，"ring0驱动层上实现隐藏进程"是一种高级技术，它涉及到操作系统内核级别的编程。Ring0是CPU执行级别中的最高权限级别，通常只允许操作系统核心和设备驱动程序访问。...
C++中CopyFile和MoveFile函数使用区别的示例分析
08-18
主要介绍了C++中CopyFile和MoveFile函数使用区别的示例分析，CopyFile表示将文件A拷贝到B，如果B已经存在则覆盖，MoveFile表示将文件A移动到。对此感兴趣的可以来了解一下
驱动层ring0和应用层ring3软件通信.zip
01-27
在x86架构中，操作系统通常使用保护模式，其中Ring0和Ring3是两个关键的执行级别，分别代表了最高的系统权限和最低的用户权限。本资料"驱动层ring0和应用层ring3软件通信.zip"将深入探讨这两个层次之间的通信机制。 ...
ring0驱动内核级的ROOTKIT实现隐藏文件，隐藏注册表项，隐藏端口.zip
01-27
在Ring0层，Rootkit可以更有效地实现这些功能，因为它能直接操作内核数据结构，如文件系统和网络栈，来隐藏文件、注册表项和网络端口。 **隐藏文件和注册表项** 在Windows系统中，Rootkit可以修改文件系统驱动，使...
SSDT 对抗 ring0 inline hook, 通过SSDT绕过inline Hook.zip
01-24
在x86/x64架构的CPU中，操作系统运行在ring0特权级别，这是最高的权限等级，可以访问所有的硬件资源。黑客或恶意软件通常会使用ring0 inline hook来监控或篡改系统关键函数的行为。它们会直接在内核模式下的原函数...
易语言源码无驱动进入ring0易语言源码.rar
03-30
"无驱动进入ring0"是指在不依赖设备驱动程序的情况下，将程序的执行权限提升到操作系统最核心的Ring0层。在Windows系统中，Ring0是最高级别的特权级，通常只有操作系统内核才能运行在此模式下。 易语言源码进入Ring...
ZwCreateFile
死胖子的博客
02-04 8706
ZwCreateFile routine ZwCreateFile 创建一个新的文件或者打开一个已经存在的文件。 Syntax C++ NTSTATUS ZwCreateFile( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJE
用CopyFile复制文件
mail_cm的专栏
04-05 8381
BOOL CopyFile(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,BOOL bFailIfExists ); 说明　　 　　Long，非零表示成功，零表示失败。 　　 参数类型及说明 ： 　　lpExistingFileName String：输入参数，已经存在的所需复制文件的源路径。 　　lpNewFileName St
深入理解 ZwCreateFile
HXC_HUANG的博客
04-11 1541
前言：任何编码的东西必须充分的了解规则！我试探性的搜索了下关于这个native api的相关的问题，很郁闷的发现，这些问题90%都是没有真正理解了这个函数导致的！有的人连函数干嘛的都不知道就着急的写驱动，真是不可一世！所谓兼收并蓄为的是厚积薄发，其间如履薄冰。说的很贴切！对此我一直支持achills师傅的思想！搞明白了最基本的和必须的东西，一切后续的东西迎刃而解！这个文章我没有过多的写什么东西，因为
Ring0和Ring3
weixin_43742894的博客
05-13 2798
Intel的CPU将特权级别分为4个级别：RING0,RING1,RING2,RING3。 Windows只使用RING0和RING3，RING0只给操作系统用，RING3谁都能用。 如果普通应用程序企图执行RING0指令，则Windows会显示“非法指令”错误信息。因为有CPU的特权级别作保护。 ring0是指CPU的运行级别，ring0是最高级别，ring1次之，ring2更次之…… 以Li...
winring0 驱动怎么在ring3加载
最新发布
05-16
WinRing0驱动是一个操作系统级别的驱动程序，运行在Ring0特权级别。在Ring3特权级别下不能直接加载WinRing0驱动。但是可以通过使用WinRing0的API函数来访问其功能，从而达到Ring0级别的操作效果。 首先需要安装...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值