Programming world

//
// Executive Process (EPROCESS)
//
typedef struct _EPROCESS
{
    KPROCESS Pcb;
    EX_PUSH_LOCK ProcessLock;
    LARGE_INTEGER CreateTime;
    LARGE_INTEGER ExitTime;
    EX_RUNDOWN_REF RundownProtect;
    HANDLE UniqueProcessId;
    LIST_ENTRY ActiveProcessLinks;
    ULONG QuotaUsage[3];
    ULONG QuotaPeak[3];
    ULONG CommitCharge;
    ULONG PeakVirtualSize;
    ULONG VirtualSize;
    LIST_ENTRY SessionProcessLinks;
    PVOID DebugPort;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
    union
    {
        PVOID ExceptionPortData;
        ULONG ExceptionPortValue;
        UCHAR ExceptionPortState:3;
    };
#else
    PVOID ExceptionPort;
#endif
    PHANDLE_TABLE ObjectTable;
    EX_FAST_REF Token;
    ULONG WorkingSetPage;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
    EX_PUSH_LOCK AddressCreationLock;
    PETHREAD RotateInProgress;
#else
    FAST_MUTEX AddressCreationLock;

// FIXME: FAST_MUTEX for XP, KGUARDED_MUTEX for 2K3
    KSPIN_LOCK HyperSpaceLock;
#endif
    PETHREAD ForkInProgress;
    ULONG HardwareTrigger;
    MM_AVL_TABLE PhysicalVadroot;
    PVOID CloneRoot;
    ULONG NumberOfPrivatePages;
    ULONG NumberOfLockedPages;
    PVOID *Win32Process;
    struct _EJOB *Job;
    PVOID SectionObject;
    PVOID SectionBaseAddress;
    PEPROCESS_QUOTA_BLOCK QuotaBlock;
    PPAGEFAULT_HISTORY WorkingSetWatch;
    PVOID Win32WindowStation;
    HANDLE InheritedFromUniqueProcessId;
    PVOID LdtInformation;
    PVOID VadFreeHint;
    PVOID VdmObjects;
    PVOID DeviceMap;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
    ULONG AlpcPagedPoolQuotaCache;
    PVOID EtwDataSource;
    PVOID FreeTebHint;
#else
    PVOID Spare0[3];
#endif
    union
    {
        HARDWARE_PTE_X86 PagedirectoryPte;
        ULONGLONG Filler;
    };
    ULONG Session;
    CHAR ImageFileName[16];
    LIST_ENTRY JobLinks;
    PVOID LockedPagesList;
    LIST_ENTRY ThreadListHead;
    PVOID SecurityPort;
    PVOID PaeTop;
    ULONG ActiveThreads;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
    ULONG ImagePathHash;
#else
    ACCESS_MASK GrantedAccess;
#endif
    ULONG DefaultHardErrorProcessing;
    NTSTATUS LastThreadExitStatus;
    struct _PEB* Peb;
    EX_FAST_REF PrefetchTrace;
    LARGE_INTEGER ReadOperationCount;
    LARGE_INTEGER WriteOperationCount;
    LARGE_INTEGER OtherOperationCount;
    LARGE_INTEGER ReadTransferCount;
    LARGE_INTEGER WriteTransferCount;
    LARGE_INTEGER OtherTransferCount;
    ULONG CommitChargeLimit;
    ULONG CommitChargePeak;
    PVOID AweInfo;
    SE_AUDIT_PROCESS_CREATION_INFO SeAuditProcessCreationInfo;
    MMSUPPORT Vm;
    LIST_ENTRY MmProcessLinks;
    ULONG ModifiedPageCount;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
    union
    {
        struct
        {
            ULONG JobNotReallyActive:1;
            ULONG AccountingFolded:1;
            ULONG NewProcessReported:1;
            ULONG ExitProcessReported:1;
            ULONG ReportCommitChanges:1;
            ULONG LastReportMemory:1;
            ULONG ReportPhysicalPageChanges:1;
            ULONG HandleTableRundown:1;
            ULONG NeedsHandleRundown:1;
            ULONG RefTraceEnabled:1;
            ULONG NumaAware:1;
            ULONG ProtectedProcess:1;
            ULONG DefaultPagePriority:3;
            ULONG ProcessDeleteSelf:1;
            ULONG ProcessVerifierTarget:1;
        };
        ULONG Flags2;
    };
#else
    ULONG JobStatus;
#endif
    union
    {
        struct
        {
            ULONG CreateReported:1;
            ULONG NoDebugInherit:1;
            ULONG ProcessExiting:1;
            ULONG ProcessDelete:1;
            ULONG Wow64SplitPages:1;
            ULONG VmDeleted:1;
            ULONG OutswapEnabled:1;
            ULONG Outswapped:1;
            ULONG ForkFailed:1;
            ULONG Wow64VaSpace4Gb:1;
            ULONG AddressSpaceInitialized:2;
            ULONG SetTimerResolution:1;
            ULONG BreakOnTermination:1;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
            ULONG DeprioritizeViews:1;
#else
            ULONG SessionCreationUnderway:1;
#endif
            ULONG WriteWatch:1;
            ULONG ProcessInSession:1;
            ULONG OverrideAddressSpace:1;
            ULONG HasAddressSpace:1;
            ULONG LaunchPrefetched:1;
            ULONG InjectInpageErrors:1;
            ULONG VmTopDown:1;
            ULONG ImageNotifyDone:1;
            ULONG PdeUpdateNeeded:1;
            ULONG VdmAllowed:1;
            ULONG SmapAllowed:1;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
            ULONG ProcessInserted:1;
#else
            ULONG CreateFailed:1;
#endif
            ULONG DefaultIoPriority:3;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
            ULONG SparePsFlags1:2;
#else
            ULONG Spare1:1;
            ULONG Spare2:1;
#endif
        };
        ULONG Flags;
    };
    NTSTATUS ExitStatus;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
    USHORT Spare7;
#else
    USHORT NextPageColor;
#endif
    union
    {
        struct
        {
            UCHAR SubSystemMinorVersion;
            UCHAR SubSystemMajorVersion;
        };
        USHORT SubSystemVersion;
    };
    UCHAR PriorityClass;
    MM_AVL_TABLE VadRoot;
    ULONG Cookie;
} EPROCESS, *PEPROCESS;

