lain32 - Delphi 2010 And Reverse Engineering

VirtualBox 3.0.6 r52128 네트워크 공유 폴더 접근 시 BSDO

lain32 — Wed, 30 Sep 2009 11:44:12 GMT

네트워크 공유 폴더에 접근 시 랜덤하게 위와 같은 블루 스크린을 볼 수가 있습니다.
저같은 경우에는 네트워크 공유 폴더에 접근 후에 파일의 속성을 볼려고 시도를 하면 파일 속성창이
바로 뜨지 않고 딜레이가 생기다가 간혹 블루 스크린이 뜨는 것 같습니다.

밑에 링크를 따라가면 해결책이 나오긴 했는데 워낙에 랜덤하게 발생하는 문제라서 테스트는 해보지는 못 하였네요.
http://justcheckingonall.wordpress.com/2009/01/08/windows-xp-under-virtualbox/

이것말고도 VirtualBox에 경우 블루 스크린이 뜰 때 간혹 화면이 깨진 상태로 GuestOS가 멈춰버리는 문제점도 있는데
아직까지 안정성에는 좀 문제가 있는 것 같습니다. 하지만 속도는 매우 빠르네요..

tag : VirtualBox, 버츄얼박스, VMWare

Delphi 2010에 Format Source 기능

lain32 — Mon, 28 Sep 2009 14:14:20 GMT

Delphi 2010에는 다음과 같은 메뉴가 새로 생겼습니다.

Format Source라는 메뉴인데 이 기능은 코드를 정렬해주는 기능입니다.
아주 깔끔하게 코드를 정렬해줍니다.

예를 들어 다음과 같은 개념없는 코드가..

그냥 아무 생각없이 Ctrl + D 를 누르면.....
다음과 같이 바뀌는 것입니다.

tag : Delphi2010, Delphi, SourceFormat

커널 디버거 탐지 기법 우회

lain32 — Mon, 28 Sep 2009 13:40:25 GMT

다음 코드 2줄로 우회가 가능합니다.

extern PBOOLEAN KdDebuggerEnabled; // 선언..
*KdDebuggerEnabled = FALSE; // 우회 코드

KdDebuggerEnabled 변수를 직접적으로 접근하지 않는 방식을 사용하여도 이 방법은 통합니다.
왜냐하면 결국엔 그 함수들은 저 전역변수를 참조하게 됩니다.
심지어 WinDbg 조차도 저렇게 값을 임의로 바꾸면 Attach가 안됩니다.

따라서 이러한 경우 커널 디버거는 우회가 되는데 WinDbg로 Attach 하여서 디버깅하는데 조금 문제가 생길것입니다.
따라서 디버거를 탐지하는 코드가 실행되는 경우에는 우선 저렇게 전역변수를 FALSE로 바꾸고
디버거 탐지코드가 실행되었다면 다시 KdDebuggerEnabled 커널 전역변수를 TRUE로 바꿔주면
WinDbg로 Attach 도 되고 디버깅이 가능해집니다.

커널 디버거를 탐지하는 대상 코드는 아래와 같고 이러한 코드는 이전에 말했듯이 내부적으로
위에 커널 전역변수를 사용하므로 우회가 됩니다.

bool __stdcall IsDebugPort(PVOID Object)
{
void *pZwQueryInformationProcess; // eax@2
bool result; // eax@4
signed int bDebug; // [sp+10h] [bp-4h]@1
int v4; // [sp+Ch] [bp-8h]@2
UNICODE_STRING DestinationString; // [sp+4h] [bp-10h]@3

bDebug = 0;
if ( PsLookupProcessByProcessId(Object, &Object) >= 0
    && ((ObOpenObjectByPointer(Object, 0, 0, 0, 0, 0, &v4), ObfDereferenceObject(Object), pZwQueryInformationProcess = (void *)g_ZwQueryInformationProcess, g_ZwQueryInformationProcess)
     || (RtlInitUnicodeString(&DestinationString, L"ZwQueryInformationProcess"), pZwQueryInformationProcess = MmGetSystemRoutineAddress(&DestinationString), g_ZwQueryInformationProcess = (int)pZwQueryInformationProcess, pZwQueryInformationProcess)) )
{
    ((int (__stdcall *)(int, signed int, signed int *, signed int, _DWORD))pZwQueryInformationProcess)(
      v4,
      7,
      &bDebug,
      4,
      0);                                                       // 이 함수에 두 번째 인자 ProcessDebugPort를 넘기고 있다.
                                                                // 즉, 이것은 디버그중인지 체크한다고 보면 될것이다.
    result = bDebug == -1;                                      // -1(0xFFFFFFFF) 일 경우 디버깅중인 상태입니다.
}
else
{
    result = 0;
}
return result;
}

