登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›驱动开发：内核注册表增删改查

驱动开发：内核注册表增删改查

路逸思 前天 20:00
注册表是Windows中的一个重要的数据库，用于存储系统和应用程序的设置信息，注册表是一个巨大的树形结构，无论在应用层还是内核层操作注册表都有独立的API函数可以使用，而在内核中读写注册表则需要使用内核装用API函数，如下将依次介绍并封装一些案例，实现对注册表的创建，删除，更新，查询等操作。
在Windows内核中，注册表是一种存储系统配置信息的机制，包括应用程序、硬件、驱动程序和操作系统的各种设置。内核提供了一些API函数，可以让驱动程序通过代码访问和修改注册表，以实现系统的配置和管理。下面简单介绍一下内核中的注册表增删改查操作：
注册表查询

  • 在内核中，可以使用ZwQueryValueKey或ZwEnumerateValueKey函数查询指定键的值。其中，ZwQueryValueKey函数可以查询指定键的值，而ZwEnumerateValueKey函数可以枚举指定键下的所有值。这两个函数都需要指定键的句柄和要查询的值的名称，查询结果将返回在指定的缓冲区中。
注册表修改

  • 在内核中，可以使用ZwSetValueKey函数修改指定键的值。该函数需要指定键的句柄、要修改的值的名称、值的类型和值的数据。在修改注册表时，需要注意权限和安全性问题，以避免潜在的安全问题。
注册表添加

  • 在内核中，可以使用ZwCreateKey函数创建一个新的键。该函数需要指定要创建键的父键的句柄、新键的名称、新键的属性等信息。如果成功创建了新键，则可以使用ZwSetValueKey函数向其添加值。
注册表删除

  • 在内核中，可以使用ZwDeleteValueKey函数删除指定键的值，或使用ZwDeleteKey函数删除指定键及其下面的所有子键和值。这两个函数都需要指定要删除的键的句柄或路径。在删除注册表时，同样需要注意权限和安全性问题，以避免潜在的安全问题。
需要注意的是，对注册表的操作可能会对系统的稳定性产生影响。因此，在实现这些技术时，需要遵循操作系统和安全软件的规定，以确保系统的安全和稳定。
ZwCreateKey: 创建注册表Key键，内核函数ZwCreateKey可用于创建新的注册表项或打开现有注册表项。
ZwCreateKey是Windows内核中的一个函数，用于创建一个新的注册表键（registry key）。它通常被驱动程序使用来添加新的配置信息或者修改已有的配置信息。
以下是ZwCreateKey函数的一般形式：
  1. NTSTATUS ZwCreateKey(
  2.   _Out_ PHANDLE            KeyHandle,
  3.   _In_  ACCESS_MASK        DesiredAccess,
  4.   _In_  POBJECT_ATTRIBUTES ObjectAttributes,
  5.   _Reserved_ ULONG         TitleIndex,
  6.   _In_  PUNICODE_STRING    Class,
  7.   _In_  ULONG              CreateOptions,
  8.   _Out_ PULONG             Disposition
  9. );
复制代码
参数说明：

  • KeyHandle： 输出参数，指向新创建的注册表键的句柄（handle）。
  • DesiredAccess： 指定新创建的键所需的访问权限，比如KEY_QUERY_VALUE等，具体请参考MSDN文档。
  • ObjectAttributes： 指向一个OBJECT_ATTRIBUTES结构体的指针，该结构体包含了注册表键的一些属性信息，比如名称、路径等。
  • TitleIndex： 指定键的标题索引。
  • Class： 指向一个UNICODE_STRING结构体的指针，它用于指定新创建的键的类名。
  • CreateOptions： 指定创建键的选项，比如REG_OPTION_NON_VOLATILE等。
  • Disposition： 输出参数，指向一个ULONG类型的指针，返回创建的键的状态信息，比如REG_CREATED_NEW_KEY等。
函数执行成功时，将返回STATUS_SUCCESS，否则返回相应的错误代码。需要注意的是，在使用ZwCreateKey函数之前，必须先初始化OBJECT_ATTRIBUTES结构体，以包含要创建的注册表键的完整路径。
在使用ZwCreateKey函数时，需要注意权限和安全性问题，以避免潜在的安全问题。同时，需要仔细考虑键的类名、访问权限和创建选项等参数的设置，以确保所创建的键能够正确地满足应用程序的需求。
  1. #include <ntifs.h>
  3. // 创建或者打开已存在注册表键
  4. BOOLEAN MyCreateRegistryKeyA(UNICODE_STRING ustrRegistry)
  5. {
  6.         HANDLE hRegister = NULL;
  7.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  8.         ULONG ulResult = 0;
  9.         NTSTATUS status = STATUS_SUCCESS;
  11.         // 创建或者打开已存在注册表键
  12.         InitializeObjectAttributes(&objectAttributes, &ustrRegistry, OBJ_CASE_INSENSITIVE, NULL, NULL);
  14.         // 创建Key
  15.         status = ZwCreateKey(&hRegister,
  16.                 KEY_ALL_ACCESS,
  17.                 &objectAttributes,
  18.                 0,
  19.                 NULL,
  20.                 REG_OPTION_NON_VOLATILE,
  21.                 &ulResult);
  22.         if (!NT_SUCCESS(status))
  23.         {
  24.                 return FALSE;
  25.         }
  26.         if (REG_CREATED_NEW_KEY == ulResult)
  27.         {
  28.                 DbgPrint("[*] 注册表已被创建 \n");
  29.         }
  30.         else if (REG_OPENED_EXISTING_KEY == ulResult)
  31.         {
  32.                 DbgPrint("[*] 注册表打开 \n");
  33.         }
  35.         // 关闭注册表键句柄
  36.         ZwClose(hRegister);
  37.         return TRUE;
  38. }
  40. // 创建键值对
  41. BOOLEAN MyCreateRegistryKeyB(LPWSTR KeyName)
  42. {
  43.         OBJECT_ATTRIBUTES objectAttributes;
  44.         UNICODE_STRING usKeyName;
  45.         NTSTATUS ntStatus;
  46.         HANDLE hRegister;
  48.         RtlInitUnicodeString(&usKeyName, KeyName);
  50.         // 初始化
  51.         InitializeObjectAttributes(&objectAttributes, &usKeyName, OBJ_CASE_INSENSITIVE, NULL, NULL);
  53.         // 创建Key
  54.         ntStatus = ZwCreateKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
  55.         if (NT_SUCCESS(ntStatus))
  56.         {
  57.                 DbgPrint("[*] 注册表已被创建 \n");
  58.                 ZwClose(hRegister);
  59.                 return TRUE;
  60.         }
  61.         else
  62.         {
  63.                 DbgPrint("[*] 注册表创建失败 \n");
  64.                 return FALSE;
  65.         }
  66.         return FALSE;
  67. }
  69. VOID UnDriver(PDRIVER_OBJECT driver)
  70. {
  71.         DbgPrint(("Uninstall Driver Is OK \n"));
  72. }
  74. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  75. {
  76.         DbgPrint("Hello LyShark.com \n");
  78.         BOOLEAN flag = FALSE;
  80.         // 创建注册表键
  81.         UNICODE_STRING ustrRegistry;
  82.         RtlInitUnicodeString(&ustrRegistry, L"\\Registry\\Machine\\Software\\LySharkKeysA");
  83.         flag = MyCreateRegistryKeyA(ustrRegistry);
  84.         if (flag == TRUE)
  85.         {
  86.                 DbgPrint("注册表键已创建 \n");
  87.         }
  89.         // 创建注册表键
  90.         flag = MyCreateRegistryKeyB(L"\\Registry\\Machine\\Software\\LySharkKeysB");
  91.         if (flag == TRUE)
  92.         {
  93.                 DbgPrint("注册表键已创建 \n");
  94.         }
  96.         Driver->DriverUnload = UnDriver;
  97.         return STATUS_SUCCESS;
  98. }
