驱动—文件操作

已于 2025-03-27 17:25:38 修改
阅读量157 收藏
点赞数 2
分类专栏： 内核编程 文章标签： windows
于 2024-10-20 08:21:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48257887/article/details/143087985
版权

内核代码：

#include <ntifs.h>

#define DEVICE_NAME L"\\device\\MyDricer1" //设备对象名称
#define LINK_NAME L"\\dosdevices\\Goose" //符号链接名称
#define Io_Control_Code(i) CTL_CODE( FILE_DEVICE_UNKNOWN, 0x800 + i, METHOD_BUFFERED, FILE_ANY_ACCESS )//必须的宏定义
#define CTL_CREATE Io_Control_Code(0)
#define CTL_WRITE Io_Control_Code(1)
#define CTL_READ Io_Control_Code(2)
#define CTL_DELETE Io_Control_Code(3)
#define CTL_COPY Io_Control_Code(4)
#define CTL_MOVE Io_Control_Code(5)
#define CTL_GETATTR Io_Control_Code(6)
#define CTL_SETATTR Io_Control_Code(7)
#define CTL_SETDELETE Io_Control_Code(8)
#define CTL_SETNAME Io_Control_Code(9)
#define CTL_PROTECT Io_Control_Code(10)
#define CTL_UNPROTECT Io_Control_Code(11)

ULONG RetNtstatus(NTSTATUS ntStatus, WCHAR* szbuffer, PVOID IOBuffer, ULONG OutPutLength);
ULONG Name_Flag = 0;
HANDLE g_handle = 0;
typedef struct  WriteData
{
	WCHAR PathBuffer[260];
	WCHAR DataBuffer[0x1024];
}WriteData, * PWriteData;

NTSTATUS CreateFileFunc(PVOID IOBuffer)
{
	UNICODE_STRING usStrbuffer0 = { 0 };
	UNICODE_STRING usStrbuffer1 = { 0 };
	UNICODE_STRING usStrbuffer2 = { 0 };
	WCHAR wcbuffer[256];
	RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
	RtlInitUnicodeString(&usStrbuffer0, (WCHAR*)IOBuffer);
	RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
	OBJECT_ATTRIBUTES p = { 0 };
	InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
	HANDLE FileHandle;
	IO_STATUS_BLOCK ioblock = { 0 };
	NTSTATUS ntStatus = ZwCreateFile(&FileHandle, GENERIC_ALL, &p, &ioblock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_VALID_FLAGS, FILE_CREATE, FILE_NON_DIRECTORY_FILE, 0, 0);
	if (ntStatus == STATUS_SUCCESS)
	{
		ZwClose(FileHandle);
	}
	return ntStatus;
}

NTSTATUS WriteFileFunc(PVOID IOBuffer)
{
	WriteData WriteDataObj = *(WriteData*)IOBuffer;
	UNICODE_STRING usStrbuffer0 = { 0 };
	UNICODE_STRING usStrbuffer1 = { 0 };
	UNICODE_STRING usStrbuffer2 = { 0 };
	WCHAR wcbuffer[256];
	RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
	RtlInitUnicodeString(&usStrbuffer0, WriteDataObj.PathBuffer);
	RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
	DbgPrint("%ws", WriteDataObj.DataBuffer);
	OBJECT_ATTRIBUTES p = { 0 };
	InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
	HANDLE FileHandle;
	IO_STATUS_BLOCK ioblock = { 0 };
	NTSTATUS ntStatus = ZwCreateFile(&FileHandle, GENERIC_ALL, &p, &ioblock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_VALID_FLAGS, FILE_OPEN_IF, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_ALERT, 0, 0);
	if (ntStatus == STATUS_SUCCESS)
	{
		ULONG szie = wcslen(WriteDataObj.DataBuffer) * sizeof(WCHAR);
		ntStatus = ZwWriteFile(FileHandle, 0, 0, 0, &ioblock, WriteDataObj.DataBuffer, szie, 0, 0);
		ZwClose(FileHandle);
	}
	return ntStatus;
}

NTSTATUS ReadFileFunc(PVOID IOBuffer, ULONG* OutPutSize)
{
	UNICODE_STRING usStrbuffer0 = { 0 };
	UNICODE_STRING usStrbuffer1 = { 0 };
	UNICODE_STRING usStrbuffer2 = { 0 };
	WCHAR wcbuffer[256];
	RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
	RtlInitUnicodeString(&usStrbuffer0, (WCHAR*)IOBuffer);
	RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
	OBJECT_ATTRIBUTES p = { 0 };
	InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
	HANDLE FileHandle;
	IO_STATUS_BLOCK ioblock = { 0 };
	NTSTATUS ntStatus = ZwCreateFile(&FileHandle, GENERIC_ALL, &p, &ioblock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_VALID_FLAGS, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, 0, 0);
	static ULONG Read_Flag = 0;
	if (ntStatus == STATUS_SUCCESS)
	{
		if (Read_Flag)
		{
			CHAR* readbuff = ExAllocatePool(PagedPool, *OutPutSize);
			ntStatus = ZwReadFile(FileHandle, 0, 0, 0, &ioblock, readbuff, *OutPutSize, 0, 0);
			RtlCopyMemory(IOBuffer, readbuff, *OutPutSize);
			Read_Flag = 0;
			ExFreePool(readbuff);
		}
		else
		{
			Read_Flag = 1;
			FILE_STANDARD_INFORMATION fsi = { 0 };
			ntStatus = ZwQueryInformationFile(FileHandle, &ioblock, &fsi, sizeof(fsi), FileStandardInformation);
			*OutPutSize = fsi.EndOfFile.QuadPart;
		}
	}
	ZwClose(FileHandle);
	return ntStatus;
}