Documented By :

ReactOS

P.S : 이 EPROCESS 구조체는 Windows 버전에 따라서 호환이 될수도 있고, 안될수도 있습니다

Driver를 작성하면서, 때때로, 후킹을 한다거나 할 때에도 EPROCESS, ETHREAD 구조체에서 얻고자 하는 값의 오프셋이 필요할 때가 있습니다.

이것은 Windows버전마다 EPROCESS, ETHREAD의 구조가 다를뿐만 아니라, EPROCESS, ETHREAD 구조체가 ntddk 헤더에 정의되어있지 않기 때문이기도 합니다.

때문에 값을 얻어오기 위해 오프셋을 알아야 하는데,

저같은 경우는 후킹을 위해서 EPROCESS 구조체의 ImageFileName, UniqueProcessId 오프셋이 필요하고,

ETHREAD에서는 ClientId 오프셋이 필요합니다.

UniqueProcessId인 경우는 그냥 PsGetProcessId()를 이용하면 쉽게 구할 수 있습니다.

하지만 굳이 UniqueProcessId의 오프셋을 구하고 싶다면, 아래와 같이 하면 됩니다.

LONG

NTAPI

GetProcessIdOffset()

{

        PEPROCESS CurrentProcess=PsGetCurrentProcess();

        HANDLE CurrentProcessId=PsGetCurrentProcessId();

        ULONG Offset=0;

        for(Offset=0;Offset<PAGE_SIZE*4;Offset++)

        {

                if(*(PHANDLE)((char *)CurrentProcess+Offset)==CurrentProcessId))

                {

                         return Offset;

                }

        }

        return -1;

}

