winapi/kernel32.go at master · tryor/winapi · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package winapi

import (
	"reflect"
	"syscall"
	"unsafe"
)

var (
	modkernel32 = syscall.NewLazyDLL("kernel32.dll")

	procGetModuleHandleW    = modkernel32.NewProc("GetModuleHandleW")
	procFreeConsole         = modkernel32.NewProc("FreeConsole")
	procGetLastError        = modkernel32.NewProc("GetLastError")
	procGetLocaleInfoW      = modkernel32.NewProc("GetLocaleInfoW")
	procSetSystemPowerState = modkernel32.NewProc("SetSystemPowerState")
	ProcGetFullPathName     = modkernel32.NewProc("GetFullPathNameA")

	procGetCurrentThreadId = modkernel32.NewProc("GetCurrentThreadId")

	procCreateThread = modkernel32.NewProc("CreateThread")

	procOpenProcess = modkernel32.NewProc("OpenProcess")
	procCloseHandle = modkernel32.NewProc("CloseHandle")
	//procGetModuleFileNameExW = modkernel32.NewProc("K32GetModuleFileNameExW")

	//procSetUnhandledExceptionFilter = modkernel32.NewProc("SetUnhandledExceptionFilter")

)

const (
	SYNCHRONIZE              = 0x00100000
	STANDARD_RIGHTS_REQUIRED = 0x000F0000
	PROCESS_ALL_ACCESS       = (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFFF)
)

//OpenProcess(PROCESS_ALL_ACCESS, False, PID);//打开进程
func OpenProcess(pid uintptr) (h HANDLE, err error) {
	r0, e1 := Syscall(procOpenProcess.Addr(), uintptr(PROCESS_ALL_ACCESS), BoolToPtr(false), pid)
	if r0 == 0 {
		err = error(e1)
	} else {
		h = HANDLE(r0)
	}
	return
}

func CloseHandle(h HANDLE) (err error) {
	r0, e1 := Syscall(procCloseHandle.Addr(), uintptr(h))
	if r0 == 0 {
		err = error(e1)
	}
	return
}

/*
HANDLE
WINAPI
CreateThread(
_In_opt_LPSECURITY_ATTRIBUTES lpThreadAttributes,
_In_SIZE_T dwStackSize,
_In_LPTHREAD_START_ROUTINE lpStartAddress,
_In_opt___drv_aliasesMemLPVOID lpParameter,
_In_DWORD dwCreationFlags,
_Out_opt_LPDWORD lpThreadId
);


DWORD WINAPI ThreadProc(LPVOID lpParam){
    return 0
    }

hThread[i]=CreateThread(
        NULL,//default security attributes
        0,//use default stack size
        ThreadProc,//thread function
        pData,//argument to thread function
        0,//use default creation flags
        &dwThreadId[i]);//returns the thread identifier

*/
type ThreadProc func(lpParam uintptr) uintptr

func CreateThread(proc ThreadProc) (h HANDLE, tid uintptr, err error) {
	r0, e1 := Syscall(procCreateThread.Addr(), 0, 0, syscall.NewCallback(proc), 0, 0, uintptr(unsafe.Pointer(&tid)))
	if e1 != nil {
		err = error(e1)
	} else {
		h = HANDLE(r0)
	}
	return
}

func GetCurrentThreadId() (ret uint, err error) {
	r0, e1 := Syscall(procGetCurrentThreadId.Addr())
	if e1 != nil {
		err = error(e1)
	} else {
		ret = uint(r0)
	}
	return
}

func GetFullPathName(lpFileName string) (string, error) {
	nBufferLength := 255
	lpBuffer := make([]byte, nBufferLength)
	var lpFilePart string
	ret, err := Syscall(ProcGetFullPathName.Addr(), StringToUintptr(lpFileName), uintptr(nBufferLength), uintptr(unsafe.Pointer(&lpBuffer[0])), (uintptr)(unsafe.Pointer(&lpFilePart)))
	if err == nil || reflect.ValueOf(err).IsNil() {
		return string(lpBuffer[0:int(ret)]), nil
	} else {
		return "", err
	}
}

func GetModuleHandle(modname string) (handle HINSTANCE, err error) {
	var modname_ uintptr
	if modname == "" {
		modname_ = 0
	} else {
		modname_ = StringToUintptr(modname)
	}
	r0, _, e1 := syscall.Syscall(procGetModuleHandleW.Addr(), 1, modname_, 0, 0)
	handle = HINSTANCE(r0)
	if handle == 0 {
		if e1 != 0 {
			err = error(e1)
		} else {
			err = syscall.EINVAL
		}
	}
	return
}

func FreeConsole() (ret uint64, err error) {
	r0, _, e1 := syscall.Syscall(procFreeConsole.Addr(), 0, 0, 0, 0)
	if e1 != 0 {
		err = error(e1)
	} else {
		ret = uint64(r0)
	}
	return
}