NTSTATUS DeleteFileFunc(PVOID IOBuffer)
{

	UNICODE_STRING usStrbuffer0 = { 0 };
	UNICODE_STRING usStrbuffer1 = { 0 };
	UNICODE_STRING usStrbuffer2 = { 0 };
	WCHAR wcbuffer[256];
	RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
	RtlInitUnicodeString(&usStrbuffer0, IOBuffer);
	RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
	OBJECT_ATTRIBUTES p = { 0 };
	InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
	NTSYSAPI NTSTATUS ZwDeleteFile(
		POBJECT_ATTRIBUTES ObjectAttributes
	);
	NTSTATUS ntstatus = ZwDeleteFile(&p);
	return ntstatus;
}

NTSTATUS CopyFileFunc(PVOID IOBuffer)
{
	UNICODE_STRING usStrbuffer0 = { 0 };
	UNICODE_STRING usStrbuffer1 = { 0 };
	UNICODE_STRING usStrbuffer2 = { 0 };
	WCHAR wcbuffer[256];
	RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
	RtlInitUnicodeString(&usStrbuffer0, IOBuffer);
	RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
	OBJECT_ATTRIBUTES p = { 0 };
	InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
	static CHAR* readbuff;
	static ULONG Copy_Flag = 0;
	static ULONG wsize;
	NTSTATUS ntStatus;
	HANDLE FileHandle = 0;
	if (!Copy_Flag)
	{
		Copy_Flag = 1;
		IO_STATUS_BLOCK ioblock = { 0 };
		ntStatus = ZwCreateFile(&FileHandle, GENERIC_ALL, &p, &ioblock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_VALID_FLAGS, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, 0, 0);
		FILE_STANDARD_INFORMATION fsi = { 0 };
		ZwQueryInformationFile(FileHandle, &ioblock, &fsi, sizeof(fsi), FileStandardInformation);
		wsize = fsi.EndOfFile.QuadPart;
		readbuff = ExAllocatePool(PagedPool, wsize);
		ZwReadFile(FileHandle, 0, 0, 0, &ioblock, readbuff, wsize, 0, 0);
	}
	else
	{
		Copy_Flag = 0;
		IO_STATUS_BLOCK ioblock = { 0 };
		ZwCreateFile(&FileHandle, GENERIC_ALL, &p, &ioblock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_VALID_FLAGS, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, 0, 0);
		ntStatus = ZwWriteFile(FileHandle, 0, 0, 0, &ioblock, readbuff, wsize, 0, 0);
	}
	ZwClose(FileHandle);
	return ntStatus;
}

NTSTATUS MoveFileFunc(PVOID IOBuffer)
{
	UNICODE_STRING usStrbuffer0 = { 0 };
	UNICODE_STRING usStrbuffer1 = { 0 };
	UNICODE_STRING usStrbuffer2 = { 0 };
	WCHAR wcbuffer[256];
	RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
	RtlInitUnicodeString(&usStrbuffer0, IOBuffer);
	RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
	OBJECT_ATTRIBUTES p = { 0 };
	InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
	static CHAR* readbuff;
	static ULONG MOve_Flag = 0;
	static ULONG wsize;
	NTSTATUS ntStatus;
	HANDLE FileHandle = 0;
	if (!MOve_Flag)
	{
		MOve_Flag = 1;
		IO_STATUS_BLOCK ioblock = { 0 };
		ntStatus = ZwCreateFile(&FileHandle, GENERIC_ALL, &p, &ioblock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_VALID_FLAGS, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, 0, 0);
		FILE_STANDARD_INFORMATION fsi = { 0 };
		ZwQueryInformationFile(FileHandle, &ioblock, &fsi, sizeof(fsi), FileStandardInformation);
		wsize = fsi.EndOfFile.QuadPart;
		readbuff = ExAllocatePool(PagedPool, wsize);
		ZwReadFile(FileHandle, 0, 0, 0, &ioblock, readbuff, wsize, 0, 0);
		DeleteFileFunc(IOBuffer);
	}
	else
	{
		MOve_Flag = 0;
		IO_STATUS_BLOCK ioblock = { 0 };
		ZwCreateFile(&FileHandle, GENERIC_ALL, &p, &ioblock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_VALID_FLAGS, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, 0, 0);
		ntStatus = ZwWriteFile(FileHandle, 0, 0, 0, &ioblock, readbuff, wsize, 0, 0);
	}
	ZwClose(FileHandle);
	return ntStatus;
}