그리고 UniqueProcessId값을 굳이 구하고 싶다면, 위에 함수를 연결시켜서 아래와 같이 하면 되겠죠?

HANDLE

NTAPI

PsGetProcessId(

        IN PEPROCESS Process)

{

        LONG Offset=GetProcessIdOffset();

        if(Offset!=-1)

        {

                return Process ? *(PHANDLE)((char *)Process+Offset) : NULL;

        }

        return NULL;

}

그리하여 오프셋을 얻어오면 값을 구할 수 있지만,

하지만 오프셋 역시 Windows 버전마다 틀리므로 PsGetVersion() 또는 RtlGetVersion()을 이용하여 OS Version을 구해와서 OS별로 Switch-Case문으로 값을 넣어줘야 합니다.

하지만, 몇몇 오프셋은 일정한 값으로 구해올 수 있습니다.

그 예가 아래에 있습니다.

LONG GetProcessImageFileNameOffset()

{

       ULONG Offset=0;

       PEPROCESS CurrentProcess=PsGetCurrentProcess();

       for(Offset=0;Offset<PAGE_SIZE*4;Offset++)

       {

               if(!strncmp((char *)((char *)CurrentProcess+Offset), "System", 6))

               {

                      return Offset;

               }

       }

       return -1;

}

이 함수는 프로세스 이미지 파일 이름(ImageFileName)의 오프셋을 구해오는 함수입니다.

하지만, 이 함수의 한계점은 DriverEntry()에서만 호출해야 정상적으로 작동할 수 있다는 것입니다.

그 이유는, DriverEntry()는 "System" 이라는 이름을 가진 프로세스가 호출하기 때문입니다.

이 함수를 어디에서 호출하던간에, 알맞게 동작하도록 바꿔 보았습니다.

__declspec(dllimport) PEPROCESS PsInitialSystemProcess;

LONG GetProcessImageFileNameOffset()

{

       ULONG Offset=0;

       /*We used PsGetCurrentProcess(), but now, use PsInitialSystemProcess.*/

       PEPROCESS SystemProcess=PsInitialSystemProcess;

       for(Offset=0;Offset<PAGE_SIZE*4;Offset++)

       {

               if(!strncmp((char *)((char *)SystemProcess+Offset), "System", 6))

               {

                      return Offset;

               }

       }

       return -1;

}

전에는 PsGetCurrentProcess()를 사용하여 그것을 DriverEntry()에서 호출하였으나,

이제는 System Process의 프로세스 객체 포인터(PEPROCESS)를 Import해서 씁니다.

ntoskrnl.exe에 export 되어 있습니다.

그리고, 제가 PsGetThreadClientId() 를 직접 구현해 보았습니다.

이 함수는 ETHREAD 구조체의 ClientId의 오프셋을 구해온 후, CLIENT_ID 구조체의 포인터를 리턴해주는 기능을 가지고 있습니다.

//이 함수는 Win2000에서 테스트 되었습니다~

PCLIENT_ID

NTAPI

PsGetThreadClientId(

       IN PETHREAD Thread)

{

        HANDLE CurrentProcessId=PsGetCurrentProcessId();

        HANDLE CurrentThreadId=PsGetCurrentThreadId();

        PETHREAD CurrentThread=PsGetCurrentThread();

        ULONG Offset=0;

        PCLIENT_ID ClientId;

        //오프셋을 증가시켜가면서 값을 찾는다

        for(Offset=0;Offset<PAGE_SIZE*4;Offset++)

        {

                 ClientId=(CLIENT_ID *)((char *)CurrentThread+Offset);

                 //ClientId->UniqueProcess : Owner Process Id

                 //ClientId->UniqueThread : Thread Id

                 if(ClientId->UniqueProcess==CurrentProcessId &&

                           ClientId->UniqueThread==CurrentThreadId)

                 {

                          DbgPrint("Found Offset at 0x%X", Offset);

                          //찾았다!

                          if(Thread)

                          {

                                  return (CLIENT_ID *)((char *)Thread+Offset);

                          }

                          break;

                 }

        }

        return NULL;

}