复制代码
运行如上代码即可在计算机\HKEY_LOCAL_MACHINE\SOFTWARE\目录下分别创建LySharkKeysA和LySharkKeysB两个空目录，输出效果如下图；
1.png

ZwDeleteKey: 删除注册表Key键，内核函数ZwDeleteKey可从注册表中删除打开的项。
ZwDeleteKey是Windows内核中的一个函数，用于删除指定的注册表键（registry key）。它通常被驱动程序使用来删除不再需要的配置信息或者清理无用的键。
以下是ZwDeleteKey函数的一般形式：
  1. NTSTATUS ZwDeleteKey(
  2.   _In_ HANDLE            KeyHandle
  3. );
复制代码
参数说明：

  • KeyHandle：要删除的键的句柄（handle）。
函数执行成功时，将返回STATUS_SUCCESS，否则返回相应的错误代码。需要注意的是，在使用ZwDeleteKey函数之前，需要先打开要删除的键，获取其句柄。
在使用ZwDeleteKey函数时，需要注意权限和安全性问题，以避免潜在的安全问题。同时，需要仔细考虑键的名称和路径等信息，确保要删除的键是正确的，并且不会对系统造成不良影响。
另外，需要注意的是，ZwDeleteKey函数只能用于删除空的注册表键。如果要删除非空的键，需要先递归地删除该键下的所有子键和值。
  1. #include <ntifs.h>
  3. // 删除注册表键
  4. BOOLEAN MyDeleteRegistryKeyA(UNICODE_STRING ustrRegistry)
  5. {
  6.         HANDLE hRegister = NULL;
  7.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  8.         NTSTATUS status = STATUS_SUCCESS;
  10.         // 打开注册表键
  11.         InitializeObjectAttributes(&objectAttributes, &ustrRegistry, OBJ_CASE_INSENSITIVE, NULL, NULL);
  12.         status = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  13.         if (!NT_SUCCESS(status))
  14.         {
  15.                 return FALSE;
  16.         }
  17.         // 删除注册表键
  18.         status = ZwDeleteKey(hRegister);
  19.         if (!NT_SUCCESS(status))
  20.         {
  21.                 ZwClose(hRegister);
  22.                 return FALSE;
  23.         }
  24.         // 关闭注册表键句柄
  25.         ZwClose(hRegister);
  26.         return TRUE;
  27. }
  29. // 删除注册表键
  30. BOOLEAN MyDeleteRegistryKeyB(LPWSTR KeyName)
  31. {
  32.         OBJECT_ATTRIBUTES objectAttributes;
  33.         UNICODE_STRING usKeyName;
  34.         NTSTATUS ntStatus;
  35.         HANDLE hRegister;
  37.         RtlInitUnicodeString(&usKeyName, KeyName);
  39.         // 初始化
  40.         InitializeObjectAttributes(&objectAttributes, &usKeyName, OBJ_CASE_INSENSITIVE, NULL, NULL);
  41.        
  42.         // 打开Key
  43.         ntStatus = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  44.         if (NT_SUCCESS(ntStatus))
  45.         {
  46.                 ntStatus = ZwDeleteKey(hRegister);
  47.                 ZwClose(hRegister);
  48.                 return TRUE;
  49.         }
  50.         else
  51.         {
  52.                 return FALSE;
  53.         }
  54.         return FALSE;
  55. }
  57. VOID UnDriver(PDRIVER_OBJECT driver)
  58. {
  59.         DbgPrint(("Uninstall Driver Is OK \n"));
  60. }
  62. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  63. {
  64.         DbgPrint("Hello LyShark.com \n");
  66.         BOOLEAN flag = FALSE;
  68.         // 删除注册表键
  69.         UNICODE_STRING ustrRegistry;
  70.         RtlInitUnicodeString(&ustrRegistry, L"\\Registry\\Machine\\Software\\LySharkKeysA");
  71.         flag = MyDeleteRegistryKeyA(ustrRegistry);
  72.         if (flag == TRUE)
  73.         {
  74.                 DbgPrint("[*] 已删除 \n");
  75.         }
  77.         // 删除注册表键
  78.         flag = MyDeleteRegistryKeyB(L"\\Registry\\Machine\\Software\\LySharkKeysB");
  79.         if (flag == TRUE)
  80.         {
  81.                 DbgPrint("[*] 已删除 \n");
  82.         }
  84.         Driver->DriverUnload = UnDriver;
  85.         return STATUS_SUCCESS;
  86. }