NTSTATUS GetFileFunc(PVOID IOBuffer, ULONG* OutPutSize)
{
	UNICODE_STRING usStrbuffer0 = { 0 };
	UNICODE_STRING usStrbuffer1 = { 0 };
	UNICODE_STRING usStrbuffer2 = { 0 };
	WCHAR wcbuffer[256];
	RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
	RtlInitUnicodeString(&usStrbuffer0, IOBuffer);
	RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
	OBJECT_ATTRIBUTES p = { 0 };
	InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
	FILE_NETWORK_OPEN_INFORMATION fnoi = { 0 };
	NTSTATUS ntstatus = ZwQueryFullAttributesFile(&p, &fnoi);
	if (fnoi.FileAttributes & FILE_ATTRIBUTE_ARCHIVE)
	{
		*OutPutSize = wcslen(L"ARCHIVE") * 2;
		RtlCopyMemory(IOBuffer, L"ARCHIVE", *OutPutSize);
	}
	if (fnoi.FileAttributes & FILE_ATTRIBUTE_HIDDEN)
	{
		*OutPutSize = wcslen(L"HIDDEN") * 2;
		RtlCopyMemory(IOBuffer, L"HIDDEN", *OutPutSize);
	}
	if (fnoi.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
	{
		*OutPutSize = wcslen(L"DIRECTORY") * 2;
		RtlCopyMemory(IOBuffer, L"DIRECTORY", *OutPutSize);
	}
	return ntstatus;

}

NTSTATUS SetFileFunc(PVOID IOBuffer, ULONG* OutPutSize)
{
	UNICODE_STRING usStrbuffer0 = { 0 };
	UNICODE_STRING usStrbuffer1 = { 0 };
	UNICODE_STRING usStrbuffer2 = { 0 };
	WCHAR wcbuffer[256];
	RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
	RtlInitUnicodeString(&usStrbuffer0, IOBuffer);
	RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
	OBJECT_ATTRIBUTES p = { 0 };
	InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
	HANDLE FileHandle;
	IO_STATUS_BLOCK ioblock = { 0 };
	NTSTATUS ntStatus = ZwCreateFile(&FileHandle, GENERIC_ALL, &p, &ioblock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_VALID_FLAGS, FILE_OPEN_IF, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, 0, 0);
	DbgBreakPoint();
	if (ntStatus == STATUS_SUCCESS)
	{
		FILE_POSITION_INFORMATION fpi = { 100 };
		ntStatus = ZwSetInformationFile(FileHandle, &ioblock, &fpi, sizeof(fpi), FilePositionInformation);
		FILE_STANDARD_INFORMATION fsi = { 0 };
		ntStatus = ZwQueryInformationFile(FileHandle, &ioblock, &fsi, sizeof(fsi), FileStandardInformation);
		*OutPutSize = fsi.EndOfFile.QuadPart;
		ntStatus = ZwReadFile(FileHandle, 0, 0, 0, &ioblock, IOBuffer, *OutPutSize, 0, 0);
	}
	ZwClose(FileHandle);
	return ntStatus;
}

NTSTATUS SetDeleteFileFunc(PVOID IOBuffer)
{
	UNICODE_STRING usStrbuffer0 = { 0 };
	UNICODE_STRING usStrbuffer1 = { 0 };
	UNICODE_STRING usStrbuffer2 = { 0 };
	WCHAR wcbuffer[256];
	RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
	RtlInitUnicodeString(&usStrbuffer0, IOBuffer);
	RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
	OBJECT_ATTRIBUTES p = { 0 };
	InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
	HANDLE FileHandle;
	IO_STATUS_BLOCK ioblock = { 0 };
	NTSTATUS ntStatus = ZwCreateFile(&FileHandle, GENERIC_ALL, &p, &ioblock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_VALID_FLAGS, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, 0, 0);
	if (ntStatus == STATUS_SUCCESS)
	{
		FILE_DISPOSITION_INFORMATION fdi = { TRUE };
		ntStatus = ZwSetInformationFile(FileHandle, &ioblock, &fdi, sizeof(fdi), FileDispositionInformation);
	}
	ZwClose(FileHandle);
	return ntStatus;
}

NTSTATUS SetFileNameFunc(PVOID IOBuffer)
{
	NTSTATUS ntStatus = 0;
	static HANDLE FileHandle;
	IO_STATUS_BLOCK ioblock = { 0 };
	if (Name_Flag == 0)
	{
		UNICODE_STRING usStrbuffer0 = { 0 };
		UNICODE_STRING usStrbuffer1 = { 0 };
		UNICODE_STRING usStrbuffer2 = { 0 };
		WCHAR wcbuffer[256];
		RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
		RtlInitUnicodeString(&usStrbuffer0, IOBuffer);
		RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
		RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
		RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
		OBJECT_ATTRIBUTES p = { 0 };
		InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
		ntStatus = ZwCreateFile(&FileHandle, GENERIC_ALL, &p, &ioblock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_VALID_FLAGS, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT | FILE_NO_INTERMEDIATE_BUFFERING, 0, 0);
		if (ntStatus == 0)
		{
			Name_Flag = 1;
		}
	}
	else
	{
		Name_Flag = 0;
		FILE_RENAME_INFORMATION fri = { 0 };
		fri.FileNameLength = wcslen(IOBuffer) * 2;
		memcpy(fri.FileName, IOBuffer, fri.FileNameLength);
		fri.ReplaceIfExists = fri.RootDirectory = 0;
		ntStatus = ZwSetInformationFile(FileHandle, &ioblock, &fri, sizeof(fri) + fri.FileNameLength, FileRenameInformation);
		ZwClose(FileHandle);
	}
	return ntStatus;
}

NTSTATUS ProtectFileFunc(PVOID IOBuffer)
{
	UNICODE_STRING usStrbuffer0 = { 0 };
	UNICODE_STRING usStrbuffer1 = { 0 };
	UNICODE_STRING usStrbuffer2 = { 0 };
	WCHAR wcbuffer[256];
	RtlInitEmptyUnicodeString(&usStrbuffer2, wcbuffer, sizeof(wcbuffer));
	RtlInitUnicodeString(&usStrbuffer0, IOBuffer);
	RtlInitUnicodeString(&usStrbuffer1, L"\\??\\");
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer1);
	RtlAppendUnicodeStringToString(&usStrbuffer2, &usStrbuffer0);
	OBJECT_ATTRIBUTES p = { 0 };
	InitializeObjectAttributes(&p, &usStrbuffer2, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, 0, 0);
	HANDLE FileHandle = 0;
	IO_STATUS_BLOCK isb = { 0 };
	NTSTATUS ntstatus = ZwOpenFile(&FileHandle, GENERIC_ALL, &p, &isb, 0, FILE_SYNCHRONOUS_IO_NONALERT | FILE_NO_INTERMEDIATE_BUFFERING);
	g_handle = FileHandle;
	return ntstatus;
}

