驱动实验六(实现注册表的修改)

最新推荐文章于 2022-11-03 17:40:23 发布
最新推荐文章于 2022-11-03 17:40:23 发布
阅读量364 收藏 1
点赞数
分类专栏： Win驱动内核实验 文章标签： 驱动开发
cctrl
本文链接：https://blog.csdn.net/weixin_44309300/article/details/122149620
版权

驱动程序源代码：

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


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

#define IOCTL_MUL	CTL_CODE(FILE_DEVICE_UNKNOWN, 0x9888, METHOD_BUFFERED, FILE_ANY_ACCESS)

VOID nothing(HANDLE ppid, HANDLE mypid, BOOLEAN bcreate)
{
	DbgPrint("ProcessNotify\n");
}

VOID	DrvUnload(PDRIVER_OBJECT pdriver)
{
	DbgPrint("Unload\n");

	if (pdriver->DeviceObject)
	{
		IoDeleteDevice(pdriver->DeviceObject);

		UNICODE_STRING	symname = { 0 };

		RtlInitUnicodeString(&symname, SYM_NAME);
		
		IoDeleteSymbolicLink(&symname);
	}

	PsSetCreateProcessNotifyRoutine(nothing, TRUE);
}

NTSTATUS MyCreate(PDEVICE_OBJECT pdevice, PIRP pirp)	//PDEVICE_OBJECT 
{
	NTSTATUS status = STATUS_SUCCESS;

	DbgPrint("My Device has be opened\n");

	pirp->IoStatus.Status = status;

	pirp->IoStatus.Information = 0;

	IoCompleteRequest(pirp, IO_NO_INCREMENT);

	return 0;
}

NTSTATUS MyClose(PDEVICE_OBJECT pdevice, PIRP pirp)	//PDEVICE_OBJECT 
{
	NTSTATUS status = STATUS_SUCCESS;

	DbgPrint("My Device has be MyClose\n");

	pirp->IoStatus.Status = status;

	pirp->IoStatus.Information = 0;

	IoCompleteRequest(pirp, IO_NO_INCREMENT);

	return 0;
}


NTSTATUS MyCleanUp(PDEVICE_OBJECT pdevice, PIRP pirp)	//PDEVICE_OBJECT 
{
	NTSTATUS status = STATUS_SUCCESS;

	DbgPrint("My Device has be MyCleanUp\n");

	pirp->IoStatus.Status = status;

	pirp->IoStatus.Information = 0;

	IoCompleteRequest(pirp, IO_NO_INCREMENT);

	return 0;
}

NTSTATUS MyRead(PDEVICE_OBJECT pdevice, PIRP pirp)	 
{
	NTSTATUS status = STATUS_SUCCESS;

	DbgPrint("My Device has be MyRead\n");
	
	PIO_STACK_LOCATION pstack = IoGetCurrentIrpStackLocation(pirp);

	ULONG readsize = pstack->Parameters.Read.Length;

	PCHAR readbuffer = pirp->AssociatedIrp.SystemBuffer;

	RtlCopyMemory(readbuffer, "This Message Come From Kernel.", strlen("This Message Come From Kernel."));

	pirp->IoStatus.Status = status;

	pirp->IoStatus.Information = strlen("This Message Come From Kernel.");

	DbgPrint("Really Read Info Len is %d\n", strlen("This Message Come From Kernel."));

	IoCompleteRequest(pirp, IO_NO_INCREMENT);

	return STATUS_SUCCESS;
}

NTSTATUS MyWrite(PDEVICE_OBJECT pdevice, PIRP pirp)
{
	NTSTATUS status = STATUS_SUCCESS;

	DbgPrint("My Device has be MyWrite\n");

	PIO_STACK_LOCATION pstack = IoGetCurrentIrpStackLocation(pirp);

	ULONG writesize = pstack->Parameters.Write.Length;

	PCHAR writebuffer = pirp->AssociatedIrp.SystemBuffer;

	RtlZeroMemory(pdevice->DeviceExtension, 200);

	RtlCopyMemory(pdevice->DeviceExtension, writebuffer, writesize);

	DbgPrint("--%p--%s\n", writebuffer, (PCHAR)pdevice->DeviceExtension);

	pirp->IoStatus.Status = status;

	pirp->IoStatus.Information = 13;

	DbgPrint("Really Read Info Len is %d\n", strlen("This Message Come From Kernel."));

	IoCompleteRequest(pirp, IO_NO_INCREMENT);

	return STATUS_SUCCESS;
}