일부 보안 드라이버에서는 실시간으로 KdDebuggerEnabled 에 직접 접근하여 디버깅중인지 체크하는데
이러한 경우 해당 드라이버에 한해서 IAT만 변조하는 방식으로 우회하여도 됩니다.
그러나 일반적인 경우 드라이버 초기화 작업에서만 디버깅중인지 체크하므로 위에 방법으로 왠만하면 우회가 가능합니다.

tag : 키보드보안, 커널디버거, 디버거, 디버거우회, 커널디버거탐지우회, 커널디버거탐지기법우회

오픈캡쳐 버전관리 사이트를 soureforege로 옮겼습니다.

lain32 — Sun, 27 Sep 2009 12:38:33 GMT

변경 된 가장 핵심적인 부분은 다음과 같습니다.

sourceforge 주소가 다음과 같이 변경되었습니다.
http://sourceforge.net/projects/opencapture

svn 주소가 다음과 같이 변경되었습니다.
https://opencapture.svn.sourceforge.net/svnroot/opencapture

소스 브라우저는 기존 trac를 사용하지 않고 SCM Repositories 를 사용합니다.
주소는 다음과 같습니다.
http://opencapture.svn.sourceforge.net/viewvc/opencapture/

현재 개발진행 중인 최신 소스코드는 다음 주소에서 받을 수 있습니다.
http://opencapture.svn.sourceforge.net/viewvc/opencapture.tar.gz?view=tar

tag : 오픈캡쳐, 버전관리, sourceforge, opencapture

오픈캡쳐가 Delphi 2010으로 개발됩니다.

lain32 — Sun, 27 Sep 2009 12:36:07 GMT

원래 Turbo Delphi 2006으로 개발을 진행하였는데 해당 버전이 엠바카데로에서 더 이상 지원을
하지 않는 것 같네요. 거기다가 문제가 너무 많구요..

그래서 그냥 정품을 샀습니다.
아무튼 업그레이드 하면서 자동적으로 유니코드가 지원이 되었네요.

한동안 오픈캡쳐 개발을 거의 안 하다시피 했는데 ( 몇 달 동안 안 한듯 .. -_- ) 이제부터라도 조금씩
기능추가들을 해놓겠습니다.

tag : Delphi2010, 오픈캡쳐

VMWare 탐지 기법 우회

lain32 — Sun, 27 Sep 2009 12:29:29 GMT

http://www.trapkit.de/



위에 사이트에 가시면 여러가지 VMWare 탐지 기법들에 대해서 소개하고 있고 맨 마지막으로 그 모든 탐지기법들을

우회하는 방법에 대해서 설명하는데 우회하는 방법은 VMWare에 vmx 파일에 다음 설정을 추가하는 것입니다.



isolation.tools.getPtrLocation.disable = "TRUE"
isolation.tools.setPtrLocation.disable = "TRUE"
isolation.tools.setVersion.disable = "TRUE"
isolation.tools.getVersion.disable = "TRUE"
monitor_control.disable_directexec = "TRUE"
monitor_control.disable_chksimd = "TRUE"
monitor_control.disable_ntreloc = "TRUE"
monitor_control.disable_selfmod = "TRUE"
monitor_control.disable_reloc = "TRUE"
monitor_control.disable_btinout = "TRUE"
monitor_control.disable_btmemspace = "TRUE"
monitor_control.disable_btpriv = "TRUE"
monitor_control.disable_btseg = "TRUE"



테스트 해본결과 일부 상용 DRM 솔루션이 VMWare 탐지인지 체크하는데 유명한 DRM 솔루션도 이 방법은

우회를 하지 못 하였네요.

tag : VMWare, VMWareDection, 리버스엔지니어링, VMWareDetoure, Detoure

Sysinternals - Filemon source code

lain32 — Sat, 25 Jul 2009 12:32:32 GMT

Filemon 소스코드입니다.
요것도 꽤 오래된 소스코드이지만 하드에서 증발할 가능성이 있어서 이곳에 올립니다.

참고로 WDK Samples에 보면 Minispy라고 Filemon가 같은 역할을 하는 MiniFilter 드라이버 예제코드가 있습니다.

filemon434.7z

tag : Filemon, DeviceDriver

Sysinternals - Regmon source code

lain32 — Sat, 25 Jul 2009 12:28:43 GMT

Sysinternals 에서 만든 Regmon 소스코드입니다.
좀 오래된 소스이긴한데 나중에 제 하드에서 증발할 가능성이 있어서 이곳에 올립니다.

regmon435.7z

tag : Regmon, DeviceDriver

기본적인 커널 후킹 탬플릿 코드 2 - IRP Completion Hook

lain32 — Sat, 25 Jul 2009 09:46:05 GMT

이전에 설명한 IRP Hook 코드와는 크게 다른 부분은 없고 추가적으로
완료 루틴을 훅킹하는 예제를 보여줍니다.
완료 루틴을 훅킹함으로써 하드 디스크에서 어떠한 데이터를 읽었는지 알아내는 예제입니다.