인자값이(PEPROCESS) 올바른가 알아보기

인자값이(PEPROCESS) 올바른가 알아보려면

ObReferenceObjectByPointer()를 이용해서

리턴값을 얻어서

NT_SUCCESS(리턴값)==1이면 올바른 프로세스 객체인거고,

0인 경우에는 리턴값에 따라서 잘못된 값인지, 엑세스가 거부되었는지 등등의 자세한 상태를 알 수 있습니다.

제가 ActiveProcessLinks의 오프셋을 어떻게하면 구할수 있을까 생각하다가

아주 좋은 방법이 떠올랐습니다 +_+

EPROCESS 구조체의 정보를 보면서 하나하나 알아보죠 ㅇ_ㅇ

다음은 각 Windows별로 EPROCESS 구조체 정보를 생략한 것입니다.

(※이 구조체 정보는 타사이트서 퍼왔습니다)

이 방법은 최소한(?) 다음 Windows에서 성공적으로 동작합니다:

Windows 2000 SP4

Windows XP SP2

Windows Server 2003 No SP

우선 Windows 2000부터 봅시다.

Windows 2000 SP4

   +0x000 Pcb              : _KPROCESS
   +0x06c ExitStatus       : Int4B
   +0x070 LockEvent        : _KEVENT
   +0x080 LockCount        : Uint4B
   +0x088 CreateTime       : _LARGE_INTEGER
   +0x090 ExitTime         : _LARGE_INTEGER
   +0x098 LockOwner        : Ptr32 _KTHREAD
   +0x09c UniqueProcessId  : Ptr32 Void
   +0x0a0 ActiveProcessLinks : _LIST_ENTRY ---->ActiveProcessLinks
   +0x0a8 QuotaPeakPoolUsage : [2] Uint4B
ActiveProcessLinks의 오프셋은 0x0a0.

UniqueProcessId과 QuotaPeakPoolUsage 사이에 위치해 있군요.

다음은 Windows XP SP2......

Windows XP SP2

   +0x000 Pcb              : _KPROCESS
   +0x06c ProcessLock      : _EX_PUSH_LOCK
   +0x070 CreateTime       : _LARGE_INTEGER
   +0x078 ExitTime         : _LARGE_INTEGER
   +0x080 RundownProtect   : _EX_RUNDOWN_REF
   +0x084 UniqueProcessId  : Ptr32 Void
   +0x088 ActiveProcessLinks : _LIST_ENTRY ---->ActiveProcessLinks
   +0x090 QuotaUsage       : [3] Uint4B
ActiveProcessLinks의 오프셋은 0x088.

UniqueProcessId과 QuotaUsage 사이에 위치해 있군요.

이번에는 Windows Server 2003 No SP

Windows Server 2003 No SP

   +0x000 Pcb              : _KPROCESS
   +0x06c ProcessLock      : _EX_PUSH_LOCK
   +0x070 CreateTime       : _LARGE_INTEGER
   +0x078 ExitTime         : _LARGE_INTEGER
   +0x080 RundownProtect   : _EX_RUNDOWN_REF
   +0x084 UniqueProcessId  : Ptr32 Void
   +0x088 ActiveProcessLinks : _LIST_ENTRY ---->ActiveProcessLinks
   +0x090 QuotaUsage       : [3] Uint4B
ActiveProcessLinks의 오프셋은 0x088.

UniqueProcessId과 QuotaUsage 사이에 위치해 있군요.

마지막으로, Windows Server 2003 SP1을 알아봅시다.

Windows Server 2003 SP1

   +0x000 Pcb              : _KPROCESS
   +0x078 ProcessLock      : _EX_PUSH_LOCK
   +0x080 CreateTime       : _LARGE_INTEGER
   +0x088 ExitTime         : _LARGE_INTEGER
   +0x090 RundownProtect   : _EX_RUNDOWN_REF
   +0x094 UniqueProcessId  : Ptr32 Void
   +0x098 ActiveProcessLinks : _LIST_ENTRY ---->ActiveProcessLinks
   +0x0a0 QuotaUsage       : [3] Uint4B