复制代码
编译并运行如上程序，则可将ZwCreateKey创建的Key键删除，当尝试再次打开LySharkKeysB则会提示打开失败，输出效果如下所示；
2.png

ZwRenameKey: 重命名注册表Key键，内核函数ZwRenameKey可修改特定注册表键名，此函数需要自行导出。
ZwRenameKey是Windows内核中的一个函数，用于重命名一个指定的注册表键。它通常被驱动程序使用来更改配置信息或者重命名键。
以下是ZwRenameKey函数的一般形式：
  1. NTSTATUS ZwRenameKey(
  2.   _In_ HANDLE            KeyHandle,
  3.   _In_ PUNICODE_STRING   NewName
  4. );
复制代码
参数说明：

  • KeyHandle： 要重命名的键的句柄（handle）。
  • NewName： 新键名称的Unicode字符串。
函数执行成功时，将返回STATUS_SUCCESS，否则返回相应的错误代码。需要注意的是，在使用ZwRenameKey函数之前，需要先打开要重命名的键，获取其句柄。
在使用ZwRenameKey函数时，需要注意权限和安全性问题，以避免潜在的安全问题。同时，需要仔细考虑键的名称和路径等信息，确保要重命名的键是正确的，并且不会对系统造成不良影响。另外，需要确保新键名称是唯一的，且符合注册表键名称的规范。
需要注意的是，ZwRenameKey函数只能用于重命名单个键，如果需要批量重命名键，则需要自行实现递归操作。
  1. #include <ntifs.h>
  3. // ZwRenameKey 需要自己导出
  4. typedef NTSTATUS(__fastcall *ZWRENAMEKEY)(HANDLE KeyHandle, PUNICODE_STRING NewName);
  6. ZWRENAMEKEY MyZwRenameKey = NULL;
  8. // 根据函数名得到函数内存地址
  9. PVOID GetFunctionAddr(PCWSTR FunctionName)
  10. {
  11.         UNICODE_STRING UniCodeFunctionName;
  12.         RtlInitUnicodeString(&UniCodeFunctionName, FunctionName);
  13.         return MmGetSystemRoutineAddress(&UniCodeFunctionName);
  14. }
  16. // 重命名注册表Key
  17. BOOLEAN RegRenameKey(LPWSTR OldKeyName, LPWSTR NewKeyName)
  18. {
  19.         OBJECT_ATTRIBUTES objectAttributes;
  20.         HANDLE hRegister;
  21.         NTSTATUS ntStatus;
  22.         UNICODE_STRING usOldKeyName, usNewKeyName;
  24.         RtlInitUnicodeString(&usOldKeyName, OldKeyName);
  25.         RtlInitUnicodeString(&usNewKeyName, NewKeyName);
  27.         InitializeObjectAttributes(&objectAttributes, &usOldKeyName, OBJ_CASE_INSENSITIVE, NULL, NULL);
  29.         // 得到函数内存地址
  30.         MyZwRenameKey = (ZWRENAMEKEY)GetFunctionAddr(L"ZwRenameKey");
  32.         ntStatus = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  33.         if (NT_SUCCESS(ntStatus))
  34.         {
  35.                 // 重命名Key键
  36.                 ntStatus = MyZwRenameKey(hRegister, &usNewKeyName);
  37.                 ZwFlushKey(hRegister);
  38.                 ZwClose(hRegister);
  39.                 return TRUE;
  40.         }
  41.         else
  42.         {
  43.                 return FALSE;
  44.         }
  45.         return FALSE;
  46. }
  48. VOID UnDriver(PDRIVER_OBJECT driver)
  49. {
  50.         DbgPrint(("Uninstall Driver Is OK \n"));
  51. }
  53. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  54. {
  55.         DbgPrint("Hello LyShark.com \n");
  57.         BOOLEAN flag = FALSE;
  59.         // 重命名键
  60.         flag = RegRenameKey(L"\\Registry\\Machine\\Software\\LySharkKeysA", L"SuperLyShark");
  61.         if (flag == TRUE)
  62.         {
  63.                 DbgPrint("[*] 已被重命名 \n");
  64.         }
  66.         Driver->DriverUnload = UnDriver;
  67.         return STATUS_SUCCESS;
  68. }
复制代码
编译并运行这段驱动程序，自动将LySharkKeysA改名为SuperLyShark，输出效果如下所示；
3.png

ZwSetValueKey: 在键中创建Value值，在一个Key中增加一个新的值。
ZwSetValueKey是Windows内核中的一个函数，用于向指定的注册表键中写入值。它通常被驱动程序使用来修改或添加配置信息或者键值。
以下是ZwSetValueKey函数的一般形式：
  1. NTSTATUS ZwSetValueKey(
  2.   _In_ HANDLE            KeyHandle,
  3.   _In_ PUNICODE_STRING   ValueName,
  4.   _In_opt_ ULONG         TitleIndex,
  5.   _In_ ULONG             Type,
  6.   _In_opt_ PVOID         Data,
  7.   _In_ ULONG             DataSize
  8. );
复制代码
参数说明：

  • KeyHandle： 要写入值的键的句柄（handle）。
  • ValueName： 要写入值的名称的Unicode字符串。
  • TitleIndex： 零基索引，用于在键的名称列表中查找与ValueName相对应的索引值。
  • Type： 要写入的值的类型。
  • Data： 要写入的数据的指针。
  • DataSize： 要写入的数据的长度。