완료루틴에서 데이터를 가져올 때 지금과 같이 ATAPI.sys에 경우
Irp->MdlAddress 로부터 읽은 섹터를 가져오는데 이 때 MmGetSystemAddressForMdlSafe 함수를
사용하면 안되고 자체적으로 해당 매크로를 구현해주었습니다.
주석에도 나왓듯이 간혹 MDL_MAPPED_TO_SYSTEM_VA 플래그가 MDL에 포함 된 상태로
오는 경우가 있기 때문입니다.
만약 그런 경우가 발생하게 되면 다음과 같이 블루 스크린이 뜰 수 있습니다.

그리고 현재 ATAPI.sys를 훅킹하기 위해 \\Device\\Ide\\IdeDeviceP1T0L0-17 요런식으로
디바이스 이름을 가져오는데 이렇게 가져오지 않고 다음과 같이 드라이버 오브젝트를 가져오는
방식으로 해도 상관이 없습니다.

UNICODE_STRING uniname;
PDRIVER_OBJECT atapi_dev;

NTSTATUS ntStatus;

RtlInitUnicodeString(&uniname , L"\\Driver\\Atapi");
ntStatus = ObReferenceObjectByName( &uniname ,
                               OBJ_CASE_INSENSITIVE ,
                               NULL ,
                               0,
                               *IoDriverObjectType ,
                               KernelMode ,
                               NULL ,
                                (PVOID*)&atapi_dev);

참고로 특정 PC에 경우에는 ATAPI.sys를 안 쓰고 자체 드라이버를 쓰는 경우도 있으니 참고바랍니다.

IRP Completion Hook에 대해 어려운 부분이 없으므로 잡담은 그만하고 소스코드올립니다.

IRPCompletionHookTemplate.7z

#include
#include

//
// 이 구조체에 필요한 데이터 변수들을 추가합니다.
//
typedef struct _MY_CONTEXT_DATA
{
    //
    // 이곳에 추가..
    //
    PVOID pNotUsedData;
} MY_CONTEXT_DATA, *PMY_CONTEXT_DATA;

typedef struct _HOOK_CONTEXT_DATA
{
    PIO_COMPLETION_ROUTINE pOrgCompletionRoutine;
    PVOID pOrgContext;

    MY_CONTEXT_DATA MyContextData;
} HOOK_CONTEXT_DATA, *PHOOK_CONTEXT_DATA;

PDEVICE_OBJECT g_HookDeviceObject = NULL;
PDRIVER_DISPATCH g_OrgHandler = NULL;
UCHAR g_HookMajorFunctionIndex = 0xFF;

LONG g_IRPEnterCount = 0;

PDEVICE_OBJECT MyIoGetDeviceObjectPointer(__in WCHAR *DeviceObjectName, __in BOOLEAN bRelated);

BOOLEAN IrpHook(__in PDEVICE_OBJECT DeviceObject, __in UCHAR MajorFunctionIndex, __out PDRIVER_DISPATCH *pOrgHandler, PDRIVER_DISPATCH pNewHandler);
BOOLEAN IrpHookFormName(__in WCHAR *DeviceObjectName, __in UCHAR MajorFunctionIndex, __out PDRIVER_DISPATCH *pOrgHandler, PDRIVER_DISPATCH pNewHandler);

VOID IrpUnhook();

NTSTATUS NewIrpHandler(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp);

