Cara melaksanakan peb dalam golang-Golang-php.cn

PEB (Blok Persekitaran Proses) ialah blok persekitaran proses, yang menyimpan banyak maklumat peringkat sistem, seperti alamat asas proses, pembolehubah persekitaran proses, parameter baris arahan proses , dsb. Dalam kernel Windows, PEB dilaksanakan sebagai struktur, yang boleh dibaca melalui API Asli Tidak Berdokumen (seperti ZwQueryInformationProcess) dalam Mod Kernel.

Dalam artikel ini, kami akan memperkenalkan cara melaksanakan pemapar PEB yang mudah menggunakan bahasa golang.

Langkah-langkah membaca PEB

Dapatkan pengendalian proses semasa.

Dalam golang, kita boleh menggunakan fungsi GetCurrentProcess dalam pakej syscall untuk mendapatkan pengendalian proses semasa.
```
handle, err := syscall.GetCurrentProcess()
if err != nil {
    fmt.Println("获取当前进程句柄失败：", err)
    return
}
defer syscall.CloseHandle(handle)
```
Salin selepas log masuk
Soal maklumat proses semasa, termasuk alamat PEB.

Dalam Windows, kami boleh menggunakan ZwQueryInformationProcess atau NtQueryInformationProcess untuk membaca maklumat proses. Walau bagaimanapun, API ini tidak didedahkan secara langsung dalam golang, jadi kami perlu menggunakan pakej yang tidak selamat untuk memanggil fungsi sistem.
```
var pbi PROCESS_BASIC_INFORMATION
var returnLength uint32
ntStatus := NtQueryInformationProcess(
    handle,
    PROCESS_BASIC_INFORMATION_CLASS,
    uintptr(unsafe.Pointer(&pbi)),
    uint32(unsafe.Sizeof(pbi)),
    uintptr(unsafe.Pointer(&returnLength)),
)
if ntStatus != STATUS_SUCCESS {
    fmt.Println("获取进程PEB信息失败：", ntStatus)
    return
}
```
Salin selepas log masuk
Dalam kod di atas, kami mentakrifkan struktur PROCESS_BASIC_INFORMATION untuk menyimpan maklumat proses yang dikembalikan oleh fungsi NtQueryInformationProcess. Kami memberitahu sistem maklumat yang perlu kami baca dengan menyatakan nilai penghitungan PROCESS_BASIC_INFORMATION_CLASS Apa yang kami perlukan di sini ialah maklumat PEB. Selain itu, kami juga perlu menyediakan penimbal untuk menyimpan maklumat yang dikembalikan dan saiz penimbal ini.