函数执行成功时，将返回STATUS_SUCCESS，否则返回相应的错误代码。需要注意的是，在使用ZwSetValueKey函数之前，需要先打开要写入值的键，获取其句柄。
在使用ZwSetValueKey函数时，需要注意权限和安全性问题，以避免潜在的安全问题。同时，需要仔细考虑键的名称和路径等信息，确保要写入值的键是正确的，并且不会对系统造成不良影响。另外，需要确保写入的数据类型和长度正确，以避免造成不必要的问题。
需要注意的是，ZwSetValueKey函数只能用于向单个键写入单个值，如果需要批量写入值，则需要自行实现循环操作。
  1. #include <ntifs.h>
  2. #include <windef.h>
  4. // 在键中增加值
  5. BOOLEAN RegSetValueKey(LPWSTR KeyName, LPWSTR ValueName, DWORD DataType, PVOID DataBuffer, DWORD DataLength)
  6. {
  7.         OBJECT_ATTRIBUTES objectAttributes;
  8.         UNICODE_STRING usKeyName, usValueName;
  9.         NTSTATUS ntStatus;
  10.         HANDLE hRegister;
  11.         RtlInitUnicodeString(&usKeyName, KeyName);
  12.         RtlInitUnicodeString(&usValueName, ValueName);
  14.         InitializeObjectAttributes(&objectAttributes, &usKeyName, OBJ_CASE_INSENSITIVE, NULL, NULL);
  16.         // 打开
  17.         ntStatus = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  18.         if (NT_SUCCESS(ntStatus))
  19.         {
  20.                 // 设置注册表
  21.                 ntStatus = ZwSetValueKey(hRegister, &usValueName, 0, DataType, DataBuffer, DataLength);
  23.                 // 将请求刷新到磁盘
  24.                 ZwFlushKey(hRegister);
  25.                 ZwClose(hRegister);
  26.                 return TRUE;
  27.         }
  28.         else
  29.         {
  30.                 return FALSE;
  31.         }
  32.         return FALSE;
  33. }
  35. // 添加或者修改注册表键值
  36. BOOLEAN MySetRegistryKeyValue(UNICODE_STRING ustrRegistry, UNICODE_STRING ustrKeyValueName, ULONG ulKeyValueType, PVOID pKeyValueData, ULONG ulKeyValueDataSize)
  37. {
  38.         HANDLE hRegister = NULL;
  39.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  40.         NTSTATUS status = STATUS_SUCCESS;
  42.         InitializeObjectAttributes(&objectAttributes, &ustrRegistry, OBJ_CASE_INSENSITIVE, NULL, NULL);
  44.         // 打开注册表键
  45.         status = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  46.         if (!NT_SUCCESS(status))
  47.         {
  48.                 return FALSE;
  49.         }
  51.         // 添加或者修改键值
  52.         status = ZwSetValueKey(hRegister, &ustrKeyValueName, 0, ulKeyValueType, pKeyValueData, ulKeyValueDataSize);
  53.         if (!NT_SUCCESS(status))
  54.         {
  55.                 ZwClose(hRegister);
  56.                 return FALSE;
  57.         }
  59.         // 关闭注册表键句柄
  60.         ZwClose(hRegister);
  61.         return TRUE;
  62. }
  64. VOID UnDriver(PDRIVER_OBJECT driver)
  65. {
  66.         DbgPrint(("Uninstall Driver Is OK \n"));
  67. }
  69. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  70. {
  71.         DbgPrint("Hello LyShark.com \n");
  73.         BOOLEAN flag = FALSE;
  75.         DWORD set_dw = 1024;
  76.         BOOLEAN is_true = TRUE;
  77.         WCHAR sz_char[256] = L"hello lyshark";
  79.         // 新建设置value
  80.         flag = RegSetValueKey(L"\\Registry\\Machine\\Software\\LySharkKeysA", L"is_auth", REG_DWORD, &set_dw, sizeof(set_dw));
  81.         if (flag == TRUE)
  82.         {
  83.                 DbgPrint("[*] 创建is_auth值成功 \n");
  84.         }
  86.         // 新建设置bool
  87.         flag = RegSetValueKey(L"\\Registry\\Machine\\Software\\LySharkKeysA", L"is_trhe", REG_BINARY, &is_true, sizeof(is_true));
  88.         if (flag == TRUE)
  89.         {
  90.                 DbgPrint("[*] 创建is_true值成功 \n");
  91.         }
  93.         // 新建设置char
  94.         flag = RegSetValueKey(L"\\Registry\\Machine\\Software\\LySharkKeysA", L"1001", REG_SZ, &sz_char, sizeof(sz_char));
  95.         if (flag == TRUE)
  96.         {
  97.                 DbgPrint("[*] 创建char值成功 \n");
  98.         }
  100.         // 添加注册表键值
  101.         UNICODE_STRING ustrRegistry;
  102.         UNICODE_STRING ustrKeyValueName;
  104.         WCHAR wstrKeyValueData[] = L"I am LyShark";
  105.         RtlInitUnicodeString(&ustrKeyValueName, L"1002");
  106.         RtlInitUnicodeString(&ustrRegistry, L"\\Registry\\Machine\\Software\\LySharkKeysA");
  108.         flag = MySetRegistryKeyValue(ustrRegistry, ustrKeyValueName, REG_SZ, wstrKeyValueData, sizeof(wstrKeyValueData));
  109.         if (flag == TRUE)
  110.         {
  111.                 DbgPrint("[*] 创建char值成功 \n");
  112.         }
  114.         Driver->DriverUnload = UnDriver;
  115.         return STATUS_SUCCESS;
  116. }
复制代码
编译并运行如上代码，即可在\\Registry\\Machine\\Software\\LySharkKeysA分别创建一个整数，布尔值，字符串类型，效果图如下；
4.png

ZwQueryValueKey: 查询某个Key键中的值，调用后可输出特定键中的值。
ZwQueryValueKey是Windows内核中的一个函数，用于从指定的注册表键中读取指定值的数据。它通常被驱动程序使用来获取配置信息或者键值。
以下是ZwQueryValueKey函数的一般形式：
  1. NTSTATUS ZwQueryValueKey(
  2.   _In_ HANDLE            KeyHandle,
  3.   _In_ PUNICODE_STRING   ValueName,
  4.   _In_ KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
  5.   _Out_opt_ PVOID        KeyValueInformation,
  6.   _In_ ULONG             Length,
  7.   _Out_ PULONG           ResultLength
  8. );
