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.
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)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
}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;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())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;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)
}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
}
}
}
}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!
Bagaimana untuk menukar jenis fail dalam win7
Pengenalan kepada maksud kata laluan tidak sah
Bagaimana untuk memuat naik html
Bagaimana untuk membuka akaun dengan mata wang u
Bagaimana untuk membuka fail ofd
Bagaimana untuk mengekstrak audio daripada video dalam java
jsonp menyelesaikan masalah merentas domain
Apakah maksud c#?
Analisis keberkesanan kos pembelajaran python, java dan c++
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
