1.HIVE结构
首先,要明白的是注册表是由多个hive文件组成.
而一个hive是由许多bin组成,一个bin是由很多cell组成.
而cell可以有好几种类型.比如 key cell(cm_key_node) value cell(CM_KEY_VALUE) subbkey-list cell,value-list cell等
当新的数据要扩张一个hive时,总是按照block的粒度(4kb)来增加,一个hive的第一个块是base block.包含了有关该hive的全局信息.参考结构 _hbase_block
bin也有头部，其中包含了一个特征签名hbin，一个记录该bin在hive中的offset(偏移)，以及该bin的大小。bin头的大小一般为0x20。
所以一个hive的磁盘映像看起来如下图
+===============+
+ _hbase_block (4kb) +
+===============+
+ _bin0 +
+===============+
+ _bin1 +
+===============+
+ _bin2 +
+===============+
+ .........+
+===============+
+ _bin N +
+===============+
bin头的结构_hbin如下:
typedef struct _HBIN
{
+0x000 ULONG Signature; //”hbin”字符串
+0x004 ULONG FileOffset; //本BIN相差0x1000的偏移
+0x008 ULONG Size; //本BIN的大小
+0x00c ULONG Reserved1[2];
+0x014 LARGE_INTEGER TimeStamp;
+0x01c ULONG Spare;
+0x020 ULONG Reserved2;
+0x024
//
//这里开始是cell数据
//
}
所以定位到第一个cell的步骤如下:
1,将磁盘上的hive文件*.dat通过CreateFile()和CreateFileMapping()映射到内存,得到hFileMap.
2,hFileMap加上一个_base_block大小(0x1000)，定位到bin头，即RootBin=hFileMap+0x1000.
3,RootBin加上一个_hbin的大小，即可定位到第一个cell，即pKeyNode=RootBin+0x24；(假设该hive的第一个cell为_CM_KEY_NODE结构)
2.关于cell的几个结构
一个cell可以容纳一个键,一个值,一个安全描述,一列子键,或者一列键值.
typedef struct _CELL_DATA
{
union _u //注意它是一个联合体
{
CM_KEY_NODE KeyNode; //键结构
CM_KEY_VALUE KeyValue;//值的结构, 包含一个键的值的信息.
CM_KEY_SECURITY KeySecurity;//安全描述
CM_KEY_INDEX KeyIndex;//一列子键,又一系列的键cell的cellindex所构成的cell,这些cell是一个公共parent key的所有subkey.
CM_BIG_DATA ValueData;
HCELL_INDEX KeyList[1];//一列键值,
WCHAR KeyString[1];
} u;
} CELL_DATA, *PCELL_DATA;
lkd> DT _CM_KEY_NODE
nt!_CM_KEY_NODE
+0x000 Signature : Uint2B //”nk”字符串
+0x002 Flags : Uint2B
+0x004 LastWriteTime : _LARGE_INTEGER
+0x00c Spare : Uint4B
+0x010 Parent : Uint4B
+0x014 SubKeyCounts : [2] Uint4B //SubKeyCounts[0]子键的个数
+0x01c SubKeyLists : [2] Uint4B //SubKeyLists[0]子键列表相差本BIN的偏移
+0x024 ValueList : _CHILD_LIST //ValueList.Count值的个数
//ValueList.List值列表相差本BIN的偏移
+0x01c ChildHiveReference : _CM_KEY_REFERENCE
+0x02c Security : Uint4B
+0x030 Class : Uint4B
+0x034 MaxNameLen : Pos 0, 16 Bits
+0x034 UserFlags : Pos 16, 4 Bits
+0x034 VirtControlFlags : Pos 20, 4 Bits
+0x034 Debug : Pos 24, 8 Bits
+0x038 MaxClassLen : Uint4B
+0x03c MaxValueNameLen : Uint4B
+0x040 MaxValueDataLen : Uint4B
+0x044 WorkVar : Uint4B
+0x048 NameLength : Uint2B //键名的长度
+0x04a ClassLength : Uint2B
+0x04c Name : [1] Uint2B //键名
补充下_CHILD_LIST结构:
nt!_CHILD_LIST
+0x000 Count : Uint4B //ValueList.Count值的个数
+0x004 List : Uint4B //ValueList.List值列表相差本BIN的偏移
通过观察_CM_KEY_NODE结构,
我们发现pKeyNode+0x4c获得键名,即RootKeyName=pKeyNode->Name;
通过ValueList域,可得到值列表相差本bin的偏移,可以定位该键的值结构.即_CM_KEY_VALUE.
ValueIndex=(ULONG *)(Bin+ValueLists+0x4);
value=(PCM_KEY_VALUE)(Bin+ValueIndex[i]+0x4);
而通过SubKeyLists域,可得到子键列表相差本bin的偏移.
DWORD SubKeyLists=KeyNode->SubKeyLists[0];
KeyIndex=(PCM_KEY_INDEX)(RootBin+SubKeyLists+0x4);
lkd> DT _CM_KEY_VALUE
nt!_CM_KEY_VALUE
+0x000 Signature : Uint2B //”vk”字符串
+0x002 NameLength : Uint2B
+0x004 DataLength : Uint4B //数据长度，以字节计，包括结束符
+0x008 Data : Uint4B //注意：数据偏移或数据判断：如果DataLenth最高位为1，那么它就是数据，且DataLenth&0x7FFFFFFF为数据长度
+0x00c Type : Uint4B
+0x010 Flags : Uint2B
+0x012 Spare : Uint2B
+0x014 Name : [1] Uint2B
通过_CM_KEY_VALUE结构,可以获得该键值的类型(type),名字(Name),以及数据(Data)
lkd> dt _CM_KEY_INDEX
nt!_CM_KEY_INDEX
+0x000 Signature : Uint2B
+0x002 Count : Uint2B //这里也是表示子键的数量，与前面的相同
+0x004 List : [1] Uint4B //这里要注意了
如果Signature==CM_KEY_FAST_LEAF或CM_KEY_HASH_LEAF，那么从0x004偏移开始的数组元素结构如下：
struct
{
ULONG offset;
ULONG HashKey;
}
否则：
ULONG offset;
对于_CM_KEY_INDEX结构,通过List域可以定位所有子键的_CM_KEY_NODE结构,具体实现如下:
DWORD KeyNodeOffset=KeyIndex->List[i*2]; //(其中的i是,USHORT i=0,i<count,i++)
KeyNode=(PCM_KEY_NODE)(Bin+KeyNodeOffset+0x4);
这样定位到每个子键的_CM_KEY_NODE结构,就能获得该子键的键值,以及该子键下面的子子键,
这样重复上述的步骤就能实现对整个hive的解析.
ps下:通过是ring3的RegSaveKey(),可以生成一个Hive文件.
具体实现的代码如下:
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#define REGF 0x66676572 //fger
#define HBIN 0x6e696268 //nibh
#define CM_KEY_FAST_LEAF 0x666c // fl
#define CM_KEY_HASH_LEAF 0x686c // hl
//数据结构定义
typedef struct _CHILD_LIST
{
ULONG Count;
ULONG List;
}CHILD_LIST;
typedef struct _CM_KEY_NODE
{
USHORT Signature;
CHAR Reserve_1[18];
ULONG SubKeyCounts[2];
ULONG SubKeyLists[2];
CHILD_LIST ValueList;
CHAR Reserve_2[28];
USHORT NameLength;
SHORT ClassName;
CHAR Name;
} CM_KEY_NODE,*PCM_KEY_NODE;
typedef struct _CM_KEY_INDEX
{
USHORT Signature;
USHORT Count;
ULONG List[1];
} CM_KEY_INDEX, *PCM_KEY_INDEX;
typedef struct _CM_KEY_VALUE
{
USHORT Signature;
SHORT NameLength;
ULONG DataLength;
ULONG Data;
ULONG Type;
CHAR Reserve_1[4];
CHAR Name;
}CM_KEY_VALUE,*PCM_KEY_VALUE;
VOID TpyeKeyAndValue(PVOID FileMemAddr);
VOID TypeSubKey(PCHAR Bin,PCM_KEY_INDEX KeyIndex);
VOID TypeSubKeyName(PCHAR Bin,PCM_KEY_NODE KeyNode);
VOID TypeValue(PCHAR Bin,PCM_KEY_VALUE value);
int main(int argc,char *argv[])
{
HANDLE hFile;
HANDLE hFileMap;
DWORD FileSize;
PVOID FileMem;
#ifndef _DEBUG
if(argc!=2)
{
printf("*************************\n");
printf("Useage:\nHivePase FileName\n");
printf("*************************\n");
system("pause");
return 1;
}
hFile=CreateFile(argv[1],GENERIC_READ,0,NULL,
OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);
#else
hFile=CreateFile("c:\\test_root.dat",GENERIC_READ,0,NULL,
OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);
#endif
if(hFile==INVALID_HANDLE_VALUE)
{
printf("Error:File doesn's Exist!\n");
system("pause");
return 1;
}
FileSize=GetFileSize(hFile,NULL);
hFileMap=CreateFileMapping(hFile,NULL,PAGE_READONLY | SEC_COMMIT,0,FileSize,NULL);
if(hFileMap==NULL)
{
printf("CreateFileMapping Error!\n");
CloseHandle(hFile);
system("pause");
return 1;
}
CloseHandle(hFile);
FileMem=MapViewOfFile(hFileMap,FILE_MAP_READ,0,0,0);
if(FileMem==NULL)
{
printf("MapViewOfFile Error!\n");
CloseHandle(hFileMap);
system("pause");
return 1;
}
CloseHandle(hFileMap);
TpyeKeyAndValue(FileMem);
printf("\nSuccess!\n");
system("pause");
return 0;
}
VOID TpyeKeyAndValue(PVOID FileMemAddr)
{
char RootKeyName[256];
PCHAR RootBin;
PCM_KEY_NODE KeyNode;
PCM_KEY_INDEX KeyIndex;
if(*(ULONG*)FileMemAddr!=REGF)
{
printf("Not a Hive File!\n");
system("pause");
}
RootBin=(char*)FileMemAddr+0x1000;
KeyNode=(PCM_KEY_NODE)(RootBin+0x24);
if(*(ULONG*)RootBin!=HBIN)
{
printf("Hive File Error!\n");
system("pause");
}
ZeroMemory(RootKeyName,256);
memcpy(RootKeyName,&KeyNode->Name,KeyNode->NameLength);
printf("Root Key: %s\n",RootKeyName);
DWORD SubKeyLists=KeyNode->SubKeyLists[0];
KeyIndex=(PCM_KEY_INDEX)(RootBin+SubKeyLists+0x4);
TypeSubKey(RootBin,KeyIndex);
}
VOID TypeSubKey(PCHAR Bin,PCM_KEY_INDEX KeyIndex)
{
USHORT KeyCount;
PCM_KEY_NODE KeyNode;
KeyCount=KeyIndex->Count;
for(USHORT i=0;i<KeyCount;i++)
{
if(KeyIndex->Signature==CM_KEY_FAST_LEAF || KeyIndex->Signature==CM_KEY_HASH_LEAF)
{
DWORD KeyNodeOffset=KeyIndex->List[i*2];
KeyNode=(PCM_KEY_NODE)(Bin+KeyNodeOffset+0x4);
TypeSubKeyName(Bin,KeyNode);
}
else
{
DWORD KeyNodeOffset=KeyIndex->List[i*2];
KeyNode=(PCM_KEY_NODE)(Bin+KeyNodeOffset+0x4);
TypeSubKeyName(Bin,KeyNode);
}
}
}
VOID TypeSubKeyName(PCHAR Bin,PCM_KEY_NODE KeyNode)
{
char SubKeyName[256];
ULONG ValueLists;
ULONG ValueCount;
ULONG *ValueIndex;
PCM_KEY_VALUE value;
PCM_KEY_INDEX KeyIndex;
ZeroMemory(SubKeyName,256);
strncpy(SubKeyName,&KeyNode->Name,KeyNode->NameLength);
printf("Sub Key: %s\n",SubKeyName);
ValueLists=KeyNode->ValueList.List;
ValueCount=KeyNode->ValueList.Count;
if(ValueLists!=-1)
{
ValueIndex=(ULONG *)(Bin+ValueLists+0x4);
for(ULONG i=0;i<ValueCount;i++)
{
value=(PCM_KEY_VALUE)(Bin+ValueIndex[i]+0x4);
TypeValue(Bin,value);
}
}
if(KeyNode->SubKeyLists[0]!=-1)
{
KeyIndex=(PCM_KEY_INDEX)(Bin+KeyNode->SubKeyLists[0]+0x4);
TypeSubKey(Bin,KeyIndex);
}
}
VOID TypeValue(PCHAR Bin,PCM_KEY_VALUE value)
{
char ValueName[256];
ULONG DataLenth;
PCHAR Data;
ZeroMemory(ValueName,256);
strncpy(ValueName,&value->Name,value->NameLength);
printf("Value Name: %s\n",ValueName);
switch(value->Type)
{
case REG_SZ:
printf("REG_SZ ");
break;
case REG_BINARY:
printf("REG_BINARY ");
break;
case REG_DWORD:
printf("REG_DWORD ");
break;
case REG_MULTI_SZ:
printf("REG_MULIT_SZ ");
break;
case REG_EXPAND_SZ:
printf("REG_EXPAND_SZ ");
break;
default:
break;
}
if(value->Type==REG_DWORD)
{
Data=(PCHAR)&value->Data;
printf("%08x",*(ULONG*)Data);
}
else
{
if(value->DataLength & 0x80000000)
{
DataLenth=value->DataLength & 0x7FFFFFFF;
Data=(PCHAR)&value->Data;
for(ULONG i=0;i<DataLenth;i++)
{
if(value->Type==REG_BINARY)
{
printf("%1x",Data[i]);
}
else
{
printf("%c",Data[i]);
}
}
}
else
{
DataLenth=value->DataLength;
DWORD DataOffset=value->Data;
Data=Bin+DataOffset+0x4;
for(ULONG i=0;i<DataLenth;i++)
{
if(value->Type==REG_BINARY)
{
printf("%1x",Data[i]);
}
else
{
printf("%c",Data[i]);
}
}
}
}
printf("\n");
} |
关于上面code的一些补充说明:(by linxer)
1.对nk节点下二级索引子键的情况没有处理(有ri节点情况,当子键过多的时候系统会使用ri节点的)
2.TypeValue里对值名称的处理有问题,问题出在这下面两行代码
strncpy(ValueName,&value->Name,value->NameLength);
printf("Value Name: %s\n",ValueName);
vk节点的值名称未必就是ascii字符串,因此用str系列函数是不可以的,正确用法应该是
memcpy(ValueName,&value->Name,value->NameLength);因此显示语句也不能用printf来显示,目前我看到的很多代码都有这样的问题(chntpw),还有一些使用的hive解析的工具(SnipeSword0225)也有这种问题
(责任编辑：admin)