ActiveProcessLinks의 오프셋은 0x098.

UniqueProcessId과 QuotaUsage 사이에 위치해 있군요.

그런데, 위에서 자세히 보면 ActiveProcessLinks의 오프셋은, UniqueProcessId+4 라는것을 알수가 있군요 +_+

실제로 구해 볼까요?

Windows 2000 SP4 : 0x09c+0x004=0x0a0

Windows XP SP2 : 0x084+0x004=0x088

Windows Server 2003 No SP : 0x084+0x004=0x088(Windows XP SP2와 동일)

Windows Server 2003 SP1 : 0x094+0x004=0x098

결과적으로,

ActiveProcessLinks Offset = UniqueProcessId Offset + 4

ActiveProcessLinks=(PLIST_ENTRY)((char *)EPROCESS 구조체 포인터+UniqueProcessId Offset+4)

음......

과연 다른 운영체제에서는 잘 동작하는지 궁금하네요 +_+

전에 구현한 PsGetNextProcess()를 이용해서 PsLookupProcessByProcessId()를 구현해 보았습니다.

원래는 PsGetFirstProcess()를 쓰려 했으나, 그냥 PsInitialSystemProcess를 넣어주면 될것 같아서 그냥

PsInitialSystemProcess를 썼습니다.

원함수의 원형은 이와 같습니다.

NTKERNELAPI

NTSTATUS

NTAPI

PsLookupProcessByProcessId(

       IN HANDLE ProcessId,               //프로세스 아이디

       OUT PEPROCESS *Process       //성공했을 때에는 여기로 EPROCESS 구조체의 포인터가 넘어온다

       );

제가 만든 함수의 코드는 이렇습니다.

NTSTATUS
NTAPI
PsLookupProcessByProcessId(
       IN HANDLE ProcessId,
       OUT PEPROCESS *Process)
{

       /*Get System Process Object*/
       PEPROCESS NextProcess=PsInitialSystemProcess;
       NTSTATUS Status=STATUS_SUCCESS;

       /*Unexpected Situation! PsInitialSystemProcess==NULL????*/
       if(!NextProcess) return STATUS_UNSUCCESSFUL;
       if(!Process) return STATUS_INVALID_PARAMETER;

       /*Loop and find target Process*/
       while(NT_SUCCESS(Status))
       {

              /*Check if Process is target Proces*/
              if(ProcessId==PsGetProcessId(NextProcess))
              {

                     /*Reference the Object*/
                     Status=ObReferenceObjectByPointer(
                            NextProcess,
                            PROCESS_ALL_ACCESS,
                            PsProcessType,
                            KernelMode);

                     /*Is Object Valid?*/
                     if(NT_SUCCESS(Status))
                     {

                            /*Found it! Now, Save the Pointer.....*/
                            *Process=NextProcess;
                     }

                     /*return it*/
                     return Status;
              }

              /*Get Next Process*/
              Status=PsGetNextProcess(&NextProcess);
       }

       /*Process Not Found*/
       return STATUS_NOT_FOUND;
}

이 함수들은 제가 직접 작성한 것으로, 현재 떠 있는 프로세스를 구할 수 있습니다.

PsGetFirstProcess()

Idle Process를 제외한 가장 첫번째 프로세스의 EPROCESS 구조체의 포인터를 구합니다.

성공시 STATUS_SUCCESS를 리턴,

실패시 STATUS_NOT_FOUND, STATUS_INVALID_PARAMETER를 리턴.

구현은 했지만, 그다지 필요한 것 같지는 않네요(그럼 왜 구현한 거지 ㅡ.ㅡ)

PsGetNextProcess()

이 함수의 원형은

PEPROCESS

PsGetNextProcess(

       IN PEPROCESS Process);

라고 합니다.

(하지만, 제가 임의로 바꾸었습니다.)

