keylogger | A keylogger written in Rust | Keyboard library

Try open/close the file for every log line?

KeyLogger

But it'll continue again anyway because of the parent loop.

No. The inner loop will not continue on each iteration of the outer loop; rather, it will restart – with the c variable being reset to 8 on each of those restarts.

Thus, on each of the (potentially infinite) runs of the outer for loop, the inner loop runs through the values of c from 8 to 222 and calls the GetAsyncKeyState() function with each of those values.

Note: Judging from the use of GetAsyncKeyState, this appears to be code designed to run on Windows. Many (most) Windows-compatible compilers have a signed 8-bit char type, so using values greater than 127 will likely cause problems.

The MSVC compiler (Visual Studio 2019) gives the following on your inner for loop:

warning C6295: Ill-defined for-loop: 'char' values are always of range '-128' to '127'. Loop executes infinitely.

The clang-cl compiler (same IDE) gives a similar message:

warning : result of comparison of constant 222 with expression of type 'char' is always true [-Wtautological-constant-out-of-range-compare]

Changing the c variable to an int would fix this – and GetAsyncKeyState takes an int argument, after all.

key.py

You can use a default route, then based on request headers, you can redirect to your route.

@Willeke was correct in their comment. Although I was correctly overriding the event, what I really needed to do was use the keydown/keyup events to keep track of when the right command key is pressed. I could then use that flag to intercept other keypress events, remove the command modifier, and insert the control modifier flag use bitwise operators. However, the simple solution here to this problem comes from the documentation link they provided:

hidutil property --set '{"UserKeyMapping":[{"HIDKeyboardModifierMappingSrc":0x7000000E7,"HIDKeyboardModifierMappingDst":0x7000000E0}]}'

As SimpleHTTPServer logs every request it receives, you can use fetch() to make a GET request and pass the data within it.

It may be possible, but any non root solution will depend on the keyboard virtualization tool. Let us look how (modern) OS work:

• the hardware is under the exclusive control of the kernel and its drivers. It is possible to implement a keylogger at that level that would only be kernel dependent but it requires admin privileges.
• if you have a multiple windows capable system (X11, XWindow) the OS passes low level events to the window manager which in turn will passes them to the client program. In Windows that part is include in the kernel for historical reasons. Here again it is possible to implement a (still low level) keylogger, but if the window manager has been started as root, interacting with it as a whole still requires admin privileges. At least the X11 server can be started as a non admin user process and in that use case, the keylogger can also run under the same user.
• at the end, the window manager passes events to the client application. On some (windowing) sytems, it is possible to implement hooks but they will be restricted to the same process or process group or at least the same user. Whether it is possible or not, and the way to implement it if possible will be anyway window manager dependant.

That means that it may be possible to implement a user level keylogger, but it will depend on the windowing system and not only on the kernel. Said differently, you will have to search for a Wayland specific way and a X11 specific way if you want to support both of them.

The pynput listener runs in another thread, so when you join that thread, the tkinter thread is blocked. Therefore your GUI doesn't show up. This also creates another problem, as tkinter does not work with multiple threads, so there needs to be a way to communicate between the listener thread and the tkinter thread. You also can't use .join() on the thread, as this will block the tkinter one.

The problem is that the hook fires, gets unbound, gets rebound and immediately fires again as the key is still pressed.

You can prevent that by using keyboard.on_release(on_key) instead of keyboard.hook(on_key). This causes the hook only fire when the key is released. This way the key is no longer pressed when the hook is rebound.