复制代码
参数说明：

  • KeyHandle： 要读取值的键的句柄（handle）。
  • ValueName： 要读取值的名称的Unicode字符串。
  • KeyValueInformationClass： 指定要获取的键值的信息类型。
  • KeyValueInformation： 存储读取的键值信息的缓冲区。
  • Length： KeyValueInformation缓冲区的大小。
  • ResultLength： 实际读取的键值信息的大小。
函数执行成功时，将返回STATUS_SUCCESS，否则返回相应的错误代码。需要注意的是，在使用ZwQueryValueKey函数之前，需要先打开要读取值的键，获取其句柄。
在使用ZwQueryValueKey函数时，需要注意权限和安全性问题，以避免潜在的安全问题。同时，需要仔细考虑键的名称和路径等信息，确保要读取值的键是正确的，并且不会对系统造成不良影响。另外，需要确保KeyValueInformation缓冲区的大小足够，以存储读取的键值信息。
需要注意的是，ZwQueryValueKey函数只能用于读取单个键的单个值，如果需要读取多个键的值，则需要自行实现循环操作。
  1. #include <ntifs.h>
  2. #include <windef.h>
  4. // 查询Key键中的Value值
  5. BOOLEAN RegQueryValueKey(LPWSTR KeyName, LPWSTR ValueName, PKEY_VALUE_PARTIAL_INFORMATION *pkvpi)
  6. {
  7.         ULONG ulSize;
  8.         NTSTATUS ntStatus;
  9.         PKEY_VALUE_PARTIAL_INFORMATION pvpi;
  10.         OBJECT_ATTRIBUTES objectAttributes;
  11.         HANDLE hRegister;
  12.         UNICODE_STRING usKeyName;
  13.         UNICODE_STRING usValueName;
  15.         RtlInitUnicodeString(&usKeyName, KeyName);
  16.         RtlInitUnicodeString(&usValueName, ValueName);
  18.         // 初始化
  19.         InitializeObjectAttributes(&objectAttributes, &usKeyName, OBJ_CASE_INSENSITIVE, NULL, NULL);
  21.         // 打开注册表Key
  22.         ntStatus = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  23.         if (!NT_SUCCESS(ntStatus))
  24.         {
  25.                 return FALSE;
  26.         }
  28.         // 查询长度
  29.         ntStatus = ZwQueryValueKey(hRegister, &usValueName, KeyValuePartialInformation, NULL, 0, &ulSize);
  30.         if (ntStatus == STATUS_OBJECT_NAME_NOT_FOUND || ulSize == 0)
  31.         {
  32.                 return FALSE;
  33.         }
  35.         // 分配空间保存查询结果
  36.         pvpi = (PKEY_VALUE_PARTIAL_INFORMATION)ExAllocatePool(PagedPool, ulSize);
  37.         ntStatus = ZwQueryValueKey(hRegister, &usValueName, KeyValuePartialInformation, pvpi, ulSize, &ulSize);
  38.         if (!NT_SUCCESS(ntStatus))
  39.         {
  40.                 return FALSE;
  41.         }
  43.         // 这里的pvpi未被释放，可在外部释放
  44.         // 执行 ExFreePool(pvpi); 释放
  45.         *pkvpi = pvpi;
  46.         return TRUE;
  47. }
  49. // 查询注册表键值
  50. BOOLEAN MyQueryRegistryKeyValue(UNICODE_STRING ustrRegistry, UNICODE_STRING ustrKeyValueName)
  51. {
  52.         HANDLE hRegister = NULL;
  53.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  54.         NTSTATUS status = STATUS_SUCCESS;
  55.         ULONG ulBufferSize = 0;
  56.         PKEY_VALUE_PARTIAL_INFORMATION pKeyValuePartialInfo = NULL;
  58.         // 初始化
  59.         InitializeObjectAttributes(&objectAttributes, &ustrRegistry, OBJ_CASE_INSENSITIVE, NULL, NULL);
  61.         // 打开注册表Key
  62.         status = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  63.         if (!NT_SUCCESS(status))
  64.         {
  65.                 return FALSE;
  66.         }
  67.         // 先获取查询注册表键值所需缓冲区的大小
  68.         status = ZwQueryValueKey(hRegister, &ustrKeyValueName, KeyValuePartialInformation, NULL, 0, &ulBufferSize);
  69.         if (0 == ulBufferSize)
  70.         {
  71.                 ZwClose(hRegister);
  72.                 return FALSE;
  73.         }
  75.         // 申请缓冲区
  76.         pKeyValuePartialInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ExAllocatePool(NonPagedPool, ulBufferSize);
  78.         // 查询注册表键值并获取查询结果
  79.         status = ZwQueryValueKey(hRegister, &ustrKeyValueName, KeyValuePartialInformation, pKeyValuePartialInfo, ulBufferSize, &ulBufferSize);
  80.         if (!NT_SUCCESS(status))
  81.         {
  82.                 ExFreePool(pKeyValuePartialInfo);
  83.                 ZwClose(hRegister);
  84.                 return FALSE;
  85.         }
  86.         // 显示查询结果
  87.         DbgPrint("KeyValueName=%wZ, KeyValueType=%d, KeyValueData=%S\n", &ustrKeyValueName, pKeyValuePartialInfo->Type, pKeyValuePartialInfo->Data);
  89.         // 释放内存, 关闭句柄
  90.         ExFreePool(pKeyValuePartialInfo);
  91.         ZwClose(hRegister);
  92.         return TRUE;
  93. }
  95. VOID UnDriver(PDRIVER_OBJECT driver)
  96. {
  97.         DbgPrint(("Uninstall Driver Is OK \n"));
  98. }
  100. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  101. {
  102.         DbgPrint("Hello LyShark.com \n");
  104.         BOOLEAN flag = FALSE;
  105.         DWORD get_dw = 0;
  107.         PKEY_VALUE_PARTIAL_INFORMATION pkvi;
  109.         // 查询设置
  110.         flag = RegQueryValueKey(L"\\Registry\\Machine\\Software\\LySharkKeysA", L"is_auth", &pkvi);
  111.         if (flag == TRUE)
  112.         {
  113.                 // 拷贝查询结果
  114.                 RtlCopyMemory(&get_dw, pkvi->Data, pkvi->DataLength);
  116.                 // 输出结果
  117.                 DbgPrint("[*] 查询结果: %d \n", get_dw);
  118.                 ExFreePool(pkvi);
  119.         }
  121.         // 第二种查询方式
  122.         UNICODE_STRING ustrRegistry;
  123.         UNICODE_STRING ustrKeyValueName;
  125.         RtlInitUnicodeString(&ustrRegistry, L"\\Registry\\Machine\\Software\\LySharkKeysA");
  126.         RtlInitUnicodeString(&ustrKeyValueName, L"is_auth");
  128.         MyQueryRegistryKeyValue(ustrRegistry, ustrKeyValueName);
  130.         Driver->DriverUnload = UnDriver;
  131.         return STATUS_SUCCESS;
  132. }
