• 深入注册表监控

    前言

    注册表是windows的重要数据库，存放了很多重要的信息以及一些应用的设置，对注册表进行监控并防止篡改是十分有必要的。在64位系统下微软提供了CmRegisterCallback这个回调函数来实时监控注册表的操作，那么既然这里微软提供了这么一个方便的接口，病毒木马自然也会利用，这里我们就来探究其实现的原理和如何利用这个回调函数进行对抗

    CmRegisterCallback

    要想更好的进行对抗，就是深入底层去看这个函数到底做了什么事情，无论是监控还是反监控，这样我们才能够更好的进行利用

    首先我们去msdn里面看一下它的结构

    1. NTSTATUS CmRegisterCallback(
    2.   [in]           PEX_CALLBACK_FUNCTION Function,
    3.   [in, optional] PVOID                 Context,
    4.   [out]          PLARGE_INTEGER        Cookie
    5. );

    image-20220501100957527.png

    第一个参数指向RegistryCallback，它这里其实是通过EX_CALLBACK_FUNCTION这个回调函数实现，结构如下

    1. EX_CALLBACK_FUNCTION ExCallbackFunction;
    2.  
    3. NTSTATUS ExCallbackFunction(
    4.   [in]           PVOID CallbackContext,
    5.   [in, optional] PVOID Argument1,
    6.   [in, optional] PVOID Argument2
    7. )
    8. {...}

    image-20220501101203532.png

    主要是看第三个参数，REG_NOTIFY_CLASS结构如下

    1. typedef enum _REG_NOTIFY_CLASS {
    2.     RegNtDeleteKey,
    3.     RegNtPreDeleteKey = RegNtDeleteKey,
    4.     RegNtSetValueKey,
    5.     RegNtPreSetValueKey = RegNtSetValueKey,
    6.     RegNtDeleteValueKey,
    7.     RegNtPreDeleteValueKey = RegNtDeleteValueKey,
    8.     RegNtSetInformationKey,
    9.     RegNtPreSetInformationKey = RegNtSetInformationKey,
    10.     RegNtRenameKey,
    11.     RegNtPreRenameKey = RegNtRenameKey,
    12.     RegNtEnumerateKey,
    13.     RegNtPreEnumerateKey = RegNtEnumerateKey,
    14.     RegNtEnumerateValueKey,
    15.     RegNtPreEnumerateValueKey = RegNtEnumerateValueKey,
    16.     RegNtQueryKey,
    17.     RegNtPreQueryKey = RegNtQueryKey,
    18.     RegNtQueryValueKey,
    19.     RegNtPreQueryValueKey = RegNtQueryValueKey,
    20.     RegNtQueryMultipleValueKey,
    21.     RegNtPreQueryMultipleValueKey = RegNtQueryMultipleValueKey,
    22.     RegNtPreCreateKey,
    23.     RegNtPostCreateKey,
    24.     RegNtPreOpenKey,
    25.     RegNtPostOpenKey,
    26.     RegNtKeyHandleClose,
    27.     RegNtPreKeyHandleClose = RegNtKeyHandleClose,
    28.     //
    29.     // .Net only
    30.     //    
    31.     RegNtPostDeleteKey,
    32.     RegNtPostSetValueKey,
    33.     RegNtPostDeleteValueKey,
    34.     RegNtPostSetInformationKey,
    35.     RegNtPostRenameKey,
    36.     RegNtPostEnumerateKey,
    37.     RegNtPostEnumerateValueKey,
    38.     RegNtPostQueryKey,
    39.     RegNtPostQueryValueKey,
    40.     RegNtPostQueryMultipleValueKey,
    41.     RegNtPostKeyHandleClose,
    42.     RegNtPreCreateKeyEx,
    43.     RegNtPostCreateKeyEx,
    44.     RegNtPreOpenKeyEx,
    45.     RegNtPostOpenKeyEx,
    46.     //
    47.  
    48.     //
    49.     RegNtPreFlushKey,
    50.     RegNtPostFlushKey,
    51.     RegNtPreLoadKey,
    52.     RegNtPostLoadKey,
    53.     RegNtPreUnLoadKey,
    54.     RegNtPostUnLoadKey,
    55.     RegNtPreQueryKeySecurity,
    56.     RegNtPostQueryKeySecurity,
    57.     RegNtPreSetKeySecurity,
    58.     RegNtPostSetKeySecurity,
    59.     //
    60.     // per-object context cleanup
    61.     //
    62.     RegNtCallbackObjectContextCleanup,
    63.     //
    64.     // new in Vista SP2 
    65.     //
    66.     RegNtPreRestoreKey,
    67.     RegNtPostRestoreKey,
    68.     RegNtPreSaveKey,
    69.     RegNtPostSaveKey,
    70.     RegNtPreReplaceKey,
    71.     RegNtPostReplaceKey,
    72.  
    73.     MaxRegNtNotifyClass //should always be the last enum
    74. } REG_NOTIFY_CLASS;

    这里有几个比较常见的类型

    • • RegNtPreCreateKey 创建注册表 对应的Argument2为PREG_CREATE_KEY_INFORMATION

    • • RegNtPreOpenKey 打开注册表 对应的Argument2为PREG_CREATE_KEY_INFORMATION

    • • RegNtPreDeleteKey 删除键 对应的Argument2为PREG_DELETE_KEY_INFORMATION

    • • RegNtPreDeleteValueKey 删除键值 对应的Argument2为PREG_DELETE_VALUE_KEY_INFORMATION

    • • RegNtPreSetValueKey 修改键值 对应的Argument2为PREG_SET_VALUE_KEY_INFORMATION

    这里RegNtPreCreateKey和RegNtPreOpenKey的Argument2都是使用到PREG_CREATE_KEY_INFORMATION这个结构体，我们看下结构

    其中两个关键的参数就是CompleteName表示指向路径的指针，以及RootObject表示指向注册表项的指针

    1. typedef struct _REG_CREATE_KEY_INFORMATION {
    2.     PUNICODE_STRING     CompleteName; // IN
    3.     PVOID               RootObject;   // IN
    4.     PVOID               ObjectType;   
    5.     ULONG               CreateOptions;
    6.     PUNICODE_STRING     Class;        
    7.     PVOID               SecurityDescriptor;
    8.     PVOID               SecurityQualityOfService;
    9.     ACCESS_MASK         DesiredAccess;
    10.     ACCESS_MASK         GrantedAccess;
    11.                                         // to be filled in by callbacks 
    12.                                       // when bypassing native code
    13.     PULONG              Disposition;  
    14.                                       // on pass through, callback should fill 
    15.                                       // in disposition
    16.     PVOID               *ResultObject;
    17.                                       // on pass through, callback should return 
    18.                                       // object to be used for the return handle
    19.     PVOID               CallContext;  
    20.     PVOID               RootObjectContext;  
    21.     PVOID               Transaction;  
    22.     PVOID               Reserved;     
    23. } REG_CREATE_KEY_INFORMATION, REG_OPEN_KEY_INFORMATION,*PREG_CREATE_KEY_INFORMATION, *PREG_OPEN_KEY_INFORMATION;

    然后就是RegNtPreDeleteKey对应PREG_DELETE_KEY_INFORMATION结构体，这里的话因为只需要删除注册表，使用到Object参数指向要删除注册表的指针

    1. typedef struct _REG_DELETE_KEY_INFORMATION {
    2.     PVOID    Object;                      // IN
    3.     PVOID    CallContext;  
    4.     PVOID    ObjectContext;
    5.     PVOID    Reserved;     
    6. } REG_DELETE_KEY_INFORMATION, *PREG_DELETE_KEY_INFORMATION

    image-20220501102243154.png

    再就是RegNtPreDeleteValueKey对应PREG_DELETE_VALUE_KEY_INFORMATION结构体，我们通过名字可以判断这里我们要删除表项里面的值，所以这里Object还是指向要删除的注册表的指针，而ValueName就是指向具体需要删除的值

    1. typedef struct _REG_DELETE_VALUE_KEY_INFORMATION {
    2.   PVOID           Object;
    3.   PUNICODE_STRING ValueName;
    4.   PVOID           CallContext;
    5.   PVOID           ObjectContext;
    6.   PVOID           Reserved;
    7. } REG_DELETE_VALUE_KEY_INFORMATION, *PREG_DELETE_VALUE_KEY_INFORMATION;

    image-20220501102233472.png

    RegNtPreSetValueKey对应的是PREG_SET_VALUE_KEY_INFORMATION结构，同样是Object指向要修改的注册表的指针，而ValueName就是指向具体需要修改的值

    1. typedef struct _REG_CREATE_KEY_INFORMATION {
    2.     PUNICODE_STRING     CompleteName; // IN
    3.     PVOID               RootObject;   // IN
    4.     PVOID               ObjectType;   
    5.     ULONG               CreateOptions;
    6.     PUNICODE_STRING     Class;        
    7.     PVOID               SecurityDescriptor;
    8.     PVOID               SecurityQualityOfService;
    9.     ACCESS_MASK         DesiredAccess;
    10.     ACCESS_MASK         GrantedAccess;
    11.                                         // to be filled in by callbacks 
    12.                                       // when bypassing native code
    13.     PULONG              Disposition;  
    14.                                       // on pass through, callback should fill 
    15.                                       // in disposition
    16.     PVOID               *ResultObject;
    17.                                       // on pass through, callback should return 
    18.                                       // object to be used for the return handle
    19.     PVOID               CallContext;  
    20.     PVOID               RootObjectContext;  
    21.     PVOID               Transaction;  
    22.     PVOID               Reserved;     
    23. } REG_CREATE_KEY_INFORMATION, REG_OPEN_KEY_INFORMATION,*PREG_CREATE_KEY_INFORMATION, *PREG_OPEN_KEY_INFORMATION;

    我们这里了解了CmRegisterCallback的一些常用结构，这里我们去IDA里面看一下其底层实现

    这个函数首先调用了CmpRegisterCallbackInternal

    image-20220501103504282.png

    我们跟进去看看，首先是通过ExAllocatePoolWithTag来申请0x30大小的空间，然后通过test esi,esi将Blink和Flink都指向自己，然后进行判断后跳转到69436B这个地址

    image-20220501103825124.png

    这段函数主要是将双向链表存入申请空间的前8字节，然后将Context结构保存到0x18的位置，将回调函数保存到0x1C的位置，然后进行判断后跳转到6943B1这个地址

    image-20220501104354270.png

    这段函数的主要作用就是将Cookie的值存入0x10偏移处，这里的设计很巧妙，因为一个cookie是占8字节的，这里首先将[esi + 0x10]的值存入eax，然后将ebx地址存入eax，相当于赋值前4位，然后再进行同样的操作，这里取的是[esi + 0x14]，也就是赋值后四位

    image-20220501104945941.png

    然后再就是后面的代码，这里就是一些释放内存的操作

    image-20220501105207771.png

    我们从上面的分析可以得出CmRegisterCallback其实就是申请了一块空间，保存了一个双向链表、Cookie、Context、回调函数的地址，那么如果要存放注册表，只可能是放在了双向链表里面，这里我们就有理由猜测注册表监控的回调函数就是通过一个双向链表连接起来的

    监控

    我们在上面已经分析了CmRegisterCallback函数的原理，那么我们首先注册一个回调函数

    1. NTSTATUS status = CmRegisterCallback(RegisterCallback, NULL, &RegCookie);
    2. if (!NT_SUCCESS(status))
    3. {
    4.     ShowError("CmRegisterCallback", status);
    5.     RegCookie.QuadPart = 0;
    6.     return status;
    7. }

    然后我们编写RegisterCallback这个回调函数，首先传入3个参数

    NTSTATUS RegisterMonCallback(_In_ PVOID CallbackContext,_In_opt_ PVOID Argument1,_In_opt_ PVOID Argument2)

    我们在前面已经说过CmRegisterCallback的第一个参数是操作类型，我们首先获取一下

    LONG lOperateType = (REG_NOTIFY_CLASS)Argument1;

    通过ExAllocatePool申请一块内存，使用ustrRegPath定义注册表的路径，这里设置非分页内存即可

    ustrRegPath.Buffer = ExAllocatePool(NonPagedPool, ustrRegPath.MaxLength);

    然后我们通过switch...case循环来判断lOperateType来进行具体的操作，比如这里是RegNtPreCreateKey

    首先需要获取注册表的路径，这里就需要用到ObQueryNameString这个API

    1. NTSTATUS
    2.   ObQueryNameString(
    3.     IN PVOID  Object,
    4.     OUT POBJECT_NAME_INFORMATION  ObjectNameInfo,
    5.     IN ULONG  Length,
    6.     OUT PULONG  ReturnLength
    7.     );

    第二个参数指向OBJECT_NAME_INFORMATION结构，保存的是返回的名称

    1. typedef struct _OBJECT_NAME_INFORMATION {
    2.     UNICODE_STRING Name;
    3. } OBJECT_NAME_INFORMATION, *POBJECT_NAME_INFORMATION;

    那么这里我们调用ObQueryNameString获取函数地址，写成一个函数方便调用

    1. PVOID lpObjectNameInfo = ExAllocatePool(NonPagedPool, ulSize);
    2. NTSTATUS status = ObQueryNameString(pRegistryObject, (POBJECT_NAME_INFORMATION)lpObjectNameInfo, ulSize, &ulRetLen);
    3. RtlCopyUnicodeString(pRegistryPath, (PUNICODE_STRING)lpObjectNameInfo);

    获取一下注册表的路径

    GetRegisterPath(&ustrRegPath, ((PREG_CREATE_KEY_INFORMATION)Argument2)->RootObject);

    这里我们定位到注册表之后，就需要进行判断是否是我们想要保护的注册表，如果是的话就将status改成STATUS_ACCESS_DENIED即可达到保护注册表的效果

    通过wcsstr()函数判断路径是否为我们想要保护的注册表名称，编写为Compare函数

    1. BOOLEAN Compare(UNICODE_STRING ustrRegPath)
    2. {
    3.     if (NULL != wcsstr(ustrRegPath.Buffer, L"RegTest"))
    4.     {
    5.         return TRUE;
    6.     }
    7.  
    8.     return FALSE;
    9. }

    如果名称相同则设置为STATUS_ACCESS_DENIED

    1. if (Compare(ustrRegPath))
    2. {
    3.     status = STATUS_ACCESS_DENIED;
    4. }

    完整代码如下，这里因为是RegNtPreOpenKey所以Argument2对应的类型就是PREG_CREATE_KEY_INFORMATION，这里只需要修改Argunment2的类型即可，剩下的几个判断再这里就不赘述了

    1.     case RegNtPreOpenKey:
    2.     {
    3.         GetRegisterPath(&ustrRegPath, ((PREG_CREATE_KEY_INFORMATION)Argument2)->RootObject);
    4.         // 判断是否是被保护的注册表
    5.         if (Compare(ustrRegPath))
    6.         {
    7.             status = STATUS_ACCESS_DENIED;
    8.         }
    9.         // 显示
    10.         DbgPrint("[RegNtPreOpenKey][%wZ][%wZ]\n", &ustrRegPath, ((PREG_CREATE_KEY_INFORMATION)Argument2)->CompleteName);
    11.         break;
    12.     }

    image-20220501142500180.png

    回调函数的完整代码如下

    1. NTSTATUS RegisterCallback(_In_ PVOID CallbackContext,_In_opt_ PVOID Argument1,_In_opt_ PVOID Argument2)
    2. {
    3.  
    4.     NTSTATUS status = STATUS_SUCCESS;
    5.     UNICODE_STRING ustrRegPath;
    6.  
    7.     LONG lOperateType = (REG_NOTIFY_CLASS)Argument1;
    8.  
    9.     ustrRegPath.Length = 0;
    10.     ustrRegPath.MaximumLength = 1024 * sizeof(WCHAR);
    11.     ustrRegPath.Buffer = ExAllocatePool(NonPagedPool, ustrRegPath.MaximumLength);
    12.     if (NULL == ustrRegPath.Buffer)
    13.     {
    14.         printf("ExAllocatePool error : %d\n", GetLastError());
    15.         return status;
    16.     }
    17.     switch (lOperateType)
    18.     {
    19.         // 创建注册表之前
    20.     case RegNtPreCreateKey:
    21.     {
    22.         GetRegisterPath(&ustrRegPath, ((PREG_CREATE_KEY_INFORMATION)Argument2)->RootObject);
    23.  
    24.         if (Compare(ustrRegPath))
    25.         {
    26.             status = STATUS_ACCESS_DENIED;
    27.         }
    28.         DbgPrint("[RegNtPreCreateKey][%wZ][%wZ]\n", &ustrRegPath, ((PREG_CREATE_KEY_INFORMATION)Argument2)->CompleteName);
    29.         break;
    30.     }
    31.  
    32.     // 打开注册表之前
    33.     case RegNtPreOpenKey:
    34.     {
    35.         GetRegisterPath(&ustrRegPath, ((PREG_CREATE_KEY_INFORMATION)Argument2)->RootObject);
    36.  
    37.         if (Compare(ustrRegPath))
    38.         {
    39.             status = STATUS_ACCESS_DENIED;
    40.         }
    41.         DbgPrint("[RegNtPreOpenKey][%wZ][%wZ]\n", &ustrRegPath, ((PREG_CREATE_KEY_INFORMATION)Argument2)->CompleteName);
    42.         break;
    43.     }
    44.     // 删除键之前
    45.     case RegNtPreDeleteKey:
    46.     {
    47.         GetRegisterPath(&ustrRegPath, ((PREG_DELETE_KEY_INFORMATION)Argument2)->Object);
    48.  
    49.         if (Compare(ustrRegPath))
    50.         {
    51.             status = STATUS_ACCESS_DENIED;
    52.         }
    53.  
    54.         DbgPrint("[RegNtPreDeleteKey][%wZ]\n", &ustrRegPath);
    55.         break;
    56.     }
    57.     // 删除键值之前
    58.     case RegNtPreDeleteValueKey:
    59.     {
    60.         GetRegisterPath(&ustrRegPath, ((PREG_DELETE_VALUE_KEY_INFORMATION)Argument2)->Object);
    61.  
    62.         if (Compare(ustrRegPath))
    63.         {
    64.             status = STATUS_ACCESS_DENIED;
    65.         }
    66.         DbgPrint("[RegNtPreDeleteValueKey][%wZ][%wZ]\n", &ustrRegPath, ((PREG_DELETE_VALUE_KEY_INFORMATION)Argument2)->ValueName);
    67.         break;
    68.     }
    69.     // 修改键值之前
    70.     case RegNtPreSetValueKey:
    71.     {
    72.         GetRegisterPath(&ustrRegPath, ((PREG_SET_VALUE_KEY_INFORMATION)Argument2)->Object);
    73.  
    74.         if (Compare(ustrRegPath))
    75.         {
    76.             status = STATUS_ACCESS_DENIED;
    77.         }
    78.         // 显示
    79.         DbgPrint("[RegNtPreSetValueKey][%wZ][%wZ]\n", &ustrRegPath, ((PREG_SET_VALUE_KEY_INFORMATION)Argument2)->ValueName);
    80.         break;
    81.     }
    82.     default:
    83.         break;
    84.     }
    85.  
    86.     if (NULL != ustrRegPath.Buffer)
    87.     {
    88.         ExFreePool(ustrRegPath.Buffer);
    89.         ustrRegPath.Buffer = NULL;
    90.     }
    91.  
    92.     PEPROCESS pEProcess = PsGetCurrentProcess();
    93.     if (NULL != pEProcess)
    94.     {
    95.         UCHAR* lpszProcessName = PsGetProcessImageFileName(pEProcess);
    96.         if (NULL != lpszProcessName)
    97.         {
    98.             DbgPrint("Current Process[%s]\n", lpszProcessName);
    99.         }
    100.     }
    101.  
    102.     return status;
    103. }

    实现效果

    我们加载驱动可以看到我们想要修改RegTest的二进制的值被拒绝

    image-20220501142641363.png

    删除也会被拦截

    image-20220501142654260.png

    重命名也同样被拦截

    image-20220501142706899.png

    卸载驱动之后能够成功重命名

    image-20220501142719387.png

    也能够修改二进制的内容

    image-20220501142758141.png

    也可以删除字符串

    image-20220501142809044.png

    反监控

    我们在前面已经逆向分析了CmRegisterCallback的底层实现，就是通过申请一块内存空间存放双向链表，那么我们只要定位到这个双向链表删除回调函数即可得到反监控的效果

    将链表加入我们内存的函数是SetRegisterCallback，这里我因为pdb文件的问题显示得有点问题，我们跟进去看看

    image-20220501144151656.png

    这里往下走可以看到offset CallbackListHead的操作，这里就是将链表头赋值给ebx

    image-20220501144321163.png

    然后将eax的值赋给[esi + 10]，这里就是在进行初始化Cookie的操作

    image-20220501144430141.png

    然后最后再比较edi的值是否为ListBegin的地址，跳转到增加链表的代码

    image-20220501144540775.png

    那么这里我们明确下思路，我们想要定位到链表头，就首先需要通过在CmRegisterCallback里面定位SetRegisterCallback

    image-20220501144914828.png

    然后定位到链表头即可

    image-20220501145028344.png

    那么这里我们进行代码编写，首先定位到CmRegisterCallback函数

    1.     UNICODE_STRING uStrFuncName = RTL_CONSTANT_STRING(L"CmRegisterCallback");
    2.  
    3.     pCmRegFunc = (PUCHAR)MmGetSystemRoutineAddress(&uStrFuncName);

    然后通过硬编码定位到链表头

    1.     pCmRegFunc = (PUCHAR)MmGetSystemRoutineAddress(&uStrFuncName);
    2.  
    3.     if (pCmRegFunc == NULL)
    4.     {
    5.         DbgPrint("MmGetSystemRoutineAddress error : %d\r\n",GetLastError());
    6.         return pListEntry;
    7.     }
    8.  
    9.     while (*pCmRegFunc != 0xC2)
    10.     {
    11.         if (*pCmRegFunc == 0xE8)
    12.         {
    13.             pCmcRegFunc = (PUCHAR)((ULONG)pCmRegFunc + 5 + *(PULONG)(pCmRegFunc + 1));
    14.             break;
    15.         }
    16.         pCmRegFunc++;
    17.     }
    18.  
    19.     if (pCmcRegFunc == NULL)
    20.     {
    21.         DbgPrint("GetCmcRegFunc error : %d\r\n",GetLastError());
    22.         return pListEntry;
    23.     }
    24.  
    25.     while (*pCmcRegFunc != 0xC2)
    26.     {
    27.         if (*pCmcRegFunc == 0x8B && *(pCmcRegFunc + 1) == 0xC6 && *(pCmcRegFunc + 2) == 0xE8)
    28.         {
    29.             pSetRegFunc = (PUCHAR)((ULONG)pCmcRegFunc + 2 + 5 + *(PULONG)(pCmcRegFunc + 3));
    30.             break;
    31.         }
    32.         pCmcRegFunc++;
    33.     }
    34.  
    35.     if (pSetRegFunc == NULL)
    36.     {
    37.         DbgPrint("GetSetRegFunc error : %d\r\n", GetLastError());
    38.         return pListEntry;
    39.     }
    40.  
    41.     while (*pSetRegFunc != 0xC2)
    42.     {
    43.         if (*pSetRegFunc == 0xBB)
    44.         {
    45.             pListEntry = (PULONG) * (PULONG)(pSetRegFunc + 1);
    46.             break;
    47.         }
    48.         pSetRegFunc++;
    49.     }

    定位到链表头之后，我们通过MmIsAddressValid对地址进行判断是否可用，通过0x10偏移定位到Cookie

    1. pHead = GetRegisterList();
    2. pListEntry = (PLIST_ENTRY)*pHead;
    3.  
    4. pLiRegCookie = (PLARGE_INTEGER)((ULONG)pListEntry + 0x10);
    5. pFuncAddr = (PULONG)((ULONG)pListEntry + 0x1C);

    然后调用CmUnRegisterCallback删除回调

    status = CmUnRegisterCallback(*pLiRegCookie);

    实现效果

    这里如果连windbg有输出效果会更明显，但是我这台win7没有配双机调试，这里就只能看一下输出的效果了

    首先直接加载一个exe，可以看到修改注册表的值成功

    image-20220501155155905.png

    加载驱动发现创建注册表值失败

    image-20220501155057647.png

    然后再加载我们的绕过回调函数的驱动，又可以加载成功

  • 相关阅读:
    京东数据平台：2023年京东营养保健品市场销售数据分析
    会计基础——公式汇总
    反向散射耦合RFID系统的原理及特点，带你更深入的了解
    redis 事务与管道
    vue快速学习02、基础用法
    GerbView生产高级软件,支持新旧表单
    线程创建、线程池创建相关理论知识整理
    【go语言】方法
    java毕业设计参考文献基于SSM学生成绩管理系统
    基于SSM的学生社团管理系统 毕业设计-附源码211531
  • 原文地址：https://blog.csdn.net/hongduilanjun/article/details/127641197