PDEVICE_OBJECT MyIoGetDeviceObjectPointer(__in WCHAR *DeviceObjectName, __in BOOLEAN bRelated)
{
    NTSTATUS ntStatus;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    UNICODE_STRING Name;

    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE FileHandle;
    IO_STATUS_BLOCK IoStatus;

    DeviceObject = NULL;

    RtlInitUnicodeString(&Name, DeviceObjectName);
    if (bRelated == TRUE)
    {
        // IoGetDeviceObjectPointer는 내부적으로 IoGetRelatedDeviceObject 함수를 호출합니다.
        // 따라서 DeviceObjectName 에 해당하는 디바이스 오브젝트 포인터를 얻어오는게 아니라
        // 해당 디바이스 오브젝트에 대한 최상위 디바이스 오브젝트를 얻어옵니다.
        ntStatus = IoGetDeviceObjectPointer(&Name, FILE_READ_ATTRIBUTES, &FileObject, &DeviceObject);
        if (NT_SUCCESS(ntStatus) == TRUE)
        {
            return DeviceObject;
        }
        else
        {
            return NULL;
        }
    }
    else
    {
        // 실제 해당 이름을 가진 디바이스 오브젝트를 얻옵니다.
        InitializeObjectAttributes(&ObjectAttributes,
                                    &Name,
                                    0,
                                    (HANDLE) NULL,
                                    (PSECURITY_DESCRIPTOR)NULL);

        ntStatus = ZwOpenFile(&FileHandle,
                            FILE_READ_ATTRIBUTES,
                            &ObjectAttributes,
                            &IoStatus,
                            0,
                            FILE_NON_DIRECTORY_FILE);

        if (NT_SUCCESS(ntStatus) == FALSE)
        {
            // 해당 디바이스 오브젝트를 열 수 없습니다.
            return NULL;
        }

        ntStatus = ObReferenceObjectByHandle(FileHandle,
                                                                0,
                                                                *IoFileObjectType,
                                                                KernelMode,
                                                                (PVOID *)&FileObject,
                                                                NULL);

        if (NT_SUCCESS(ntStatus) == TRUE)
        {
            // Windows 2000 소스코드 참고
            // 실제 내부 구현도 이와 비슷하게 되어 있습니다.

            //
            // If the file object was taken out against the mounted file system, it
            // will have a Vpb. Traverse it to get to the DeviceObject. Note that in
            // this case we should never follow FileObject->DeviceObject, as that
            // mapping may be invalid after a forced dismount.
            //
            if (FileObject->Vpb != NULL && FileObject->Vpb->DeviceObject != NULL)
            {
                DeviceObject = FileObject->Vpb->DeviceObject;
                //
                // If a driver opened a disk device using direct device open and
                // later on it uses IoGetRelatedTargetDeviceObject to find the
                // device object it wants to send an IRP then it should not get the
                // filesystem device object. This is so that if the device object is in the
                // process of being mounted then vpb is not stable.
                //

            }
            else if (!(FileObject->Flags & FO_DIRECT_DEVICE_OPEN) &&
                       FileObject->DeviceObject->Vpb != NULL &&
                       FileObject->DeviceObject->Vpb->DeviceObject != NULL)
            {

                DeviceObject = FileObject->DeviceObject->Vpb->DeviceObject;
                //
                // This is a direct open against the device stack (and there is no mounted
                // file system to strain the IRPs through).
                //

            }
            else
            {
                DeviceObject = FileObject->DeviceObject;
            }
            ZwClose(FileHandle);

            return DeviceObject;
        }
        else
        {
            ZwClose(FileHandle);

            return NULL;
        }
    }
}

VOID DriverUnload(__in PDRIVER_OBJECT DriverObject)
{
    KdPrint(("Driver unload.\n"));

    // 드라이버 언로드 루틴에서 호출됩니다.
    IrpUnhook(TRUE);
}

BOOLEAN IrpHook(__in PDEVICE_OBJECT DeviceObject, __in UCHAR MajorFunctionIndex, __out PDRIVER_DISPATCH *pOrgHandler, PDRIVER_DISPATCH pNewHandler)
{
    g_IRPEnterCount = 0;

    *pOrgHandler = DeviceObject->DriverObject->MajorFunction[MajorFunctionIndex];
    if (*pOrgHandler == NULL)
    {
        return FALSE;
    }

    g_HookDeviceObject = DeviceObject;
    g_HookMajorFunctionIndex = MajorFunctionIndex;

    InterlockedExchangePointer(&(DeviceObject->DriverObject->MajorFunction[MajorFunctionIndex]), pNewHandler);

    return TRUE;
}

BOOLEAN IrpHookFormName(__in WCHAR *DeviceObjectName, __in UCHAR MajorFunctionIndex, __out PDRIVER_DISPATCH *pOrgHandler, PDRIVER_DISPATCH pNewHandler)
{
    PDEVICE_OBJECT DeviceObject;

    DeviceObject = MyIoGetDeviceObjectPointer(DeviceObjectName, FALSE);
    if (DeviceObject != NULL)
    {
        return (IrpHook(DeviceObject, MajorFunctionIndex, pOrgHandler, pNewHandler));
    }
    else
    {
        return FALSE;
    }
}

VOID IrpUnhook(BOOLEAN DriverUnloadRoutine)
{
    if ((g_HookDeviceObject == NULL)
        || (g_OrgHandler == NULL))
    {
        KdPrint(("Not hooked.\n"));
    }
    else
    {
        // IRP 핸들러를 원래의 핸들러로 되돌려줍니다.
        InterlockedExchangePointer(&(g_HookDeviceObject->DriverObject->MajorFunction[g_HookMajorFunctionIndex]), g_OrgHandler);

        if (DriverUnloadRoutine == TRUE)
        {
            LARGE_INTEGER WaitTime;

            WaitTime.QuadPart = -1 * 10 * 1000 * 1000;

            //
            // 드라이버 언로드 루틴에서 이 함수가 호출되었다면
            // InterlockedExchangePointer 후에 바로 드라이버가 언로드 되므로
            // 이 때 InterlockedExchangePointer를 하기전에 훅킹 핸들러가 실행되었고
            // 그 후에 InterlockedExchangePointer함수가 리턴하게 되면
            // 훅킹 핸들러를 원래대로 되돌려주었지만 현재 루틴이 실행중일 수 있으므로 이에 대한 동기화 처리를
            // 진행합니다.
            //

            while (g_IRPEnterCount > 0)
            {
                // 현재 훅킹루틴이 실행중에 있으므로 잠시 대기합니다.
                KeDelayExecutionThread(KernelMode ,FALSE, &WaitTime);
            }
            // 마지막으로 한 번 더 대기합니다.
            KeDelayExecutionThread(KernelMode ,FALSE, &WaitTime);
        }
    }
}