复制代码
编译并运行这段程序，将会查询\\Registry\\Machine\\Software\\LySharkKeysA下面的is_auth字段中的值，输出效果如下图所示；
5.png

ZwEnumerateKey: 枚举某个主键底部的子键值，实现对指定主键中所有的子键的枚举。
ZwEnumerateKey是Windows内核中的一个函数，用于列举指定注册表键下的子键。它通常被驱动程序使用来获取键列表，以及子键的数量和名称等信息。
以下是ZwEnumerateKey函数的一般形式：
  1. NTSTATUS ZwEnumerateKey(
  2.   _In_ HANDLE                KeyHandle,
  3.   _In_ ULONG                 Index,
  4.   _In_ KEY_INFORMATION_CLASS KeyInformationClass,
  5.   _Out_ PVOID                KeyInformation,
  6.   _In_ ULONG                 Length,
  7.   _Out_ PULONG               ResultLength
  8. );
复制代码
参数说明：

  • KeyHandle： 要列举子键的键的句柄（handle）。
  • Index： 指定要列举的子键的索引。
  • KeyInformationClass： 指定要获取的子键信息类型。
  • KeyInformation： 存储读取的子键信息的缓冲区。
  • Length： KeyInformation缓冲区的大小。
  • ResultLength： 实际读取的子键信息的大小。
函数执行成功时，将返回STATUS_SUCCESS，否则返回相应的错误代码。需要注意的是，在使用ZwEnumerateKey函数之前，需要先打开要列举子键的键，获取其句柄。
在使用ZwEnumerateKey函数时，需要注意权限和安全性问题，以避免潜在的安全问题。同时，需要仔细考虑键的名称和路径等信息，确保要列举子键的键是正确的，并且不会对系统造成不良影响。另外，需要确保KeyInformation缓冲区的大小足够，以存储读取的子键信息。
需要注意的是，ZwEnumerateKey函数只能用于列举单个键下的子键，如果需要列举多个键的子键，则需要自行实现循环操作。
  1. #include <ntifs.h>
  2. #include <windef.h>
  4. // 枚举子键
  5. BOOLEAN EnumRegistrySubKey(WCHAR *MY_KEY_NAME)
  6. {
  7.         UNICODE_STRING RegUnicodeString;
  8.         HANDLE hRegister;
  9.         OBJECT_ATTRIBUTES objectAttributes;
  10.         NTSTATUS ntStatus;
  11.         ULONG ulSize, i;
  12.         UNICODE_STRING uniKeyName;
  13.         PKEY_FULL_INFORMATION pfi;
  15.         // 初始化UNICODE_STRING字符串
  16.         RtlInitUnicodeString(&RegUnicodeString, MY_KEY_NAME);
  18.         // 初始化objectAttributes OBJ_CASE_INSENSITIVE(大小写敏感)
  19.         InitializeObjectAttributes(&objectAttributes, &RegUnicodeString, OBJ_CASE_INSENSITIVE, NULL, NULL);
  21.         // 打开注册表
  22.         ntStatus = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  23.         if (!NT_SUCCESS(ntStatus))
  24.         {
  25.                 return FALSE;
  26.         }
  28.         // 第一次调用获取KEY_FULL_INFORMATION数据的长度
  29.         ZwQueryKey(hRegister, KeyFullInformation, NULL, 0, &ulSize);
  30.         pfi = (PKEY_FULL_INFORMATION)ExAllocatePool(PagedPool, ulSize);
  32.         // 第二次调用获取KEY_FULL_INFORMATION数据的数据
  33.         ZwQueryKey(hRegister, KeyFullInformation, pfi, ulSize, &ulSize);
  35.         // 循环输出子键
  36.         for (i = 0; i<pfi->SubKeys; i++)
  37.         {
  38.                 PKEY_BASIC_INFORMATION pbi;
  40.                 // 第一次调用获取KEY_BASIC_INFORMATION数据的长度
  41.                 ZwEnumerateKey(hRegister, i, KeyBasicInformation, NULL, 0, &ulSize);
  42.                 pbi = (PKEY_BASIC_INFORMATION)ExAllocatePool(PagedPool, ulSize);
  44.                 // 第二次调用获取KEY_BASIC_INFORMATION数据的数据
  45.                 ZwEnumerateKey(hRegister, i, KeyBasicInformation, pbi, ulSize, &ulSize);
  47.                 uniKeyName.Length = (USHORT)pbi->NameLength;
  48.                 uniKeyName.MaximumLength = (USHORT)pbi->NameLength;
  49.                 uniKeyName.Buffer = pbi->Name;
  51.                 DbgPrint("[LyShark] 序号: %d | 子Key名: %wZ \n", i, &uniKeyName);
  52.                 ExFreePool(pbi);
  53.         }
  54.         ExFreePool(pfi);
  55.         ZwClose(hRegister);
  56.         return TRUE;
  57. }
  59. VOID UnDriver(PDRIVER_OBJECT driver)
  60. {
  61.         DbgPrint(("Uninstall Driver Is OK \n"));
  62. }
  64. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  65. {
  66.         DbgPrint("Hello LyShark.com \n");
  68.         WCHAR MY_KEY_NAME[] = L"\\Registry\\Machine\\Software";
  69.         BOOLEAN flag = EnumRegistrySubKey(MY_KEY_NAME);
  71.         if (flag == TRUE)
  72.         {
  73.                 DbgPrint("[*] 枚举结束 \n");
  74.         }
  76.         Driver->DriverUnload = UnDriver;
  77.         return STATUS_SUCCESS;
  78. }