NTSTATUS MyControl(PDEVICE_OBJECT pdevice, PIRP pirp)	 
{
	NTSTATUS status = STATUS_SUCCESS;

	PIO_STACK_LOCATION pstack = IoGetCurrentIrpStackLocation(pirp);

	ULONG	iocode = pstack->Parameters.DeviceIoControl.IoControlCode;

	ULONG	inlen = pstack->Parameters.DeviceIoControl.InputBufferLength;

	ULONG	outlen = pstack->Parameters.DeviceIoControl.OutputBufferLength;
	
	ULONG	ioinfo = 0;

	DbgPrint("---------Device IO---------\n");

	switch (iocode)
	{
	case IOCTL_MUL:
	{
		DWORD indata = *(PDWORD)pirp->AssociatedIrp.SystemBuffer;

		DbgPrint("--Kernel Indata %d--\n", indata);

		indata = indata * 5;

		*(PDWORD)pirp->AssociatedIrp.SystemBuffer = indata;

		ioinfo = 888;

		break;
	}
	default:
		status = STATUS_UNSUCCESSFUL;
		
		ioinfo = 0;

		break;
	}

	DbgPrint("My Device has be MyCleanUp\n");

	pirp->IoStatus.Status = status;

	pirp->IoStatus.Information = 0;

	IoCompleteRequest(pirp, IO_NO_INCREMENT);

	return 0;
}

//5.1	KernelDeleteFile()	局限性：只可删除未被占用的程序
NTSTATUS	KernelDeleteFile(PWCHAR	file_path)
{
	UNICODE_STRING	filepath = { 0 };

	NTSTATUS	status = STATUS_SUCCESS;

	OBJECT_ATTRIBUTES	obja = { 0 };

	RtlInitUnicodeString(&filepath, file_path);

	InitializeObjectAttributes(&obja, &filepath, OBJ_CASE_INSENSITIVE, NULL, NULL);

	status = ZwDeleteFile(&obja);

	if (!NT_SUCCESS(status))
	{
		DbgPrint("Delete File Failed: %x\n", status);
	}

	return status;
}