NTSTATUS NewIoCompletionRoutine(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp, __in_opt PVOID Context)
{
    PHOOK_CONTEXT_DATA pHookContextData;

    PIO_COMPLETION_ROUTINE pOrgCompletionRoutine;
    PVOID pOrgContext;

    PIO_STACK_LOCATION pIoStackLocation;

    UCHAR *pBuffer;
    ULONG i, DataLength;

    BOOLEAN bUnlock;

    pHookContextData = (PHOOK_CONTEXT_DATA)Context;

    pOrgCompletionRoutine = pHookContextData->pOrgCompletionRoutine;
    pOrgContext = pHookContextData->pOrgContext;

    pIoStackLocation = IoGetNextIrpStackLocation(Irp);
    if (pIoStackLocation->MajorFunction == g_HookMajorFunctionIndex)
    {
        if (Irp->MdlAddress != NULL)
        {
            KdPrint(("Irp->MdlAddress->MdlFlags : %u\n", Irp->MdlAddress->MdlFlags));

            // 이 접근 방식을 사용하지 않습니다.
            // 특정 상황에 경우 블루 스크린이 뜰 수 있습니다.
            // 왜냐하면 간혹 MDL이 이미 맵핑되어 있는 상태로 올 수가 있는데 이 때
            // MmUnmapLockedPages 함수를 호출해버리면 훅킹루틴에서 맵핑을 해제해 버리기 때문에
            // 블루 스크린이 발생합니다.
            // ( 정확하게 말해서 Irp->MdlAddress->MdlFlags에 MDL_MAPPED_TO_SYSTEM_VA 플래그가
            //   포함 된 상태인 경우가 어쩌다가 한 번씩 존재합니다. )
            //pBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);

            if (Irp->MdlAddress->MdlFlags &
                        (MDL_MAPPED_TO_SYSTEM_VA |
                        MDL_SOURCE_IS_NONPAGED_POOL))
            {
                pBuffer = Irp->MdlAddress->MappedSystemVa;
                bUnlock = FALSE;
            }
            else
            {
                pBuffer = MmMapLockedPagesSpecifyCache(Irp->MdlAddress,
                                                                                KernelMode,
                                                                                MmCached,
                                                                                NULL,
                                                                                FALSE,
                                                                                NormalPagePriority);
                bUnlock = TRUE;
            }
            if (pBuffer != NULL)
            {
                DataLength = Irp->IoStatus.Information;

                KdPrint(("ATAPI read databuffer. read length : %u\n", DataLength));
                if (DataLength > 5)
                {
                    // 읽은 데이터의 일부분만 출력합니다.
                    DataLength = 5;
                }
                for (i = 0; i < DataLength; i++)
                {
                    KdPrint(("%#x\n", pBuffer[i]));
                }

                if (bUnlock == TRUE)
                {
                    MmUnmapLockedPages(pBuffer, Irp->MdlAddress);
                }
            }
        }
    }

    KdPrint(("NewIoCompletionRoutine\n"));

    return (pOrgCompletionRoutine(DeviceObject, Irp, pOrgContext));
}