复制代码
编译并运行如上代码片段，则会枚举\\Registry\\Machine\\Software底部的所有子键值，输出效果图如下所示；
6.png

ZwEnumerateValueKey: 用于枚举子键下所有键值对的值，原理与上方枚举子键类似。
ZwEnumerateValueKey是Windows内核中的一个函数，用于列举指定注册表键下的所有值。它通常被驱动程序使用来获取键值列表，以及每个键值的名称、类型和数据等信息。
以下是ZwEnumerateValueKey函数的一般形式：
  1. NTSTATUS ZwEnumerateValueKey(
  2.   _In_ HANDLE                KeyHandle,
  3.   _In_ ULONG                 Index,
  4.   _In_ KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
  5.   _Out_ PVOID                KeyValueInformation,
  6.   _In_ ULONG                 Length,
  7.   _Out_ PULONG               ResultLength
  8. );
复制代码
参数说明：

  • KeyHandle： 要列举值的键的句柄（handle）。
  • Index： 指定要列举的值的索引。
  • KeyValueInformationClass： 指定要获取的值信息类型。
  • KeyValueInformation： 存储读取的值信息的缓冲区。
  • Length： KeyValueInformation缓冲区的大小。
  • ResultLength： 实际读取的值信息的大小。
函数执行成功时，将返回STATUS_SUCCESS，否则返回相应的错误代码。需要注意的是，在使用ZwEnumerateValueKey函数之前，需要先打开要列举值的键，获取其句柄。
在使用ZwEnumerateValueKey函数时，需要注意权限和安全性问题，以避免潜在的安全问题。同时，需要仔细考虑键的名称和路径等信息，确保要列举值的键是正确的，并且不会对系统造成不良影响。另外，需要确保KeyValueInformation缓冲区的大小足够，以存储读取的值信息。
需要注意的是，ZwEnumerateValueKey函数只能用于列举单个键下的所有值，如果需要列举多个键的所有值，则需要自行实现循环操作。
  1. #include <ntifs.h>
  2. #include <windef.h>
  4. // 枚举子键
  5. BOOLEAN EnumegistrySubValue(WCHAR *MY_KEY_NAME)
  6. {
  7.         UNICODE_STRING RegUnicodeString;
  8.         HANDLE hRegister;
  9.         OBJECT_ATTRIBUTES objectAttributes;
  10.         ULONG ulSize, i;
  11.         UNICODE_STRING uniKeyName;
  12.         PKEY_FULL_INFORMATION pfi;
  13.         NTSTATUS ntStatus;
  15.         // 初始化UNICODE_STRING字符串
  16.         RtlInitUnicodeString(&RegUnicodeString, MY_KEY_NAME);
  18.         // 初始化objectAttributes
  19.         InitializeObjectAttributes(&objectAttributes, &RegUnicodeString, OBJ_CASE_INSENSITIVE, NULL, NULL);
  21.         // 打开注册表
  22.         ntStatus = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  23.         if (!NT_SUCCESS(ntStatus))
  24.         {
  25.                 return FALSE;
  26.         }
  28.         // 查询VALUE的大小
  29.         ZwQueryKey(hRegister, KeyFullInformation, NULL, 0, &ulSize);
  30.         pfi = (PKEY_FULL_INFORMATION)ExAllocatePool(PagedPool, ulSize);
  31.         ZwQueryKey(hRegister, KeyFullInformation, pfi, ulSize, &ulSize);
  32.         for (i = 0; i<pfi->Values; i++)
  33.         {
  34.                 PKEY_VALUE_BASIC_INFORMATION pvbi;
  36.                 // 查询单个VALUE的大小
  37.                 ZwEnumerateValueKey(hRegister, i, KeyValueBasicInformation, NULL, 0, &ulSize);
  38.                 pvbi = (PKEY_VALUE_BASIC_INFORMATION)ExAllocatePool(PagedPool, ulSize);
  40.                 // 查询单个VALUE的详情
  41.                 ZwEnumerateValueKey(hRegister, i, KeyValueBasicInformation, pvbi, ulSize, &ulSize);
  42.                 uniKeyName.Length = (USHORT)pvbi->NameLength;
  43.                 uniKeyName.MaximumLength = (USHORT)pvbi->NameLength;
  44.                 uniKeyName.Buffer = pvbi->Name;
  46.                 DbgPrint("[*] 子键: %d | 名称: %wZ | ", i, &uniKeyName);
  47.                 if (pvbi->Type == REG_SZ)
  48.                 {
  49.                         DbgPrint("类型: REG_SZ \n");
  50.                 }
  51.                 else if (pvbi->Type == REG_MULTI_SZ)
  52.                 {
  53.                         DbgPrint("类型: REG_MULTI_SZ \n");
  54.                 }
  55.                 else if (pvbi->Type == REG_DWORD)
  56.                 {
  57.                         DbgPrint("类型: REG_DWORD \n");
  58.                 }
  59.                 else if (pvbi->Type == REG_BINARY)
  60.                 {
  61.                         DbgPrint("类型: REG_BINARY \n");
  62.                 }
  63.                 ExFreePool(pvbi);
  64.         }
  66.         ExFreePool(pfi);
  67.         ZwClose(hRegister);
  68.         return TRUE;
  69. }
  71. VOID UnDriver(PDRIVER_OBJECT driver)
  72. {
  73.         DbgPrint(("Uninstall Driver Is OK \n"));
  74. }
  76. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  77. {
  78.         DbgPrint("Hello LyShark.com \n");
  80.         WCHAR MY_KEY_NAME[] = L"\\Registry\\Machine\\Software\\LySharkKeysA";
  81.         BOOLEAN flag = EnumegistrySubValue(MY_KEY_NAME);
  83.         if (flag == TRUE)
  84.         {
  85.                 DbgPrint("[*] 枚举结束 \n");
  86.         }
  88.         Driver->DriverUnload = UnDriver;
  89.         return STATUS_SUCCESS;
  90. }