NTSTATUS UnProtectFileFunc(PVOID IOBuffer)
{
	NTSTATUS ret = 1;
	if (g_handle)
	{
		ret = ZwClose(g_handle);
	}
	return ret;
}

NTSTATUS DisPatch_DeviceControl(PDEVICE_OBJECT Device, PIRP irp)
{
	NTSTATUS ntStatus = 0;
	PIO_STACK_LOCATION  pDeviceStack = IoGetCurrentIrpStackLocation(irp);
	ULONG ControlCode = pDeviceStack->Parameters.DeviceIoControl.IoControlCode;//R3的控制码
	ULONG InputLength = pDeviceStack->Parameters.DeviceIoControl.InputBufferLength;//R3->R0的输入缓冲区大小
	ULONG OutPutLength = pDeviceStack->Parameters.DeviceIoControl.OutputBufferLength;//R3的接受缓冲区大小
	PVOID IOBuffer = irp->AssociatedIrp.SystemBuffer;
	static ULONG OutPutSize = 0;
	switch (ControlCode)
	{
	case CTL_CREATE:
	{
		ntStatus = CreateFileFunc(IOBuffer);
		WCHAR szbuffer[0x30] = L"CreateFile";
		OutPutSize = RetNtstatus(ntStatus, szbuffer, IOBuffer, OutPutLength);
		break;
	}
	case CTL_WRITE:
	{
		ntStatus = WriteFileFunc(IOBuffer);
		WCHAR szbuffer[0x30] = L"WriteFile";
		OutPutSize = RetNtstatus(ntStatus, szbuffer, IOBuffer, OutPutLength);
		break;
	}
	case CTL_READ:
	{
		ntStatus = ReadFileFunc(IOBuffer, &OutPutSize);
		break;
	}
	case CTL_DELETE:
	{
		ntStatus = DeleteFileFunc(IOBuffer);
		WCHAR szbuffer[0x30] = L"DeleteFile";
		OutPutSize = RetNtstatus(ntStatus, szbuffer, IOBuffer, OutPutLength);
		break;
	}
	case CTL_COPY:
	{
		ntStatus = CopyFileFunc(IOBuffer);
		break;
	}
	case CTL_MOVE:
	{
		ntStatus = MoveFileFunc(IOBuffer);
		break;
	}
	case CTL_GETATTR:
	{
		ntStatus = GetFileFunc(IOBuffer, &OutPutSize);
		break;
	}
	case CTL_SETATTR:
	{
		ntStatus = SetFileFunc(IOBuffer, &OutPutSize);
		break;
	}
	case CTL_SETDELETE:
	{
		ntStatus = SetDeleteFileFunc(IOBuffer);
		WCHAR szbuffer[0x30] = L"DeleteFile";
		OutPutSize = RetNtstatus(ntStatus, szbuffer, IOBuffer, OutPutLength);
		break;
	}
	case CTL_SETNAME:
	{
		ntStatus = SetFileNameFunc(IOBuffer);
		if (Name_Flag == 1)
		{
			WCHAR szbuffer[0x30] = L"OpenFile";
			OutPutSize = RetNtstatus(ntStatus, szbuffer, IOBuffer, OutPutLength);
		}
		else
		{
			WCHAR szbuffer[0x30] = L"SetFileName";
			OutPutSize = RetNtstatus(ntStatus, szbuffer, IOBuffer, OutPutLength);
		}
		break;
	}
	case CTL_PROTECT:
	{
		ntStatus = ProtectFileFunc(IOBuffer);
		WCHAR szbuffer[0x30] = L"Protect";
		OutPutSize = RetNtstatus(ntStatus, szbuffer, IOBuffer, OutPutLength);
		break;
	}
	case CTL_UNPROTECT:
	{
		ntStatus = UnProtectFileFunc(IOBuffer);
		WCHAR szbuffer[0x30] = L"UnProtect";
		OutPutSize = RetNtstatus(ntStatus, szbuffer, IOBuffer, OutPutLength);
		break;
	}
	default:
		break;
	}

	irp->IoStatus.Information = OutPutSize;//设置返回的字节数
	irp->IoStatus.Status = STATUS_SUCCESS;//设置irp处理成功
	IoCompleteRequest(irp, IO_NO_INCREMENT);//结束irp处理流程
	return STATUS_SUCCESS;
}