NTSTATUS NewIrpHandler(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp)
{
    NTSTATUS ntStatus;

    // 동기화를 위한 전역 카운트를 증가시킵니다.
    InterlockedIncrement(&g_IRPEnterCount);

    // 디바이스 오브젝트에 대한 필터링을 하였지만 상황에 따라 하지 않아야 할 수도 있습니다.
    //if (DeviceObject == g_HookDeviceObject)
    {
        // 우리가 원하는 DeviceObject에서 발생한 Irp입니다.
        PIO_STACK_LOCATION pIoStackLocation;

        pIoStackLocation = IoGetCurrentIrpStackLocation(Irp);
        if (pIoStackLocation->MajorFunction == g_HookMajorFunctionIndex)
        {
            //
            // 이곳에 원하는 코드를 작성합니다.
            // 예제코드에서는 간단히 CDB에 대해서 출력하겠습니다.
            //
            switch (pIoStackLocation->Parameters.Scsi.Srb->Cdb[0])
            {
                case SCSIOP_READ:
                    // ATAPI.sys에 기본적인 읽기명령이 발생하였습니다.
                    if (pIoStackLocation->CompletionRoutine != NULL)
                    {
                        // 예제에서는 완료루틴이 등록되어 있을 경우에만 완료 루틴을 훅킹합니다.
                        PHOOK_CONTEXT_DATA pHookContextData;

                        pHookContextData = ExAllocatePoolWithTag(NonPagedPool, sizeof(HOOK_CONTEXT_DATA), 'tseT');
                        if (pHookContextData != NULL)
                        {
                            pHookContextData->pOrgCompletionRoutine = pIoStackLocation->CompletionRoutine;
                            pHookContextData->pOrgContext = pIoStackLocation->Context;

                            pIoStackLocation->CompletionRoutine = NewIoCompletionRoutine;
                            pIoStackLocation->Context = pHookContextData;

                            // pIoStackLocation->Control = SL_INVOKE_ON_SUCCESS;
                        }
                    }

                    break;
            }
        }
    }
    ntStatus = g_OrgHandler(DeviceObject, Irp);

    // 동기화를 위한 전역 카운트를 감소합니다.
    InterlockedDecrement(&g_IRPEnterCount);

    return (ntStatus);
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
    NTSTATUS ntStatus;
    PDEVICE_OBJECT DeviceObject;

    // 드라이버가 언로드 될 수 있도록 합니다.
    DriverObject->DriverUnload = DriverUnload;

    // 예제로 훅킹하는 디바이스는 하드 디스크입니다.
    // ( 실제 하드 디스크에 섹터를 읽어주는 디바이스입니다. )
    //
    // 해당 디바이스 이름은 시스템에 따라서 다릅니다.
    // IRP_MJ_SCSI 를 훅킹합니다.
    if (IrpHookFormName(L"\\Device\\Ide\\IdeDeviceP1T0L0-17", IRP_MJ_SCSI, &g_OrgHandler, NewIrpHandler) == TRUE)
    {
        KdPrint(("IrpHookFormName successed.\n"));
    }
    else
    {
        KdPrint(("IrpHookFormName failed.\n"));
    }

    return STATUS_SUCCESS;
}

tag : IRPHook, IRPCompletion, ATAPI, ATAPI.sys, DeviceDriver

기본적인 커널 후킹 탬플릿 코드 1 - IRP Hook

lain32 — Sun, 19 Jul 2009 09:39:18 GMT

간단한 IRP Hook 코드입니다.
해당 코드에 일부를 수정하여 다른 IRP를 손쉽게 훅킹할 수 있습니다.
보통 저에 경우에는 다른 드라이버에 대한 값을 모니터링 할 때 많이 사용합니다.

예제코드는 ATAPI.sys에 IRP_MJ_SCSI를 훅킹하고 있고 Cdb를 출력합니다.
Cdb와 SCSI에 대한 설명은 IRP Hook 범위를 넘어가므로 이에 대한 설명을 하지 않겠습니다.

개인적으로 만든 코드라서 개인적인 루틴도 추가되었습니다.
예를 들어 IRP 핸들러 시작부분과 끝부분에 g_IRPEnterCount변수 사용 및
IRPUnhook 시 이 변수를 체크합니다.
이는 드라이버 동적 언로드 시 극악의 확률로 발생가능한 동기화문제를 막기 위해서입니다.

또 IRP Hook시 주의해야 할 점은 이러한 방식에 훅킹은 접근이 허용되지만
*pOrgHandler = DeviceObject->DriverObject->MajorFunction[MajorFunctionIndex];
InterlockedExchangePointer(&(DeviceObject->DriverObject->MajorFunction[MajorFunctionIndex]), pNewHandler);

이러한 방식에 접근은 허용되지 않습니다.
*pOrgHandler = InterlockedExchangePointer(&(DeviceObject->DriverObject->MajorFunction[MajorFunctionIndex]), pNewHandler);

물론 위에 코드나 밑에 코드나 별차이가 없어보이고 실제로 동작시켜보면 둘 다 아무런 문제가 없어보이지만
밑에 코드에 경우에는 새로운 IRP 핸들러루틴에서 pOrgHandler를 참조하게 되는데 이 때 InterlockedExchangePointer
함수가 리턴하기전에 이미 함수 포인터는 바꼈고 이 상태에서 새로운 IRP 핸들러 루틴이 실행될 수 있기 때문에
정말 극악의 확률로 블루 스크린이 뜰 수 있기 때문입니다.
( 또한 InterlockedExchangePointer 는 함수가 아니라 컴파일 시 어셈블리 코드로 변환됩니다. )

예제 코드 다운로드 ( IRPHookTemplate.7z )

#include
#include

PDEVICE_OBJECT g_HookDeviceObject = NULL;
PDRIVER_DISPATCH g_OrgHandler = NULL;
UCHAR g_HookMajorFunctionIndex = 0xFF;

LONG g_IRPEnterCount = 0;

PDEVICE_OBJECT MyIoGetDeviceObjectPointer(__in WCHAR *DeviceObjectName, __in BOOLEAN bRelated);