复制代码
编译并运行如上这段代码，则可枚举出\\Registry\\Machine\\Software\\LySharkKeysA底部的所有子键以及该子键的键值，输出效果如下图所示；
7.png

ZwDeleteValueKey: 用于删除指定键里面键值对的某个值。如果使用函数RegDeleteKey则删除键包括里面的所有值。
ZwDeleteValueKey是Windows内核中的一个函数，用于删除指定注册表键下的一个值。它通常被驱动程序使用来删除指定键下的一个值，以及释放该值占用的空间。
以下是ZwDeleteValueKey函数的一般形式：
  1. NTSTATUS ZwDeleteValueKey(
  2.   _In_ HANDLE           KeyHandle,
  3.   _In_ PUNICODE_STRING ValueName
  4. );
复制代码
参数说明：

  • KeyHandle： 要删除值的键的句柄（handle）。
  • ValueName： 要删除的值的名称，为Unicode字符串指针。
函数执行成功时，将返回STATUS_SUCCESS，否则返回相应的错误代码。需要注意的是，在使用ZwDeleteValueKey函数之前，需要先打开要删除值的键，获取其句柄。
在使用ZwDeleteValueKey函数时，需要注意权限和安全性问题，以避免潜在的安全问题。同时，需要仔细考虑键的名称和路径等信息，确保要删除的值是正确的，并且不会对系统造成不良影响。
需要注意的是，ZwDeleteValueKey函数只能用于删除单个键下的一个值，如果需要删除多个键的多个值，则需要自行实现循环操作。
  1. #include <ntifs.h>
  2. #include <windef.h>
  4. // 删除键中的值
  5. BOOLEAN RegDeleteValueKey(LPWSTR KeyName, LPWSTR ValueName)
  6. {
  7.         OBJECT_ATTRIBUTES objectAttributes;
  8.         UNICODE_STRING usKeyName, usValueName;
  9.         NTSTATUS ntStatus;
  10.         HANDLE hRegister;
  11.         RtlInitUnicodeString(&usKeyName, KeyName);
  12.         RtlInitUnicodeString(&usValueName, ValueName);
  14.         InitializeObjectAttributes(&objectAttributes, &usKeyName, OBJ_CASE_INSENSITIVE, NULL, NULL);
  16.         // 打开注册表
  17.         ntStatus = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  18.         if (NT_SUCCESS(ntStatus))
  19.         {
  20.                 ntStatus = ZwDeleteValueKey(hRegister, &usValueName);
  21.                 ZwFlushKey(hRegister);
  22.                 ZwClose(hRegister);
  23.                 return TRUE;
  24.         }
  25.         else
  26.         {
  27.                 return FALSE;
  28.         }
  29.         return FALSE;
  30. }
  32. // 删除注册表键值
  33. BOOLEAN MyDeleteRegistryKeyValue(UNICODE_STRING ustrRegistry, UNICODE_STRING ustrKeyValueName)
  34. {
  35.         HANDLE hRegister = NULL;
  36.         OBJECT_ATTRIBUTES objectAttributes = { 0 };
  37.         NTSTATUS status = STATUS_SUCCESS;
  38.         // 打开注册表键
  39.         InitializeObjectAttributes(&objectAttributes, &ustrRegistry, OBJ_CASE_INSENSITIVE, NULL, NULL);
  40.         status = ZwOpenKey(&hRegister, KEY_ALL_ACCESS, &objectAttributes);
  41.         if (!NT_SUCCESS(status))
  42.         {
  43.                 return FALSE;
  44.         }
  46.         // 删除注册表键
  47.         status = ZwDeleteValueKey(hRegister, &ustrKeyValueName);
  48.         if (!NT_SUCCESS(status))
  49.         {
  50.                 ZwClose(hRegister);
  51.                 return FALSE;
  52.         }
  54.         // 关闭注册表键句柄
  55.         ZwClose(hRegister);
  56.         return TRUE;
  57. }
  59. VOID UnDriver(PDRIVER_OBJECT driver)
  60. {
  61.         DbgPrint(("Uninstall Driver Is OK \n"));
  62. }
  64. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  65. {
  66.         DbgPrint("Hello LyShark.com \n");
  68.         // 删除值
  69.         BOOLEAN flag = RegDeleteValueKey(L"\\Registry\\Machine\\Software\\LySharkKeysA", L"is_auth");
  71.         if (flag == TRUE)
  72.         {
  73.                 DbgPrint("[*] 删除子键 \n");
  74.         }
  76.         UNICODE_STRING ustrRegistry;
  77.         UNICODE_STRING ustrKeyValueName;
  79.         RtlInitUnicodeString(&ustrRegistry, L"\\Registry\\Machine\\Software\\LySharkKeysA");
  80.         RtlInitUnicodeString(&ustrKeyValueName, L"is_trhe");
  81.         flag = MyDeleteRegistryKeyValue(ustrRegistry, ustrKeyValueName);
  82.         if (flag == TRUE)
  83.         {
  84.                 DbgPrint("[*] 删除子键 \n");
  85.         }
  87.         Driver->DriverUnload = UnDriver;
  88.         return STATUS_SUCCESS;
  89. }
复制代码
编译并运行如上驱动程序，则会将\\Registry\\Machine\\Software\\LySharkKeysA里面的is_trhe以及is_auth删除，效果图如下所示；
8.png


来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
路逸思
前天 20:00

0

粉丝关注

11

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