NTSTATUS DisPatchFunc(PDEVICE_OBJECT Device, PIRP irp)
{
	irp->IoStatus.Information = 0;//设置返回的字节数
	irp->IoStatus.Status = STATUS_SUCCESS;//设置irp处理成功
	IoCompleteRequest(irp, IO_NO_INCREMENT);//结束irp处理流程
	return STATUS_SUCCESS;
}

NTSTATUS UnLoadFunc(PDRIVER_OBJECT pDriverObj)
{
	UNICODE_STRING uLinkName = RTL_CONSTANT_STRING(LINK_NAME);//初始化符号链接名称
	IoDeleteSymbolicLink(&uLinkName);//删除符号链接
	IoDeleteDevice(pDriverObj->DeviceObject);//删除设备对象
	DbgPrint("Unload Success");
}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegPath)
{
	pDriverObj->DriverUnload = UnLoadFunc;
	UNICODE_STRING uDeviceName = RTL_CONSTANT_STRING(DEVICE_NAME);
	UNICODE_STRING uLinkName = RTL_CONSTANT_STRING(LINK_NAME);
	PDEVICE_OBJECT pDeviceObject = NULL;
	NTSTATUS ntStatus = IoCreateDevice(pDriverObj, 0, &uDeviceName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDeviceObject);
	if (ntStatus != STATUS_SUCCESS)
	{
		DbgPrint("IoCreateDevice failed:%x\n", ntStatus);
		return ntStatus;
	}
	pDeviceObject->Flags |= DO_BUFFERED_IO;
	ntStatus = IoCreateSymbolicLink(&uLinkName, &uDeviceName);
	if (ntStatus != STATUS_SUCCESS)
	{
		IoDeleteDevice(pDeviceObject);
		DbgPrint("IoCreateSymbolicLink failed:%x\n", ntStatus);
		return ntStatus;
	}
	for (size_t i = 0; i < IRP_MJ_MAXIMUM_FUNCTION + 1; i++)
	{
		pDriverObj->MajorFunction[i] = DisPatchFunc;
	}
	pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DisPatch_DeviceControl;
	DbgPrint("Load Success");
	return 0;
}

ULONG RetNtstatus(NTSTATUS ntStatus, WCHAR* szbuffer, PVOID IOBuffer, ULONG OutPutLength)
{
	ULONG OutPutSize;
	if (ntStatus == STATUS_SUCCESS)
	{

		WCHAR buffer[] = L" Success!";
		wcscat(szbuffer, buffer);
		OutPutSize = wcslen(szbuffer) * sizeof(WCHAR);
		RtlZeroMemory(IOBuffer, OutPutLength);
		RtlCopyMemory(IOBuffer, szbuffer, OutPutSize);
	}
	else
	{
		WCHAR buffer[] = L" Failed!";
		wcscat(szbuffer, buffer);
		OutPutSize = wcslen(szbuffer) * sizeof(WCHAR);
		RtlZeroMemory(IOBuffer, OutPutLength);
		RtlCopyMemory(IOBuffer, szbuffer, OutPutSize);
	}
	return OutPutSize;
}

用户代码：

#include <iostream>
#include <windows.h>