BOOLEAN IrpHook(__in PDEVICE_OBJECT DeviceObject, __in UCHAR MajorFunctionIndex, __out PDRIVER_DISPATCH *pOrgHandler, PDRIVER_DISPATCH pNewHandler);
BOOLEAN IrpHookFormName(__in WCHAR *DeviceObjectName, __in UCHAR MajorFunctionIndex, __out PDRIVER_DISPATCH *pOrgHandler, PDRIVER_DISPATCH pNewHandler);

VOID IrpUnhook();

NTSTATUS NewIrpHandler(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp);

PDEVICE_OBJECT MyIoGetDeviceObjectPointer(__in WCHAR *DeviceObjectName, __in BOOLEAN bRelated)
{
   NTSTATUS ntStatus;
   PFILE_OBJECT FileObject;
   PDEVICE_OBJECT DeviceObject;
   UNICODE_STRING Name;

    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE FileHandle;
    IO_STATUS_BLOCK IoStatus;

   DeviceObject = NULL;

   RtlInitUnicodeString(&Name, DeviceObjectName);
   if (bRelated == TRUE)
   {
       // IoGetDeviceObjectPointer는 내부적으로 IoGetRelatedDeviceObject 함수를 호출합니다.
       // 따라서 DeviceObjectName 에 해당하는 디바이스 오브젝트 포인터를 얻어오는게 아니라
       // 해당 디바이스 오브젝트에 대한 최상위 디바이스 오브젝트를 얻어옵니다.
       ntStatus = IoGetDeviceObjectPointer(&Name, FILE_READ_ATTRIBUTES, &FileObject, &DeviceObject);
       if (NT_SUCCESS(ntStatus) == TRUE)
       {
           return DeviceObject;
       }
       else
       {
           return NULL;
       }
   }
   else
   {
       // 실제 해당 이름을 가진 디바이스 오브젝트를 얻옵니다.
       InitializeObjectAttributes(&ObjectAttributes,
                                   &Name,
                                   0,
                                   (HANDLE) NULL,
                                   (PSECURITY_DESCRIPTOR)NULL);

       ntStatus = ZwOpenFile(&FileHandle,
                           FILE_READ_ATTRIBUTES,
                           &ObjectAttributes,
                           &IoStatus,
                           0,
                           FILE_NON_DIRECTORY_FILE);

       if (NT_SUCCESS(ntStatus) == FALSE)
       {
           // 해당 디바이스 오브젝트를 열 수 없습니다.
           return NULL;
       }

        ntStatus = ObReferenceObjectByHandle(FileHandle,
                                                               0,
                                                               *IoFileObjectType,
                                                               KernelMode,
                                                               (PVOID *)&FileObject,
                                                               NULL);

       if (NT_SUCCESS(ntStatus) == TRUE)
       {
           // Windows 2000 소스코드 참고
           // 실제 내부 구현도 이와 비슷하게 되어 있습니다.

           //
           // If the file object was taken out against the mounted file system, it
           // will have a Vpb. Traverse it to get to the DeviceObject. Note that in
           // this case we should never follow FileObject->DeviceObject, as that
           // mapping may be invalid after a forced dismount.
           //
           if (FileObject->Vpb != NULL && FileObject->Vpb->DeviceObject != NULL)
           {
               DeviceObject = FileObject->Vpb->DeviceObject;
               //
               // If a driver opened a disk device using direct device open and
               // later on it uses IoGetRelatedTargetDeviceObject to find the
               // device object it wants to send an IRP then it should not get the
               // filesystem device object. This is so that if the device object is in the
               // process of being mounted then vpb is not stable.
               //

           }
           else if (!(FileObject->Flags & FO_DIRECT_DEVICE_OPEN) &&
                       FileObject->DeviceObject->Vpb != NULL &&
                       FileObject->DeviceObject->Vpb->DeviceObject != NULL)
           {

               DeviceObject = FileObject->DeviceObject->Vpb->DeviceObject;
               //
               // This is a direct open against the device stack (and there is no mounted
               // file system to strain the IRPs through).
               //

           }
           else
           {
               DeviceObject = FileObject->DeviceObject;
           }
           ZwClose(FileHandle);

           return DeviceObject;
       }
       else
       {
           ZwClose(FileHandle);

           return NULL;
       }
   }
}

VOID DriverUnload(__in PDRIVER_OBJECT DriverObject)
{
   KdPrint(("Driver unload.\n"));

   // 드라이버 언로드 루틴에서 호출됩니다.
   IrpUnhook(TRUE);
}

BOOLEAN IrpHook(__in PDEVICE_OBJECT DeviceObject, __in UCHAR MajorFunctionIndex, __out PDRIVER_DISPATCH *pOrgHandler, PDRIVER_DISPATCH pNewHandler)
{
   g_IRPEnterCount = 0;

   *pOrgHandler = DeviceObject->DriverObject->MajorFunction[MajorFunctionIndex];
   if (*pOrgHandler == NULL)
   {
       return FALSE;
   }

   g_HookDeviceObject = DeviceObject;
   g_HookMajorFunctionIndex = MajorFunctionIndex;

   InterlockedExchangePointer(&(DeviceObject->DriverObject->MajorFunction[MajorFunctionIndex]), pNewHandler);

   return TRUE;
}