인자로 들어온 EPROCESS 구조체의 포인터에서 ActiveProcessLinks를 얻어와 다음 프로세스의 EPROCESS 구조체의 포인터를 구합니다.

성공시 STATUS_SUCCESS를 리턴,

실패시 STATUS_UNSUCCESSFUL, STATUS_NOT_FOUND, STATUS_INVALID_PARAMETER를 리턴.

이 함수는 다음 Windows에서 성공적으로 테스트되었습니다:

Windows 2000 Professional SP4

NTSTATUS
NTAPI
PsGetFirstProcess(
        OUT PEPROCESS *FirstProcess)
{
        if(!FirstProcess) return STATUS_INVALID_PARAMETER;
        *FirstProcess=PsInitialSystemProcess;

        /*PsInitialSystemProcess=System Process Object*/
        if(!*FirstProcess) return STATUS_NOT_FOUND;

        /*Success, return it*/
        return STATUS_SUCCESS;
}

솔직히, PsGetFirstProcess()는 위의 코드대로라면 PsInitialSystemProcess로 대체시킬 수 있습니다.

단순히 값을 얻어온 후 검사하고 리턴하는 기능만 하기 때문이죠.

NTSTATUS
NTAPI
PsGetNextProcess(
        IN OUT PEPROCESS *NextProcess)
{
        ULONG ActiveProcessLinksOffset=0, ProcessIdOffset=0;
        BOOLEAN bFound=FALSE;
        PLIST_ENTRY ActiveProcessLinks;
        PEPROCESS Process;
        PEPROCESS CurrentProcess=PsGetCurrentProcess();
        HANDLE CurrentProcessId=PsGetCurrentProcessId();

        /*PsInitialSystemProcess is System Process' Process Object.*/

        HANDLE SystemProcessId=PsGetProcessId(PsInitialSystemProcess);
        if(!NextProcess) return STATUS_INVALID_PARAMETER;

        /*Reference the Object*/

        Status=ObReferenceObjectByPointer(*NextProcess, PROCESS_ALL_ACCESS,
                  PsProcessType, KernelMode);

        /*invalid EPROCESS structure Pointer, return it*/
        if(!NT_SUCCESS(Status)) return Status;
        /*Get ProcessId Offset*/

        for(ProcessIdOffset=0;ProcessIdOffset<PAGE_SIZE*4;ProcessIdOffset++)
        {
                if(*(PHANDLE)((PCHAR)CurrentProcess+ProcessIdOffset)==CurrentProcessId)
                {
                        bFound=TRUE;
                        break;
                }
        }
        if(!bFound)
        {

                /*Cannot find ProcessId Offset, return status*/
                return STATUS_UNSUCCESSFUL;
        }
        /*ActiveProcessLinks Offset=UniqueProcessId Offset+4*/
        ActiveProcessLinksOffset=ProcessIdOffset+4;
        /*Get ActiveProcessLinks*/

        ActiveProcessLinks=(PLIST_ENTRY)((char *)*NextProcess+ActiveProcessLinksOffset);

        /*Move to Next Process*/
        Process=(PEPROCESS)ActiveProcessLinks->Flink;
        Process=(PEPROCESS)((char *)Process-ActiveProcessLinksOffset);
        /*(PEPROCESS)Process!=null*/

        if(Process)
        {
                if(SystemProcessId!=PsGetProcessId(Process))
                {

                        /*Found it! Now, Dereference the Object*/

                        ObDereferenceObject(*NextProcess);

                        /*Save the EPROCESS Pointer*/
                        *NextProcess=Process;

                        /*return success......*/
                        return STATUS_SUCCESS;
                }
        }

        /*End of Process, or Process not found*/
        return STATUS_NOT_FOUND;
}

위의 함수들은 ActiveProcessLinks로 다음 프로세스를 찾아 이동하므로,

ActiveProcessLinks를 Unlink한다면 Unlink된 프로세스의 EPROCESS는 구할 수 없지만,

ZwQuerySystemInformation() 후킹으로 인한 숨겨진 프로세스는 찾아낼 수 있습니다.