//5.2	KernelCopyFile()
NTSTATUS	KernelCopyFile(PWCHAR defile_path, PWCHAR sourcefile_path)
{
	NTSTATUS	status = STATUS_SUCCESS;

	HANDLE	hfile1 = NULL;

	UNICODE_STRING	sourcefilepath = { 0 };

	IO_STATUS_BLOCK	iostack1 = { 0 };

	OBJECT_ATTRIBUTES	obja1 = { 0 };

	RtlInitUnicodeString(&sourcefilepath, sourcefile_path);

	InitializeObjectAttributes(&obja1, &sourcefilepath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	status = ZwOpenFile(&hfile1, GENERIC_ALL, &obja1, &iostack1, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_NONALERT);

	if (!NT_SUCCESS(status))
	{
		DbgPrint("Open SourceFile Failed: %x\n", status);
		
		return status;
	}

	FILE_STANDARD_INFORMATION	fbi = { 0 };

	status = ZwQueryInformationFile(hfile1, &iostack1, &fbi, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation);
	
	if (!NT_SUCCESS(status))
	{
		DbgPrint("QueryInformation SourceFile Failed: %x\n", status);

		ZwClose(hfile1);

		return status;
	}

	PVOID	filebuffer = NULL;

	filebuffer = ExAllocatePool(NonPagedPool, fbi.EndOfFile.QuadPart);
	
	if (!filebuffer)
	{
		DbgPrint("AllocateBuffer Failed\n");
		
		ZwClose(hfile1);

		return status;
	}

	RtlZeroMemory(filebuffer, fbi.EndOfFile.QuadPart);

	LARGE_INTEGER readoffset = { 0 };

	readoffset.QuadPart = 0;

	status = ZwReadFile(hfile1, NULL, NULL, NULL, &iostack1, filebuffer, fbi.EndOfFile.QuadPart, &readoffset, NULL);

	if (!filebuffer)
	{

		DbgPrint("ReadFile Failed :%x\n", status);

		ZwClose(hfile1);

		ExFreePool(filebuffer);
		
		return status;
	}

	DbgPrint("---IoInfo---%d\n", iostack1.Information);

	ZwClose(hfile1);

	//create new file

	HANDLE hfile2 = NULL;

	UNICODE_STRING defilepath = { 0 };

	OBJECT_ATTRIBUTES obja2 = { 0 };

	IO_STATUS_BLOCK	iostack2 = { 0 };

	RtlInitUnicodeString(&defilepath, defile_path);

	InitializeObjectAttributes(&obja2, &defilepath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);

	status = ZwCreateFile(&hfile2, GENERIC_ALL, &obja2, &iostack2, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_WRITE, FILE_SUPERSEDE, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);

	if (!NT_SUCCESS(status))
	{
		DbgPrint("Create File Failed : %x\n", status);

		ExFreePool(filebuffer);

		return status;
	}

	LARGE_INTEGER	writeoffset = { 0 };

	writeoffset.QuadPart = 0;

	status = ZwWriteFile(hfile2, NULL, NULL, NULL, &iostack2, filebuffer, fbi.EndOfFile.QuadPart, &writeoffset, NULL);

	if (!NT_SUCCESS(status))
	{
		DbgPrint("Write File Failed : %x\n", status);

		ExFreePool(filebuffer);

		ZwClose(hfile2);

		return status;
	}

	DbgPrint("---write---%d\n", iostack2.Information);

	ExFreePool(filebuffer);

	ZwClose(hfile2);

	return STATUS_SUCCESS;
}

NTSTATUS	DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING reg_path)	//PDRIVER_OBJECT
{
	NTSTATUS status = STATUS_SUCCESS;

	UNICODE_STRING devicename = { 0 };	//RTL_CONSTANT_STRING(DEVICE_NAME)

	UNICODE_STRING targeunicode = { 0 };

	PDEVICE_OBJECT pdevice = NULL;

	driver->DriverUnload = DrvUnload;

	RtlInitUnicodeString(&devicename, DEVICE_NAME);

	DbgPrint("---%wZ---\n", reg_path);
	
	//6-1 open regedit
	HANDLE keyhandle = NULL;

	OBJECT_ATTRIBUTES	obja = { 0 };

	ULONG keyop = 0;

	PVOID keyinfo = NULL;

	InitializeObjectAttributes(&obja, reg_path, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
	/*	
	//6-1.1方法一ZwCreateKey（）
	status = ZwCreateKey(&keyhandle, KEY_ALL_ACCESS, &obja, 0, NULL, REG_OPTION_NON_VOLATILE, &keyop);

	if (NT_SUCCESS(status))
	{
		if (keyop == REG_CREATED_NEW_KEY)
		{
			DbgPrint("Key has be Created\n");
		}
		else if (keyop = REG_OPENED_EXISTING_KEY)
		{
			DbgPrint("Key has be Opened\n");
		}
		else
		{
			DbgPrint("Error\n");
		}

		ZwClose(keyhandle);
	}
	*/

	//6-1.2方法二 ZwOpenkey（）方法
	status = ZwOpenKey(&keyhandle, KEY_ALL_ACCESS, &obja);

	if (NT_SUCCESS(status))
	{
	 
		keyinfo = ExAllocatePool(NonPagedPool, 0x1000);

		if (!keyinfo)
		{
			return 0;
		}

		RtlZeroMemory(keyinfo, 0x1000);

		UNICODE_STRING name = { 0 };

		RtlInitUnicodeString(&name, L"ImagePath");

		status = ZwQueryValueKey(keyhandle, &name, KeyValuePartialInformation, keyinfo, 0x1000, &keyop);

		if (!NT_SUCCESS(status))
		{
			ZwClose(keyhandle);

			ExFreePool(keyinfo);

			return 0;
		}

		PKEY_VALUE_PARTIAL_INFORMATION	tempinfo = (PKEY_VALUE_PARTIAL_INFORMATION)keyinfo;

		PWCHAR	imagepath = (PWCHAR)(tempinfo->Data);

		DbgPrint("--ImagePath--<%ws>--\n", imagepath);

		//6-1.3copy驱动位置到C:\Windows\System32\drivers 

		KernelCopyFile(L"\\??\\C:\\Windows\\System32\\drivers\\asdiopss.sys", imagepath);

		//6-1.4
		//fix path	
		//目的：提升启动权限
		// \SystemRoot\system32\drivers\afd.sys

		PWCHAR rootpath = L"\\SystemRoot\\system32\\drivers\\asdiopss.sys";

		status = ZwSetValueKey(keyhandle, &name, 0, REG_EXPAND_SZ, rootpath, wcslen(rootpath) * 2 + 2);		//+2是两个空字符00位

		if (!NT_SUCCESS(status))
		{
			DbgPrint("Error Code --<%x>--\n", status);
		}

		ExFreePool(keyinfo);

		ZwClose(keyhandle);

		//6-1.5
		//另外一种方式，写入注册表

		ULONG	tempstart = 1;

		RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE, reg_path->Buffer, L"Start", REG_DWORD, &tempstart, 4);

		//6-1.7
		status = RtlCheckRegistryKey(RTL_REGISTRY_SERVICES, L"123456");

		if (NT_SUCCESS(status))
		{
			DbgPrint("Be founded\n");
		}
		else
		{
			DbgPrint("Not founded");
			RtlCreateRegistryKey(RTL_REGISTRY_SERVICES, L"123456");
		}

	}


	//test1
	/*
	
	
	PWCHAR testbuffer = ExAllocatePool(NonPagedPool, 0x1000);

	RtlZeroMemory(testbuffer, 0x1000);

	RtlCopyMemory(testbuffer, L"FFFFFFF", sizeof(L"FFFFFFF"));

	RtlInitUnicodeString(&devicename, testbuffer);

	DbgPrint("--%wZ--\n", &devicename);
	*/

	//test2
	PCHAR tempbuffer = "C:\\ABc\\fff\\dEF\\123.txt";
	
	STRING	str = { 0 };

	RtlInitString(&str, tempbuffer);

	RtlAnsiStringToUnicodeString(&devicename, &str, TRUE);

	DbgPrint("--%wZ--\n", &devicename);

	targeunicode.Buffer = ExAllocatePool(NonPagedPool, 0x1000);

	targeunicode.MaximumLength = 0x1000;

	RtlCopyUnicodeString(&targeunicode, &devicename);

	DbgPrint("--%wZ--\n", &targeunicode);

	RtlUpcaseUnicodeString(&devicename, &devicename, FALSE);

	ExFreePool(targeunicode.Buffer);

	RtlFreeUnicodeString(&devicename);


	//test3
	PWCHAR tempbuffer2 = ExAllocatePool(NonPagedPool, 0x1000);

	RtlZeroMemory(tempbuffer2, 0x1000);

	RtlStringCbCopyW(tempbuffer2, 0x1000, L"\\??\\");

	RtlStringCbCatW(tempbuffer2, 0x1000, L"C:\\ABc\\fff\\dEF\\123.txt");

	UNICODE_STRING temp1 = { 0 }, temp2 = { 0 };

	RtlInitUnicodeString(&temp1, tempbuffer2);

	RtlInitUnicodeString(&temp2, L"\\??\\");

	if (RtlPrefixUnicodeString(&temp2, &temp1, FALSE))
	{
		DbgPrint("OK , FINE\n");
	}

	UNICODE_STRING temp3 = { 0 }, temp4 = { 0 };

	RtlInitUnicodeString(&temp3, L"D:\\ABc\\fcc\\ddd\\eee.txt");

	RtlInitUnicodeString(&temp4, L"D:\\ABc\\fcc\\DDD\\eee.txt");

	if (RtlEqualUnicodeString(&temp3, &temp4, TRUE))
	{
		DbgPrint("temp3 = temp4\n");
	}

	UNICODE_STRING temp5 = { 0 };

	RtlInitUnicodeString(&temp5, L"*EEE.TXT");	//EEE.TXT 一定要大写
	
	if (FsRtlIsNameInExpression(&temp5, &temp4, TRUE, NULL))
	{
		DbgPrint("Searched\n");
	}

	DbgPrint("--%ws--\n", &tempbuffer2);

	/*
	status = IoCreateDevice((PDRIVER_OBJECT)driver, 200, &devicename, FILE_DEVICE_UNKNOWN, 0, TRUE, &pdevice);

	if (!NT_SUCCESS(status)){
		DbgPrint("Create Device Failed : %x\n", status);

		return status;
	}
	
	pdevice->Flags |= DO_BUFFERED_IO;

	//创建符号链接
	UNICODE_STRING symname = { 0 };

	RtlInitUnicodeString(&symname, SYM_NAME);
	
	status = IoCreateSymbolicLink(&symname, &devicename);
	
	if (!NT_SUCCESS(status))
	{
		DbgPrint("Create SymbolicLink Failed : %x\n", status);

		IoDeleteDevice(pdevice);

		return status;
	}

	driver->MajorFunction[IRP_MJ_CREATE] = MyCreate;

	driver->MajorFunction[IRP_MJ_CLOSE] = MyClose;

	driver->MajorFunction[IRP_MJ_CLEANUP] = MyCleanUp;

	driver->MajorFunction[IRP_MJ_READ] = MyRead;

	driver->MajorFunction[IRP_MJ_WRITE] = MyWrite;

	driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = MyControl;
	*/

	//KernelDeleteFile(L"\\??\\C:\\123.exe");

	//KernelCopyFile(L"\\??\\C:\\888.exe", L"\\??\\C:\\567.exe");

	return 0;

}

