2019 Rewrite library

Author: Marin

.travis.yml

@@ -0,0 +1,3 @@
+language: go
+go:
+- 1.11.x

README.md

@@ -1,57 +1,81 @@
-# KeyLogger
+# Keylogger
 
-# Description
 Capture global keyboard events on Linux
 
-# Installation
-    go get github.com/MarinX/keylogger
-# Notes
+[![Build Status](https://travis-ci.org/MarinX/keylogger.svg?branch=master)](https://travis-ci.org/MarinX/keylogger)
+[![GoDoc](https://godoc.org/github.com/MarinX/keylogger?status.svg)](https://godoc.org/github.com/MarinX/keylogger)
+[![License MIT](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](LICENSE)
+
+## Notes
 * Only Linux based
 * Need root privilages
 
+## Installation
+```sh
+go get github.com/MarinX/keylogger
+```
 
-# Example
-    package main
-
-    import (
-	    "fmt"
-	    "github.com/MarinX/keylogger"
-    )
+## Getting started
 
-    func main() {
-	    devs, err := keylogger.NewDevices()
-	    if err != nil {
-		    fmt.Println(err)
-		    return
-	    }
+### Finding keyboard device
+There is a helper on finding the keyboard.
+```go
+ keyboard := keylogger.FindKeyboardDevice()
+```
+Which goes through each file device name to find keyword "keyboard"
+```sh
+/sys/class/input/event[0-255]/device/name
+```
+and returns the file event path if found
+```sh
+/dev/input/event2
+```
+If the function returns empty string, you will need to cat each device name and get the event number.
+If you know already, you can easily pass it to constructor
+```sh
+keylogger.New("/dev/input/event2")
+```
 
-	    for _, val := range devs {
-		    fmt.Println("Id->", val.Id, "Device->", val.Name)
-	    }
+### Getting keypress
+Once the keylogger returns channel event, you can switch by event code as described in [input_event.go](https://github.com/MarinX/keylogger/blob/master/input_event.go)
+For start, you can listen on keyboard state change 
+```go
+keylogger.EvKey
+```
+Once you get desire event, there is a helper to parse code into human readable key.
+```go
+event.KeyString()
+```
+**NOTE**
 
-	    //keyboard device file, on your system it will be diffrent!
-	    rd := keylogger.NewKeyLogger(devs[3])
+If you listen on keyboard state change, it will return __double__ results.
+This is because pressing and releasing the key are 2 different state change.
+There is a helper function which you can call to see which type of state change happend
+```go
+// returns true if key on keyboard is pressed
+event.KeyPress()
 
-	    in, err := rd.Read()
-	    if err != nil {
-		    fmt.Println(err)
-		    return
-	    }
+// returns true if key on keyboard is released
+event.KeyRelease()
+```
 
-	    for i := range in {
+### Example
+You can find a example script in ```example/main.go```
 
-		    //we only need keypress
-		    if i.Type == keylogger.EV_KEY {
-			    fmt.Println(i.KeyString())
-		    }
-	    }
-    }
+### Running tests
+No magic, just run
+```sh
+go test -v
+```
 
-# Creating key sniffer
-* [sniffing global keyboard eventy in go](https://medium.com/@marin.basic02/sniffing-global-keyboard-events-in-go-e5497e618192/)
+## Creating key sniffer (needs update)
+* [sniffing global keyboard events in go](https://medium.com/@marin.basic02/sniffing-global-keyboard-events-in-go-e5497e618192/)
 
 
-# License
+## License
 This library is under the MIT License
-# Author
-Marin Basic 
+
+## Donate
+I don't drink beer, so energy drink will do :)
+
+BTC: 19AtHE6dgKX3R9vJSCSKRyF1saexLcBRep 

doc.go

@@ -0,0 +1,14 @@
+// Package keylogger is a go library for linux to capture keyboard events. About:
+//
+// * No C deps
+//
+// * Events ported from uapi/linux/input.h
+//
+// * Needs root privilages
+//
+// * Transfer keyboard code into human readable key
+//
+// * Capture state changes
+//
+// See README at https://github.com/MarinX/keylogger for more info.
+package keylogger

example/main.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"github.com/MarinX/keylogger"
+	"github.com/sirupsen/logrus"
+)
+
+func main() {
+
+	// find keyboard device, does not require a root permission
+	keyboard := keylogger.FindKeyboardDevice()
+
+	// check if we found a path to keyboard
+	if len(keyboard) <= 0 {
+		logrus.Error("No keyboard found...you will need to provide manual input path")
+		return
+	}
+
+	logrus.Println("Found a keyboard at", keyboard)
+	// init keylogger with keyboard
+	k, err := keylogger.New(keyboard)
+	if err != nil {
+		logrus.Error(err)
+		return
+	}
+	defer k.Close()
+
+	events := k.Read()
+
+	// range of events
+	for e := range events {
+		switch e.Type {
+		// EvKey is used to describe state changes of keyboards, buttons, or other key-like devices.
+		// check the input_event.go for more events
+		case keylogger.EvKey:
+
+			// if the state of key is pressed
+			if e.KeyPress() {
+				logrus.Println("[event] press key ", e.KeyString())
+			}
+
+			// if the state of key is released
+			if e.KeyRelease() {
+				logrus.Println("[event] release key ", e.KeyString())
+			}
+
+			break
+		}
+	}
+}

input_event.go

@@ -0,0 +1,65 @@
+package keylogger
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+const (
+	// EvSyn is used as markers to separate events. Events may be separated in time or in space, such as with the multitouch protocol.
+	EvSyn EventType = 0x00
+	// EvKey is used to describe state changes of keyboards, buttons, or other key-like devices.
+	EvKey EventType = 0x01
+	// EvRel is used to describe relative axis value changes, e.g. moving the mouse 5 units to the left.
+	EvRel EventType = 0x02
+	// EvAbs is used to describe absolute axis value changes, e.g. describing the coordinates of a touch on a touchscreen.
+	EvAbs EventType = 0x03
+	// EvMsc is used to describe miscellaneous input data that do not fit into other types.
+	EvMsc EventType = 0x04
+	// EvSw is used to describe binary state input switches.
+	EvSw EventType = 0x05
+	// EvLed is used to turn LEDs on devices on and off.
+	EvLed EventType = 0x11
+	// EvSnd is used to output sound to devices.
+	EvSnd EventType = 0x12
+	// EvRep is used for autorepeating devices.
+	EvRep EventType = 0x14
+	// EvFf is used to send force feedback commands to an input device.
+	EvFf EventType = 0x15
+	// EvPwr is a special type for power button and switch input.
+	EvPwr EventType = 0x16
+	// EvFfStatus is used to receive force feedback device status.
+	EvFfStatus EventType = 0x17
+)
+
+// EventType are groupings of codes under a logical input construct.
+// Each type has a set of applicable codes to be used in generating events.
+// See the Ev section for details on valid codes for each type
+type EventType uint16
+
+// eventsize is size of structure of InputEvent
+var eventsize = int(unsafe.Sizeof(InputEvent{}))
+
+// InputEvent is the keyboard event structure itself
+type InputEvent struct {
+	Time  syscall.Timeval
+	Type  EventType
+	Code  uint16
+	Value int32
+}
+
+// KeyString returns representation of pressed key as string
+// eg enter, space, a, b, c...
+func (i *InputEvent) KeyString() string {
+	return keyCodeMap[i.Code]
+}
+
+// KeyPress is the value when we press the key on keyboard
+func (i *InputEvent) KeyPress() bool {
+	return i.Value == 1
+}
+
+// KeyRelease is the value when we release the key on keyboard
+func (i *InputEvent) KeyRelease() bool {
+	return i.Value == 0
+}