다음에는, 이를 이용한 PsLookupProcessByProcessId() 구현에 대해 올려놓겠습니다.

ZwCreateFile()....여러모로 쓸모있는 함수입니다.

파일 핸들을 얻어올 때, 파일을 생성할 때, 파일을 이동할 때, 파일을 삭제할 때 등등 여러모로 쓰이는 유용한 함수인데.....

(파일 삭제할때도 쓰이는줄은 몰랐었다)

원형을 보면

NTKERNELAPI

NTSTATUS
NTAPI
ZwCreateFile(
      OUT PHANDLE FileHandle,
      IN ACCESS_MASK DesiredAccess,
      IN POBJECT_ATTRIBUTES ObjectAttributes,
      OUT PIO_STATUS_BLOCK IoStatusBlock,
      IN PLARGE_INTEGER AllocationSize OPTIONAL,
      IN ULONG FileAttributes,
      IN ULONG ShareAccess,
      IN ULONG CreateDisposition,
      IN ULONG CreateOptions,
      IN PVOID EaBuffer OPTIONAL,
      IN ULONG EaLength);

......이렇습니다.

그러나!

이렇게 인자가 많은 반면, 실질적으로 이 함수가 하는 일은 단순히 NewAPI인 IoCreateFile()을 호출하는 역할만 한다는거.....!

(원래 이 일은 ZwCreateFile가 아닌 NtCreateFile이 한다)

직접 구현해 보면 이렇습니다.

NTSTATUS
NTAPI
ZwCreateFile(
    OUT PHANDLE FileHandle,
    IN ACCESS_MASK DesiredAccess,
    IN POBJECT_ATTRIBUTES ObjectAttributes,
    OUT PIO_STATUS_BLOCK IoStatusBlock,
    IN PLARGE_INTEGER AllocationSize OPTIONAL,
    IN ULONG FileAttributes,
    IN ULONG ShareAccess,
    IN ULONG CreateDisposition,
    IN ULONG CreateOptions,
    IN PVOID EaBuffer OPTIONAL,
    IN ULONG EaLength)
{
      return IoCreateFile(
            FileHandle,
            DesiredAccess,
            ObjectAttributes,
            IoStatusBlock,
            AllocationSize,
            FileAttributes,
            ShareAccess,
            CreateDisposition,
            CreateOptions,
            EaBuffer,
            EaLength,
            CreateFileTypeNone,
            NULL,
            0);

}

Documented By :

ReactOS

실제로, 제가 ZwCreateFile()을 후킹해서 위와 같은 함수주소로 바꿔치기하여 성공적으로 작동하는지 시도해 본 결과,

성공적으로 잘 되었습니다.

후킹할 때, IoCreateFile()이 후킹되지 않았다면, ZwCreateFile()의 원래 함수를 호출하는 대신, IoCreateFile()을 호출하면 되겠군요!

복구시에는 저장했던 함수의 주소로 다시 바꿔치면......

Windows에서 프로세스를 다루기 위해서는, 대부분 프로세스 핸들을 얻어 와야 합니다.

핸들을 얻기 위해 사용되는 함수는 OpenProcess()이며, Kernel32.dll에 Export되어 있습니다.

하지만, OpenProcess()는 ntdll.dll의 NtOpenProcess()를 호출하고, NtOpenProcess()는 실질적으로

ntoskrnl.exe의 ZwOpenProcess()를 호출합니다.

이러한 ZwXxx 함수들은 대개 ntdll.dll의 NtXxx 함수들이 결과적으로 호출하게 되는 실질적인 함수인데,

이번에는 ZwOpenProcess()에 대해서만 알아보고, 구현해봅시다.

ZwOpenProcess()는 DDK 헤더 파일에 정의되어 있지 않습니다.(NtOpenProcess()는 정의되어 있는것 같다)

함수의 원형은 다음과 같습니다.

NTKERNELAPI

NTSTATUS

NTAPI