成功效果：
在这里插入图片描述效果2
在这里插入图片描述copy驱动位置到C:\Windows\System32\drivers
在这里插入图片描述RtlCheckRegistryKey(RTL_REGISTRY_SERVICES, L"123456")和RtlCreateRegistryKey(RTL_REGISTRY_SERVICES, L"123456")效果：
在这里插入图片描述

hercu1iz
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows驱动开发-注册表操作
weixin_42071117的博客
04-06 718
#include <ntddk.h> #include <windef.h> VOID DriverUnload(IN PDRIVER_OBJECT DriverObject) { KdPrint(("驱动卸载\n")); UNREFERENCED_PARAMETER(DriverObject); } VOID RegCreateTest() { NTSTATUS status = STATUS_SUCCESS; HANDLE hKey = NULL; HANDLE h
安装驱动时对注册表的修改
05-27
驱动和关于驱动设备安装组件的存储信息在注册表中。一般来说，驱动和设备安装组件应该使用注册表来存储数据，就是那些通过重启系统后需要保存的信息。驱动可以访问注册表来获得这些信息
注册表修改实例
12-22
注册表修改实例
【Windows驱动开发】注册表的基本操作（创建、打开、修改、读取、枚举）（附源码）
皮皮不调皮的博客
12-29 1564
1、创建注册表项和子项 VOID RegCreateText() { HANDLE hKey; HANDLE hSubkey; NTSTATUS status; OBJECT_ATTRIBUTES oa; ULONG ulRet; UNICODE_STRING RegPath = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SOFTWARE\\MyKey"); UNICODE_STRING SubPath = RTL_CONSTANT_STRING(L
驱动安装过程中对注册表的改动
weixin_30335353的博客
10-24 155
假设硬件ID为 USB\VID_aaaa&PID_bbbb\PRODUCTNAME 系统会在注册表HKEY_LOCAL_MACHINE \ SYSTEM \ CurrentControlSet \ Enum 下为每个字段生成一个目录，比如ID中的第一个字段为USB，那么Enum下会生成USB子目录，第二个字段为VID_aaaa&PID_bbbb，则在USB目录下生成VID...
zhucebiao.rar_WinCE注册表
09-19
这个“zhucebiao.rar_WinCE注册表”压缩包包含了一个关于WinCE环境下注册表操作的实验源码，这对于理解和掌握WinCE嵌入式开发中的注册表操作至关重要。 WinCE注册表与桌面版Windows注册表的主要区别在于，WinCE的...
U盘只读过滤驱动程序
01-30
这通常涉及注册表的修改和驱动加载机制的理解。 2. I/O控制代码（IOCTL）：驱动通过定义特定的IOCTL码来识别和处理只读过滤请求。当应用程序尝试写入时，驱动通过匹配IOCTL码来决定是否允许。 3. 文件系统过滤：...
wifi注册表.zip
11-26
在Windows系统中，更改注册表可以对系统行为进行深度定制，但这也需要谨慎操作，因为错误的修改可能会导致系统不稳定或功能失效。 描述中的信息简洁，没有提供额外的技术细节，所以我们只能基于文件名来推测其内容...
wince驱动调试工具
11-28
下面将详细介绍如何通过操作WinCE注册表来实现驱动的加载、卸载以及查看。 1. **WinCE驱动加载**： - 驱动加载通常在WinCE启动时自动进行，或通过动态加载机制。注册表是控制这一过程的关键，因为它存储了驱动程序...
windows驱动开发技术详解-part2
07-06
力求让读者通过亲自动手实验，掌握各类Windows驱动 程序的开发技巧，学习尽可能多的Windows底层知识。 　本书适用于中、高级系统程序员，同时也可用做高校计算机专业操作系统实验课的补充教材。 原创经典，威盛...
WEB打印设置解决方案一（通过修改注册表改变IE打印设置）
JGLI8023
08-29 2843
 以下是IE打印设置脚本           Dim hkey_root,hkey_path,hkey_key          hkey_root  = "HKEY_CURRENT_USER"          hkey_path = "/Software/Microsoft/Internet Explorer/PageSetup"   //IE打印设置的注册表地址         //设置修改
更改注册表安装驱动程序
czcty的专栏
01-19 1835
Windows Registry Editor Version 5.00[HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Services/filter]"Type"=dword:00000001"Start"=dword:00000003"ErrorControl"=dword:00000001"ImagePath"=hex(2):73,00,79,0
扩展右键菜单
06-20 741
由于工作的需求要实现像winrara那样的shell扩展菜单，带图标的，针对某个类型的文件执行相应的操作， 查了不少资料，终于解决了，效果如下图中红色矩形部分。 最先想到的当然是最方便的，直接添加注册表，只需在HCLR中需要处理的类型（即右键选中的文件类型）的注册表项中的shell子键中加入新项， 修改默认值为显示名称，显示效果如上图的菜单项。（*）代表任意类型的文件。
病毒分析与防护实验1——注册表操作
郭同学如是说
03-05 4003
E01814234郭佳明——注册表操作 实验名称：病毒分析与防护——注册表操作 实验环境 VMware workstation pro Windows 10 虚拟机 实验目的 了解病毒传播的常见行为 了解注册表在病毒行为设置中的作用 实验原理 注册表是windows操作系统中使用的中央分层数据库，存储用户、应用程序和硬件设备配置系统所需要的信息。这些信息以树状结构存储在注册表（数据库）中。包括：用户的配置文件、安装的应用程序以及应用程序创建的文档类型、文件夹和应用程序图等、系统上存在哪些硬件
驱动开发中使用安全字符串函数
ALCAT的专栏
11-08 1435
一、前言        大量的系统安全问题是由于薄弱的缓冲处理以及由此产生的缓冲区溢出造成的，而薄弱的缓冲区处理常常与字符串操作相关。c/c++语言运行库提供的标准字符串操作函数（strcpy, strcat, sprintf等）不能阻止在超出字符串尾端的写入。        基于Windows XP SP1以及随后的操作系统的Windows DDK版本提供了安全字符串函数（safe stri
遇到“未定义的标识符”问题总结
Ideal_Thirsties的博客
11-03 5276
opencv中遇到“未定义的标识符”问题总结有三：
六、 在驱动中操作注册表
autumn20080101的专栏
12-05 1965
六、 在驱动中操作注册表 注册表是Windows的核心，日常的许多操作其实最终都是转化成了对注册表的操作，我们经常需要利用注册表达到一些特殊的效果，例如实现自启动等。 Windows 下设备驱动程序的开发方法 2120080411 计算机应用 赖锡盛 19 6.1 创建、打开注册表 和文件操作类似，在操作注册表之前需要首先打开注册表，获得一个句柄，这可以通过函数ZwCreateKey完
引入内核模式安全字符串函数
静故了群动
01-15 1080
原文地址 http://www.osronline.com/ddkx/kmarch/other_0vfr.htm 一、在内核驱动代码中引入安全字符串函数     有两种方式可以引入安全字符串函数:     如果代码需要在系统为Windows XP及以后版本运行时，可以使用内联的方式；     如果代码需要运行在早于Windows XP时，则必须使用链接库的方式。
qt实现修改win10系统注册表
最新发布
05-12
如果你想在 Qt 中修改 Windows 10 系统的注册表，可以使用 Windows API 函数来实现。 以下是一个简单的例子，展示了如何在 Qt 中使用 Windows API 函数来修改注册表中的键值： ```cpp #include #include void ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值