#define LINK_NAME L"\\\\.\\Goose" //符号链接名称
#define Io_Control_Code(i) CTL_CODE( FILE_DEVICE_UNKNOWN, 0x800 + i, METHOD_BUFFERED, FILE_ANY_ACCESS )
#define CTL_CREATE Io_Control_Code(0)
#define CTL_WRITE Io_Control_Code(1)
#define CTL_READ Io_Control_Code(2)
#define CTL_DELETE Io_Control_Code(3)
#define CTL_COPY Io_Control_Code(4)
#define CTL_MOVE Io_Control_Code(5)
#define CTL_GETATTR Io_Control_Code(6)
#define CTL_SETATTR Io_Control_Code(7)
#define CTL_SETDELETE Io_Control_Code(8)
#define CTL_SETNAME Io_Control_Code(9)
#define CTL_PROTECT Io_Control_Code(10)
#define CTL_UNPROTECT Io_Control_Code(11)
WCHAR InputBuffer[0x1024] = { 0 };
WCHAR OutputBuffer[0x1024] = { 0 };

typedef struct  WriteData
{
	WCHAR PathBuffer[MAX_PATH];
	WCHAR DataBuffer[0x1024];
}WriteData,*PWriteData;

void CreateFileFunc(HANDLE hRet)
{
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	bool ret = DeviceIoControl(hRet, CTL_CREATE, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	if (ret == TRUE)
	{
		_cwprintf(L"%s\n", OutputBuffer);
	}
	else
	{
		printf("error");
	}
}

void WriteFileFunc(HANDLE hRet)
{
	WriteData WriteDataObj = { 0 };
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入文件路径：");
	wscanf_s(L"%s", WriteDataObj.PathBuffer, (DWORD)_countof(WriteDataObj.PathBuffer));
	getwchar();
	printf("输入文件数据：");
	wscanf_s(L"%[^\n]", WriteDataObj.DataBuffer, (DWORD)_countof(WriteDataObj.DataBuffer));
	DWORD dwRet;
	bool ret = DeviceIoControl(hRet, CTL_WRITE, &WriteDataObj, sizeof(WriteDataObj), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	if (ret == TRUE)
	{
		_cwprintf(L"%s\n", OutputBuffer);
	}
	else
	{
		printf("error");
	}
}

void ReadFileFunc(HANDLE hRet)
{
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入要读取文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	DeviceIoControl(hRet, CTL_READ, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	if (OutputBuffer == 0)
	{
		printf("读取错误\n");
		return;
	}
	DWORD buffersize = dwRet;
	printf("%d", dwRet);
	WCHAR* readbuffer = new WCHAR[buffersize/2]{ 0 };//除于2 看看
	DeviceIoControl(hRet, CTL_READ, InputBuffer, sizeof(InputBuffer), readbuffer, buffersize, &dwRet, 0);
	HANDLE ret = CreateFileA("c:\\buffer.txt", GENERIC_READ | GENERIC_WRITE, 0, 0, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0);
	DWORD NumberOfBytesWritten;
	WriteFile(ret, readbuffer, buffersize, &NumberOfBytesWritten, 0);
	CloseHandle(ret);
}

void DeleteFileFunc(HANDLE hRet)
{
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入删除的文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	bool ret = DeviceIoControl(hRet, CTL_DELETE, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	if (ret == TRUE)
	{
		_cwprintf(L"%s\n", OutputBuffer);
	}
	else
	{
		printf("error");
	}
}

void CopyFileFunc(HANDLE hRet)
{
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入需要复制的源文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	bool ret = DeviceIoControl(hRet, CTL_COPY, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	getwchar();
	printf("输入复制到目的文件的路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	ret = DeviceIoControl(hRet, CTL_COPY, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	if (ret == TRUE)
	{
		_cwprintf(L"%s\n", OutputBuffer);
	}
	else
	{
		printf("error");
	}
}

void MoveFileFunc(HANDLE hRet)
{
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入需要移动的源文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	bool ret = DeviceIoControl(hRet, CTL_MOVE, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	getwchar();
	printf("输入移动目的的路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	ret = DeviceIoControl(hRet, CTL_MOVE, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	if (ret == TRUE)
	{
		_cwprintf(L"%s\n", OutputBuffer);
	}
	else
	{
		printf("error");
	}
}

void GetFileFunc(HANDLE hRet)
{
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入获取属性的文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	bool ret = DeviceIoControl(hRet, CTL_GETATTR, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	if (ret == TRUE)
	{
		_cwprintf(L"%s\n", OutputBuffer);
	}
	else
	{
		printf("error");
	}
}

void SetFileFunc(HANDLE hRet)
{
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入设置属性的文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	bool ret = DeviceIoControl(hRet, CTL_SETATTR, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	if (ret == TRUE)
	{
		printf("%s\n", (char*)OutputBuffer);
	}
	else
	{
		printf("error");
	}
}

void SetDeleteFileFunc(HANDLE hRet)
{
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入删除的文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	bool ret = DeviceIoControl(hRet, CTL_SETDELETE, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	if (ret == TRUE)
	{
		_cwprintf(L"%s\n", OutputBuffer);
	}
	else
	{
		printf("error");
	}
}

void SetFileNameFunc(HANDLE hRet)
{
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入重命名的文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	DeviceIoControl(hRet, CTL_SETNAME, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	if (wcsstr(OutputBuffer,L"Success"))
	{
		ZeroMemory(InputBuffer, sizeof(InputBuffer));
		ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
		printf("输入新名称：");
		wscanf_s(L"%ls", InputBuffer, 0x1024);
		DeviceIoControl(hRet, CTL_SETNAME, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	}
	else
	{
		printf("error");
	}
}

void ProtectFileFunc(HANDLE hRet)
{
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入保护的文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	DeviceIoControl(hRet, CTL_PROTECT, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	_cwprintf(L"%ls", OutputBuffer);
}

void UnProtectFileFunc(HANDLE hRet)
{
	ZeroMemory(InputBuffer, sizeof(InputBuffer));
	ZeroMemory(OutputBuffer, sizeof(OutputBuffer));
	system("cls");
	printf("输入解除保护的文件路径：");
	wscanf_s(L"%ls", InputBuffer, 0x1024);
	DWORD dwRet;
	DeviceIoControl(hRet, CTL_UNPROTECT, InputBuffer, sizeof(InputBuffer), OutputBuffer, sizeof(OutputBuffer), &dwRet, 0);
	_cwprintf(L"%ls", OutputBuffer);
}

char InitConsole()
{
	system("cls");
	printf("  输入选择：\n");
	printf("1.创建文件：\n");
	printf("2.写入文件：\n");
	printf("3.读取文件：\n");
	printf("4.删除文件1：\n");
	printf("5.复制文件：\n");
	printf("6.移动文件：\n");
	printf("7.获取属性：\n");
	printf("8.设置属性：\n");
	printf("9.删除文件2：\n");
	printf("a.重命名：\n");
	printf("b.伪保护文件：\n");
	printf("c.卸载伪保护：\n");
	printf("0.退出程序：\n");
	return getchar();
}

int main()
{
	HANDLE hRet = CreateFile(LINK_NAME, GENERIC_ALL, NULL, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hRet == INVALID_HANDLE_VALUE)
	{
		printf("CreateFile failed:%x\n", GetLastError());
		system("pause");
		return 0;
	}
	char Index;
	while (true)
	{
		Index = InitConsole();
		switch (Index)
		{
		case '0':
			return 0;
		case '1':
			CreateFileFunc(hRet);
			system("pause");
			break;
		case '2':
			WriteFileFunc(hRet); 
			system("pause");
			break;
		case '3':
			ReadFileFunc(hRet);
			system("pause");
			break;
		case '4':
			DeleteFileFunc(hRet);
			system("pause");
			break;
		case '5':
			CopyFileFunc(hRet);
			system("pause");
			break;
		case '6':
			MoveFileFunc(hRet);
			system("pause");
			break;
		case '7':
			GetFileFunc(hRet);
			system("pause");
			break;
		case '8':
			SetFileFunc(hRet);
			system("pause");
			break;
		case '9':
			SetDeleteFileFunc(hRet);
			system("pause");
			break;
		case 'a':
			SetFileNameFunc(hRet);
			system("pause");
			break;
		case 'b':
			ProtectFileFunc(hRet);
			system("pause");
			break;
		case 'c':
			UnProtectFileFunc(hRet);
			system("pause");
			break;
		default:
			break;
		}
	}
	return 0;
}

Windows驱动开发之文件操作
enjoy5512的博客
07-06 7142
内核态文件操作 内核态字符串操作 内核态动态内存申请/释放
操作系统——显示器的驱动
m0_56561130的博客
10-07 2489
一、前言 完成了CPU和内存这两个计算机核心部件的管理以后，最后一个问题就是完成对外设的管理。 外部设备通过总线和CPU、内存相连，每个外设都有自己的控制电路，当我们想要每个外设执行相应的动作时，CPU就会向某个地方写入命令，外设接收到后就会解释命令完成相应的动作。 整个过程可以用两步来总结： （1）CPU通过端口地址发送对外设的工作要求吗，一般是命令“out ax，端口号”，其中AX寄存器存放的就是外设的具体工作内容；（2）外设开始工作，在工作完成后...
linux驱动中读写文件操作
u011774634的博客
11-09 2188
linux内核中对文件进行读写操作
Linux驱动开发笔记（五）：驱动连接用户层与内核层的文件操作集原理和Demo
长沙红胖子Qt的技术博客
11-28 7986
驱动写好后，用户层使用系统函数调用操作相关驱动从而实现与系统内核的关联，本篇主要就是理解清楚驱动如何让用户编程来实现与内核的交互。
驱动开发：内核文件读写系列函数
热门推荐
CSDN
06-09 2万+
在应用层下的文件操作只需要调用微软应用层下的`API`函数及`C库`标准函数即可，而如果在内核中读写文件则应用层的API显然是无法被使用的，内核层需要使用内核专有API，某些应用层下的API只需要增加Zw开头即可在内核中使用，例如本章要讲解的文件与目录操作相关函数，多数ARK反内核工具都具有对文件的管理功能，实现对文件或目录的基本操作功能也是非常有必要的。 首先无论在内核态还是在用户态，我们调用的文件操作函数其最终都会转换为一个IRP请求，并发送到文件系统驱动上的`IRP_MJ_READ`派遣函数里面，这
打印机驱动提取ppd文件
RZer的博客
08-01 6019
PPD的全称为PostScript Printer Description，即PostScript打印机描述文件，只有PS-PostScript（语言格式）的驱动才会有PPD文件。
操作系统核心与驱动程序
aiyueyueaoe的博客
11-14 2895
一、操作系统与核心 操作系统(Operating System, OS)其实也是一组程序， 这组程序的重点在于管理计算机的所有活动以及驱动系统中的所有硬件。 核心主要在管控硬件与提供相关的能力(例如存取硬盘、网络功能、CPU 资源取得等)。 核心只会进行计算机系统的资源分配，所以在上头还需要有应用程序的提供，用户才能够操作系统。 操作系统其实就是核心与其提供的接口工具。 应用程序的开发都是参考操作系统提供的开发接口， 所以该应用程序只能在该操作系统上面运作而已，不可以在其他操作系统上面运作的。 核心至少有
文件过滤驱动
snowfoxmonitor的专栏
06-02 6732
文件过滤驱动一、文件透明加解密关键字：透明、文件过滤驱动、加密标识，缓存 文件过滤驱动最重要的两点是搞定加密标识和缓存管理1、透明概念：透明指的是用户在操作的时候，虽然后台在自动的进行加解密，但是用户根本就不知道加密的存在，就像中间隔了一层透明的玻璃一样。     透明的好处在于不改变用户的操作，一切都和加密之前一样，甚至在有些企业安装加密后都无需通知所有的员工，就像加密并不存在一样，只是加密文件...
linux驱动文件目录
duhui75的博客
03-13 6843
设备驱动模型通过sysfs文件系统向用户层提供设备驱动视图，如下。 1.设备是具体的一个个设备，在/sys/devices/是创建了实际的文件节点。而其他目录，如设备类和总线以下的子目录中出现的设备都是用符号链接指向/sys/devices/目录下的文件。 2.设备类是对/sys/devices/下的各种设备进行归类，以体现一类设备的公共属性，如鼠标和触摸屏都是属于input设备类。 3...
linux 内核驱动中对文件的读写
ozhengsfo的博客
08-20 6941
转载地址 http://www.360doc.com/content/12/1224/10/3478092_255969804.shtml 有时候需要在Linux kernel--大多是在需要调试的驱动程序--中读写文件数据。在kernel中操作文件没有标准库可用，需要利用kernel的一些函数，这些函数主 要有： filp_open() filp_close(), vfs_read() v
storahci.sys文件，标准SATA AHCI控制器驱动
08-11
没有标准SATA AHCI控制器驱动的朋友可以把这个文件拷贝到C:\Windows\System32\drivers目录，再查找试试。
驱动签名及创建cat文件
05-28
驱动签名涉及到对驱动文件（通常为`.sys`文件）以及相关的配置文件（`.inf`文件）进行验证，确保它们来自受信任的开发者并且未经篡改。在本话题中，我们将详细探讨如何创建和签署`.cat`（Catalog File）文件，这是...
linux下的文件过滤驱动
04-12
当用户空间应用程序尝试进行文件操作时，这些操作会被内核中的文件过滤驱动捕获，然后根据预定义的规则进行处理。这使得开发者能够实现诸如权限控制、数据加密、日志记录等高级功能。 实现文件过滤驱动，首先要了解...
Windows内核驱动文件操作实战：读写与复制
在Windows内核驱动开发中，文件操作是一个重要的部分，尤其是对于系统日志记录和调试信息的输出。以下将详细解释代码中的关键知识点： 1. **文件句柄**：在Windows内核驱动中，文件操作通常通过句柄进行。`HANDLE ...
Python-MCPInspector调试
最新发布
感谢所有乐于奉献的人，在此不一一具名
05-11 584
Python-MCPInspector调试
Java集合框架全面解析
doting__的博客
05-09 673
另外，由于LinkedList是链表结构，不支持随机访问元素，因此不能使用下标访问元素，需要使用迭代器或者poll（）方法依次遍历元素。从上面的例子可以看出，HashSet会自动去重，因为他是用HashMap实现的，HashMap的键是唯一的（哈希值），相同的键的值会覆盖掉原来的值，于是第二次时候，就会覆盖掉第一次。从名字可以看出，ArrayDeque是一个基于数组实现的双端队列，为了满足可以同时再数组两端插入或删除元素的需求，数组必须是循环的，也就是说，数组的任何一点都可以看作是起点（终点）。
Java泛型补充与理解
m0_73941339的博客
05-11 525
Java 的泛型在英文里表示为。
【链表扫盲】FROM GPT
m0_48165967的博客
05-08 804
通过指针将节点串联在一起。
GrassRoot备份项目
huxyc的博客
05-08 235
Windows服务项目。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值