ZwOpenProcess(

      OUT PHANDLE ProcessHandle,                          //성공했을 시 여기로 프로세스 핸들이 넘어온다

      IN ACCESS_MASK DesiredAccess,                    //프로세스를 어떤 권한으로 열 것인가??

      IN POBJECT_ATTRIBUTES ObjectAttributes,         //핸들 상속 권한, 프로세스 이름(ObjectAttributes->ObjectName)

      IN PCLIENT_ID ClientId OPTIONAL);                    //ClientId->UniqueProcess에 프로세스 아이디를 넣으면 된다

이제 원형과 인자들에 대해서 대충 알아보았으니, ZwOpenProcess()가 어떻게 핸들을 얻어오는지 알아봅시다.

ZwOpenProcess()는 일단 SeCreateAccessState()를 호출해서 AccessState를 얻어온 후, 디버그 권한이 있는지를 확인하여 디버그 권한이 있을 경우, AccessState에 추가 권한을 부여합니다.

ObjectAttributes->ObjectName이 NULL 스트링이 아닌 경우, ObOpenObjectByName()을 이용하여 프로세스 핸들을 얻어옵니다.

다른 경우에는(ClientId->UniqueProcess가 유효한 경우) PsLookupProcessByProcessId()를 이용하여 프로세스가 존재하는지를 파악하고, 프로세스 객체를 얻습니다. 그리고 프로세스 객체는 ObOpenObjectByPointer()를 호출하는데에 쓰이게 됩니다.

결과적으로, ObOpenObjectByName()이나 ObOpenObjectByPointer()를 이용하여 얻어온 핸들은 ProcessHandle에 넘겨지게 됩니다.

이제 ZwOpenProcess()가 어떻게 프로세스 핸들을 얻어 오느냐를 알았으니, 간단히 구현해봅시다.

(참고로, 엑세스 권한 확인은 뺐습니다)

NTSTATUS
NTAPI
ZwOpenProcess(
 OUT PHANDLE ProcessHandle,
 IN ACCESS_MASK DesiredAccess,
 IN POBJECT_ATTRIBUTES ObjectAttributes,
 IN PCLIENT_ID ClientId OPTIONAL)
{
 KPROCESSOR_MODE PreviousMode=KeGetPreviousMode();
 NTSTATUS Status=STATUS_SUCCESS;
 PEPROCESS Process;
 if(!ProcessHandle) return STATUS_INVALID_PARAMETER_1;

 /*Unexpected Situation! Has ProcessId And ObjectName*/
 if(ClientId && ObjectAttributes->ObjectName!=NULL)
  return STATUS_INVALID_PARAMETER_MIX;
 if(ClientId)
 {

  /*Is Process Valid?*/
  Status=PsLookupProcessByProcessId(ClientId->UniqueProcess, &Process);
  if(NT_SUCCESS(Status))
  {

   /*OK, Now Get Process Handle By Pointer(EPROCESS *)*/
   Status=ObOpenObjectByPointer(Process, ObjectAttributes->Attributes, NULL, 0, PsProcessType, PreviousMode, ProcessHandle);
  }

  /*Return Status*/
  return Status;
 }
 else if(ObjectAttributes->ObjectName!=NULL)
 {

  /*Get Process Handle By Process Name*/
  Status=ObOpenObjectByName(ObjectAttributes, PsProcessType, PreviousMode, NULL, 0, NULL, ProcessHandle);

  /*Return Status*/
  return Status;
 }

 /*Both Process Id And Object Name is Invalid, Return NtCurrentProcess().*/
 *ProcessHandle=(HANDLE)0xffffffff;

 /*Return Success*/
 return STATUS_SUCCESS;
}

p.s : 테스트는 아직 못해봤습니다

제가 시도해 봤던 방법인데 너무 힘들었습니다;

약간 말이 안되는 방법일 수도 있지만

그런대로 Win2000, WinXP, Win2003 다 잘 구해지더군요

주소도 알맞고......

이제부터 그 방법을 알아보도록 하죠.

우선 밑의 스샷을 봅시다.