Untuk pelaksanaan khusus, sila rujuk projek ini [https://github.com/processhacker/phnt](https://github.com/processhacker/phnt), yang melaksanakan beberapa API sistem dan menyediakan Beberapa struktur data, seperti PROCESS_BASIC_INFORMATION.

Baca maklumat dalam struktur PEB.

PEB ialah struktur yang sangat penting yang menyimpan maklumat tentang banyak proses. Berikut ialah definisi PEB:

typedef struct _PEB {
    BOOLEAN InheritedAddressSpace;
    BOOLEAN ReadImageFileExecOptions;
    BOOLEAN BeingDebugged;
    BOOLEAN SpareBool;
    HANDLE Mutant;
    PVOID ImageBaseAddress;
    PPEB_LDR_DATA Ldr;
    PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
    PVOID SubSystemData;
    PVOID ProcessHeap;
    PRTL_CRITICAL_SECTION FastPebLock;
    PVOID AtlThunkSListPtr;
    PVOID IFEOKey;
    PVOID CrossProcessFlags;
    PVOID UserSharedInfoPtr;
    ULONG SystemReserved[1];
    ULONG AtlThunkSListPtr32;
    PVOID ApiSetMap;
} PEB, *PPEB;

Salin selepas log masuk

Kita boleh menggunakan pakej tidak selamat golang untuk membaca data ini. Sebagai contoh, kita boleh menggunakan kod berikut untuk membaca ImageBaseAddress PEB:

type PEB struct {
    InheritedAddressSpace    bool
    ReadImageFileExecOptions bool
    BeingDebugged            bool
    SpareBool                bool
    Mutant                   syscall.Handle
    ImageBaseAddress         uintptr
    Ldr                      *PEB_LDR_DATA
    ProcessParameters        *RTL_USER_PROCESS_PARAMETERS
    SubSystemData            uintptr
    ProcessHeap              uintptr
    FastPebLock              *RTL_CRITICAL_SECTION
    AtlThunkSListPtr         uintptr
    IFEOKey                  uintptr
    CrossProcessFlags        uintptr
    UserSharedInfoPtr        uintptr
    SystemReserved           [1]uint32
    AtlThunkSListPtr32       uintptr
    ApiSetMap                uintptr
}

func (p *PEB) GetImageBaseAddress() uintptr {
    return p.ImageBaseAddress
}

peb := (*PEB)(unsafe.Pointer(pbi.PebBaseAddress))
fmt.Printf("ImageBaseAddress: 0x%x\n", peb.GetImageBaseAddress())

Salin selepas log masuk

Dalam kod di atas, kita mula-mula mentakrifkan struktur PEB dan menentukan jenis untuk medan dalam struktur . Seterusnya, kami melaksanakan fungsi GetImageBaseAddress untuk mengembalikan medan ImageBaseAddress dalam PEB. Akhir sekali, kami membaca maklumat dalam PEB dengan menukar alamat asas PEB kepada jenis *PEB.

Baca maklumat modul proses.

Selepas mendapatkan ImageBaseAddress dalam PEB, kami boleh melintasi InMemoryOrderModuleList dalam PEB_LDR_DATA untuk mendapatkan semua maklumat modul yang dimuatkan dalam proses.

typedef struct _LDR_DATA_TABLE_ENTRY {
    LIST_ENTRY InLoadOrderLinks;
    LIST_ENTRY InMemoryOrderLinks;
    LIST_ENTRY InInitializationOrderLinks;
    PVOID DllBase;
    PVOID EntryPoint;
    ULONG SizeOfImage;
    UNICODE_STRING FullDllName;
    UNICODE_STRING BaseDllName;
    ULONG Flags;
    USHORT LoadCount;
    USHORT TlsIndex;
    union {
        LIST_ENTRY HashLinks;
        struct {
            PVOID SectionPointer;
            ULONG CheckSum;
        };
    };
    union {
        ULONG TimeDateStamp;
        struct {
            PVOID LoadedImports;
            PVOID EntryPointActivationContext;
        };
    };
} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;

typedef struct _PEB_LDR_DATA {
    ULONG Length;
    BOOLEAN Initialized;
    HANDLE SsHandle;
    LIST_ENTRY InLoadOrderModuleList;
    LIST_ENTRY InMemoryOrderModuleList;
    LIST_ENTRY InInitializationOrderModuleList;
    PVOID EntryInProgress;
    BOOLEAN ShutdownInProgress;
    HANDLE ShutdownThreadId;
} PEB_LDR_DATA, *PPEB_LDR_DATA;

Salin selepas log masuk

Kami boleh menggunakan kod berikut untuk merentasi maklumat modul:

type LDR_DATA_TABLE_ENTRY struct {
    InLoadOrderLinks            LIST_ENTRY
    InMemoryOrderLinks          LIST_ENTRY
    InInitializationOrderLinks  LIST_ENTRY
    DllBase                     uintptr
    EntryPoint                  uintptr
    SizeOfImage                 uint32
    FullDllName                 UNICODE_STRING
    BaseDllName                 UNICODE_STRING
    Flags                       uint32
    LoadCount                   uint16
    TlsIndex                    uint16
    HashLinks                   LIST_ENTRY
    TimeDateStamp               uint32
}

type PEB_LDR_DATA struct {
    Length                             uint32
    Initialized                        bool
    SsHandle                           syscall.Handle
    InLoadOrderModuleList              LIST_ENTRY
    InMemoryOrderModuleList            LIST_ENTRY
    InInitializationOrderModuleList    LIST_ENTRY
}

pebLdrData := (*PEB_LDR_DATA)(unsafe.Pointer(peb.Ldr))
moduleList := (*LIST_ENTRY)(unsafe.Pointer(&pebLdrData.InMemoryOrderModuleList))

for moduleList.Flink != uintptr(unsafe.Pointer(&pebLdrData.InMemoryOrderModuleList)) {
    ldrDataTableEntry := (*LDR_DATA_TABLE_ENTRY)(unsafe.Pointer(moduleList.Flink))
    moduleName := WcharPtrToString(ldrDataTableEntry.BaseDllName.Buffer, uint32(ldrDataTableEntry.BaseDllName.Length/2))
    moduleBase := ldrDataTableEntry.DllBase
    moduleSize := ldrDataTableEntry.SizeOfImage
    moduleEntry := ldrDataTableEntry.EntryPoint
    moduleList = (*LIST_ENTRY)(unsafe.Pointer(moduleList.Flink))
    fmt.Printf("模块名称：%s，基地址：%x，大小：%x，入口点：%x\n", moduleName, moduleBase, moduleSize, moduleEntry)
}

Salin selepas log masuk

Dalam kod di atas, kami mula-mula mentakrifkan struktur LDR_DATA_TABLE_ENTRY untuk menyimpan maklumat modul . Kemudian kami mentakrifkan struktur PEB_LDR_DATA dan menukar penunjuk peb.Ldr kepada penunjuk struktur ini. Akhir sekali, kami melintasi senarai InMemoryOrderModuleList dan membaca setiap modul.

Selepas mendapatkan alamat asas modul, kita boleh menggunakan fungsi ReadProcessMemory untuk membaca data dalam modul. Untuk pelaksanaan khusus, sila rujuk projek ini [https://github.com/AllenDang/w32/blob/master/process_windows.go](https://github.com/AllenDang/w32/blob/master/process_windows.go ), Ia melaksanakan fungsi untuk membaca data daripada proses.

Namun, perlu diingatkan bahawa jika proses yang ingin kita perolehi adalah proses lain, maka kita perlu menentukan kebenaran capaian proses tersebut apabila membaca data proses. Dalam golang, kita boleh menggunakan fungsi CreateToolhelp32Snapshot untuk mendapatkan senarai semua proses dan menentukan kebenaran akses tertentu apabila mendapatkan pemegang proses.

const (
    PROCESS_QUERY_INFORMATION     = 0x0400
    PROCESS_VM_READ               = 0x0010
    PROCESS_VM_WRITE              = 0x0020
    PROCESS_VM_OPERATION          = 0x0008
    PROCESS_CREATE_THREAD         = 0x0002
    PROCESS_CREATE_PROCESS        = 0x0080
    PROCESS_TERMINATE             = 0x0001
    PROCESS_ALL_ACCESS            = 0x1F0FFF
    TH32CS_SNAPPROCESS            = 0x00000002
)

func openProcess(pid uint32) (handle syscall.Handle, err error) {
    handle, err = syscall.OpenProcess(PROCESS_VM_READ|PROCESS_QUERY_INFORMATION|PROCESS_VM_WRITE, false, pid)
    return
}

func main() {
    snapshot := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
    defer syscall.CloseHandle(snapshot)

    var procEntry PROCESSENTRY32
    procEntry.Size = uint32(unsafe.Sizeof(procEntry))

    var (
        handle syscall.Handle
        err error
    )

    if Process32First(snapshot, &procEntry) {
        for {
            if strings.EqualFold(strings.ToLower(WcharPtrToString(procEntry.ExeFile[:])), "notepad.exe") {
                fmt.Printf("找到 notepad 进程，pid：%d\n", procEntry.ProcessID)
                handle, err = openProcess(procEntry.ProcessID)
                if err != nil {
                    fmt.Println("打开进程失败:", err)
                }
            }

            if !Process32Next(snapshot, &procEntry) {
                break
            }
        }
    }
}

Salin selepas log masuk

Kesimpulan

Artikel ini memperkenalkan cara menggunakan bahasa golang untuk melaksanakan pemapar PEB yang mudah. PEB ialah blok persekitaran proses, yang dilaksanakan sebagai struktur dalam kernel Windows, yang menyimpan banyak maklumat peringkat sistem. Dengan menggunakan pakej golang yang tidak selamat, kita boleh membaca maklumat PEB dan maklumat modul proses tersebut. Walau bagaimanapun, perlu diingat bahawa apabila membaca maklumat PEB dan maklumat modul proses lain, anda perlu menentukan kebenaran akses.

Atas ialah kandungan terperinci Cara melaksanakan peb dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!