BOOLEAN IrpHookFormName(__in WCHAR *DeviceObjectName, __in UCHAR MajorFunctionIndex, __out PDRIVER_DISPATCH *pOrgHandler, PDRIVER_DISPATCH pNewHandler)
{
   PDEVICE_OBJECT DeviceObject;

   DeviceObject = MyIoGetDeviceObjectPointer(DeviceObjectName, FALSE);
   if (DeviceObject != NULL)
   {
       return (IrpHook(DeviceObject, MajorFunctionIndex, pOrgHandler, pNewHandler));
   }
   else
   {
       return FALSE;
   }
}

VOID IrpUnhook(BOOLEAN DriverUnloadRoutine)
{
   if ((g_HookDeviceObject == NULL)
       || (g_OrgHandler == NULL))
   {
       KdPrint(("Not hooked.\n"));
   }
   else
   {
       // IRP 핸들러를 원래의 핸들러로 되돌려줍니다.
       InterlockedExchangePointer(&(g_HookDeviceObject->DriverObject->MajorFunction[g_HookMajorFunctionIndex]), g_OrgHandler);

       if (DriverUnloadRoutine == TRUE)
       {
           LARGE_INTEGER WaitTime;

           WaitTime.QuadPart = -1 * 10 * 1000 * 1000;

           //
           // 드라이버 언로드 루틴에서 이 함수가 호출되었다면
           // InterlockedExchangePointer 후에 바로 드라이버가 언로드 되므로
           // 이 때 InterlockedExchangePointer를 하기전에 훅킹 핸들러가 실행되었고
           // 그 후에 InterlockedExchangePointer함수가 리턴하게 되면
           // 훅킹 핸들러를 원래대로 되돌려주었지만 현재 루틴이 실행중일 수 있으므로 이에 대한 동기화 처리를
           // 진행합니다.
           //

           while (g_IRPEnterCount > 0)
           {
               // 현재 훅킹루틴이 실행중에 있으므로 잠시 대기합니다.
               KeDelayExecutionThread(KernelMode ,FALSE, &WaitTime);
           }
           // 마지막으로 한 번 더 대기합니다.
           KeDelayExecutionThread(KernelMode ,FALSE, &WaitTime);
       }
   }
}

NTSTATUS NewIrpHandler(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp)
{
    NTSTATUS ntStatus;

    // 동기화를 위한 전역 카운트를 증가시킵니다.
    InterlockedIncrement(&g_IRPEnterCount);

    // 디바이스 오브젝트에 대한 필터링을 하였지만 상황에 따라 하지 않아야 할 수도 있습니다.
    if (DeviceObject == g_HookDeviceObject)
    {
        // 우리가 원하는 DeviceObject에서 발생한 Irp입니다.
        PIO_STACK_LOCATION pIoStackLocation;

        pIoStackLocation = IoGetCurrentIrpStackLocation(Irp);
        if (pIoStackLocation->MajorFunction == g_HookMajorFunctionIndex)
        {
            //
            // 이곳에 원하는 코드를 작성합니다.
            // 예제코드에서는 간단히 CDB에 대해서 출력하겠습니다.
            //
            KdPrint(("DeviceObject : %p, Cdb : %#x\n", DeviceObject, pIoStackLocation->Parameters.Scsi.Srb->Cdb[0]));
        }
    }
    ntStatus = g_OrgHandler(DeviceObject, Irp);

    // 동기화를 위한 전역 카운트를 감소합니다.
    InterlockedDecrement(&g_IRPEnterCount);

    return (ntStatus);
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
{
   NTSTATUS ntStatus;
   PDEVICE_OBJECT DeviceObject;

   // 드라이버가 언로드 될 수 있도록 합니다.
   DriverObject->DriverUnload = DriverUnload;

   // 예제로 훅킹하는 디바이스는 하드 디스크입니다.
   // ( 실제 하드 디스크에 섹터를 읽어주는 디바이스입니다. )
   //
   // 해당 디바이스 이름은 시스템에 따라서 다릅니다.
   // IRP_MJ_SCSI 를 훅킹합니다.
   if (IrpHookFormName(L"\\Device\\Ide\\IdeDeviceP1T0L0-17", IRP_MJ_SCSI, &g_OrgHandler, NewIrpHandler) == TRUE)
   {
       KdPrint(("IrpHookFormName successed.\n"));
   }
   else
   {
       KdPrint(("IrpHookFormName failed.\n"));
   }

   return STATUS_SUCCESS;
}

tag : HOOK, IRPHOOK, DeviceDriver, IRP_MJ_SCSI