ich committe mit mienen besten

1 files changed, 282 insertions, 0 deletions

diff --git a/executables/hexen.py b/executables/hexen.py
new file mode 100644
index 0000000..3f4b8ca
--- /dev/null
+++ b/executables/hexen.py
@@ -0,0 +1,282 @@
+import socket
+import struct
+import psutil
+import time
+from collections import deque # Add this import
+import sys # Add this import
+import os # Add this import
+try:
+    import msvcrt # For non-blocking input on Windows
+except ImportError:
+    msvcrt = None # Will be None on non-Windows OS
+
+MCAST_GRP = '239.192.55.1'
+MCAST_PORT = 1681
+MAGIC = '/Users/crt/Documents/bodeting/research/bad-bruteforcing/attempt-1.txt'
+
+
+def get_default_ipv4():
+    # Get the first non-loopback IPv4 address on an active interface
+    for iface, addrs in psutil.net_if_addrs().items():
+        for addr in addrs:
+            if addr.family == socket.AF_INET and not addr.address.startswith("127."):
+                return addr.address
+    raise RuntimeError("Steck Ether Portal Kabel ih din PC ned ih din arsch du huso!")
+
+def save_to_magic_file(value_to_save, filepath):
+    if not value_to_save:
+        print("No value provided to save.", flush=True)
+        return
+
+    directory = os.path.dirname(filepath)
+    
+    # Check if directory exists, create if not (optional, but good for robustness)
+    # For now, as per prompt, just check and error if not exists or unwritable.
+    if directory and not os.path.isdir(directory):
+        print(f"Error: Directory '{directory}' does not exist. Kann dir nicht aufs Bett kaggern", flush=True)
+        return
+
+    try:
+        with open(filepath, 'a') as f:
+            f.write(value_to_save + "\n")
+        print(f"Hab dir ins Bett geschissen '{value_to_save}' to {filepath}", flush=True)
+    except IOError as e:
+        print(f"Kann nicht stimmen '{filepath}'. Vielleicht solltest du deine Pillen nehmen. Details: {e}", flush=True)
+    except OSError as e:
+        print(f"Error: Zu grosser Hurensohn Erkannt. PC von ihm hat ihn rejected '{filepath}'. Lol : {e}", flush=True)
+
+
+try:
+    LOCAL_INTERFACE_IP = get_default_ipv4()
+except RuntimeError as e:
+    print(f"ach weisch was ich ha eif kei bock meh lol: {e}")
+    exit(1)
+
+# Create UDP socket
+sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 1)
+
+# Bind to correct interface
+sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, socket.inet_aton(LOCAL_INTERFACE_IP))
+
+print(f"So Sportsfreund jetzt weiss ich wo du wohnst : {LOCAL_INTERFACE_IP} —  Lass deine Mami hier ficken gehen : {MCAST_GRP}:{MCAST_PORT} \n\n")
+print("Wallah billahmius ich mach hier Verzauberus, gib Hexen spruch in HEX ein, 'brute <hex_prefix>' für Bruteforce, oder 'exit' um dich zu verpissen vom Zauberstab.\n")
+
+while True:
+    user_input = input("HEXEREI > ").strip()
+    if user_input.lower() in ("exit", "quit"):
+        break
+
+    if user_input.lower().startswith("brute "):
+        parts = user_input.split(" ", 1)
+        if len(parts) < 2 or not parts[1]:
+            print("Zum Hexensprüche zu Lernen brauchst de nen Prefix. Beispiel: brute 4d454c00")
+            continue
+        
+        hex_prefix = parts[1]
+        try:
+            # Validate prefix by attempting conversion
+            bytes.fromhex(hex_prefix) 
+        except ValueError:
+            print("Also ehm das stimmt nix wirklich")
+            continue
+
+        # Get bruteforce parameters
+        brute_mode = ""
+        while brute_mode not in ['1', '2', '3']:
+            brute_mode = input("Wähle den Hexenspruch Lernmodus: (1) Manuel, (2) Magisch Absteigend, (3) Magisch Aufsteigend: ").strip()
+            if brute_mode not in ['1', '2', '3']:
+                print("Sprich Deutsch du Hurensohn! 1, 2, oder 3.")
+
+        delay_seconds_str = ""
+        delay_seconds = 1.0 # Default delay
+        while True:
+            delay_seconds_str = input(f"Wie geduldig willst du sein in Sekunden? (Zum Beispel 0.5, standart ist {delay_seconds} warten): ").strip()
+            if not delay_seconds_str: # User pressed enter, use default
+                break
+            try:
+                delay_seconds = float(delay_seconds_str)
+                if delay_seconds < 0:
+                    print("Hast du einen Schlaganfall? Gib eine richtige Zahl ein, es gibt keine negativen Zahlen, das sind Fake News")
+                else:
+                    break
+            except ValueError:
+                print("Bist du bekloppt? (Junge schreib doch einfach wie normaler mensch : 0.5, 1, 2.3).")
+        
+        print(f"So jetzt wird {hex_prefix} mal so richtig hart vergewaltigt :3")
+        print(f"Modi: {'Manuel Neuer' if brute_mode == '1' else ('Absturz' if brute_mode == '2' else 'Von Afrika bis zum Nordpol')}, Delay: {delay_seconds}s")
+        
+        if brute_mode in ['2', '3'] and msvcrt: # If Auto Ascending or Auto Descending and on Windows
+            print("During auto mode: press 'c' to cancel, 'r' to retry last 3, 'p' to pause/resume.", flush=True)
+        
+        # auto_mode is True if brute_mode is '2' or '3'
+        # manual_mode is True if brute_mode is '1'
+        manual_mode = (brute_mode == '1')
+        
+        sent_history = deque(maxlen=3) # History for 'retry' functionality
+        
+        bruteforce_successful = False
+        bruteforce_stopped_by_user = False
+        last_iteration_completed = False
+        paused = False # Pause state for auto modes
+
+        iteration_range_list = list(range(256)) # Default for mode '1' and '2'
+        if brute_mode == '3': # Auto Degrading
+            iteration_range_list = list(range(255, -1, -1))
+        
+        num_iterations = len(iteration_range_list)
+
+        for i_val_idx, i in enumerate(iteration_range_list): # Retardmode 0x00 to 0xFF or 0xFF to 0x00
+            last_byte_hex = format(i, '02x')
+            full_hex_string = hex_prefix + last_byte_hex
+            
+            try:
+                payload = bytes.fromhex(full_hex_string)
+            except ValueError:
+                print(f"Sorry bin leider Schwerbehindert: {full_hex_string}")
+                continue
+
+            if not manual_mode and msvcrt: # Check for input in auto modes on Windows
+                while True: # Loop for handling pause and other inputs
+                    if paused:
+                        if msvcrt.kbhit():
+                            try:
+                                char = msvcrt.getch().decode(errors='ignore').lower()
+                                if char == 'p':
+                                    paused = False
+                                    print("\nBin wieder wach...", flush=True)
+                                    break # Break from pause check loop, continue outer loop
+                                elif char == 'c':
+                                    print("\nNah du kleins Bumsfotzengesicht hast den Spruch rausgefunden?", flush=True)
+                                    bruteforce_stopped_by_user = True
+                                    break # Break from pause check loop
+                            except Exception as e:
+                                print(f"\nSorry bin blind geworden: {e}", flush=True)
+                        time.sleep(0.1) # Sleep briefly while paused and checking keys
+                        if bruteforce_stopped_by_user: # If 'c' was pressed during pause
+                            break # Break from the while True input check loop
+                        continue # Continue pause check loop
+                    
+                    # If not paused, check for regular input once
+                    if msvcrt.kbhit():
+                        try:
+                            char = msvcrt.getch().decode(errors='ignore').lower()
+                            if char == 'c':
+                                print("\nMarcel Davis will remember that.", flush=True)
+                                bruteforce_stopped_by_user = True
+                                # No break here, let the outer loop's check handle it
+                            elif char == 'r':
+                                if not sent_history:
+                                    print("\nChill alter, hast ja noch gar nix probiert.", flush=True)
+                                else:
+                                    retry_packets_auto = list(sent_history)
+                                    print(f"\nEsy probiere die lezten {len(retry_packets_auto)} Zaubersprüche: {', '.join(retry_packets_auto)}", flush=True)
+                                    for hist_hex_string_auto in retry_packets_auto:
+                                        try:
+                                            hist_payload_auto = bytes.fromhex(hist_hex_string_auto)
+                                            print(f"Retrying: {hist_hex_string_auto} ({len(hist_payload_auto)} bytes)", flush=True)
+                                            time.sleep(delay_seconds) 
+                                            sock.sendto(hist_payload_auto, (MCAST_GRP, MCAST_PORT))
+                                        except ValueError:
+                                            print(f"Sorry bin dumm: {hist_hex_string_auto}", flush=True)
+                                    print("Und hat das was gebracht?", flush=True)
+                                # After retry, we don't break, just continue with the current packet
+                            elif char == 'p':
+                                paused = True
+                                print("\nZeit Angehalten. Drück 'p' to um Zeit wieder zu starten, 'c' um dich Abzutreiben.", flush=True)
+                                continue # Go back to start of while True to enter pause handling
+                        except Exception as e: 
+                            print(f"\nError reading keyboard input: {e}", flush=True)
+                    break # Break from the while True input check loop if not paused or no key pressed initially
+            
+            if bruteforce_stopped_by_user: 
+                break
+
+            time.sleep(delay_seconds) # Use user-defined delay
+
+            sock.sendto(payload, (MCAST_GRP, MCAST_PORT))
+            # Ensure this print is on a new line if a key was pressed and printed something.
+            # The \n in prints above should handle this.
+            print(f"Sent: {full_hex_string} ({len(payload)} bytes)", flush=True)
+            sent_history.append(full_hex_string) # Add to history after sending
+
+            if i_val_idx == num_iterations - 1:
+                last_iteration_completed = True
+
+            if not manual_mode: # Auto modes ('2' or '3')
+                if last_iteration_completed:
+                    print(f"Bruteforce {'auto-ascending' if brute_mode == '2' else 'auto-descending'} hat fertig geballert.", flush=True)
+                continue # Continue to next i without asking
+
+            # Manual mode (brute_mode == '1'): ask for feedback
+            while True:
+                feedback_prompt = "Hats was getan? (y/n/auto/stop/r=retry last 3/c=cancel): "
+                feedback = input(feedback_prompt).strip().lower()
+                if feedback == 'y':
+                    print(f"OHAA jetzt kannst du auch wie ich zaubern mit {full_hex_string}! (Meine Frau hat mich verlassen, bin in der geschlossenen Klinik Glanzenberg und leide an starker Schizophrenie, aber egal, ich bin jetzt Hexe!)")
+                    bruteforce_successful = True
+                    break 
+                elif feedback == 'n':
+                    break 
+                elif feedback == 'auto':
+                    manual_mode = False 
+                    print("Tja da ist dir wohl die Lust vergangen. Du weisst was das Heute Abend bedeutet? Du bist jetzt im Auto-Modus direkt in meinen Keller, du kleiner Hurensohn.")
+                    if last_iteration_completed:
+                         print("Und wie ists in meinem Keller?")
+                    break 
+                elif feedback == 'stop' or feedback == 'c':
+                    print(f"Bruteforce {'stopped' if feedback == 'stop' else 'cancelled'} by mr hurensohn.")
+                    bruteforce_stopped_by_user = True
+                    break
+                elif feedback == 'r':
+                    if not sent_history:
+                        print("No packets in history to retry.")
+                        continue # Re-prompt for current packet
+
+                    retry_packets_manual = list(sent_history) 
+                    print(f"Probier da mal die hier {len(retry_packets_manual)} von vorher: {', '.join(retry_packets_manual)}")
+                    for hist_hex_string_manual in retry_packets_manual:
+                        try:
+                            hist_payload_manual = bytes.fromhex(hist_hex_string_manual)
+                            print(f"Probiere: {hist_hex_string_manual} ({len(hist_payload_manual)} bytes)") # Manual mode input implies flush
+                            time.sleep(delay_seconds) 
+                            sock.sendto(hist_payload_manual, (MCAST_GRP, MCAST_PORT))
+                        except ValueError:
+                            print(f"Die Stimmen wurden zu laut: {hist_hex_string_manual}")
+                    print(f"War es doch nur ein Traum? : {full_hex_string}")
+                    continue 
+                else:
+                    print("Junge! Ich schlage dich mit Gürtel wenn du mir jetzt nicht richtig antwortest 'y', 'n', 'auto', 'stop', 'r', or 'c'.")
+            
+            if bruteforce_successful or bruteforce_stopped_by_user:
+                break 
+        if manual_mode and not bruteforce_successful and not bruteforce_stopped_by_user and last_iteration_completed:
+             print("Schau mal da, ein Hurensohn, der nicht mal den Hexenspruch rausbekommt. Vielleicht solltest du es mit Aufgeben versuchen, mistvieh.")
+        # Message for auto_mode completion is handled inside the loop or after switching from manual
+
+        # After bruteforce attempt (success, cancel, or finish)
+        if bruteforce_successful:
+            # full_hex_string at this point is the one that was successful
+            print(f"Glückwunsch, du darfst deine Familie wieder sehen mit dem Zauberspruch '{full_hex_string}', Spass (nicht).", flush=True)
+            save_to_magic_file(full_hex_string, MAGIC)
+        else:
+            # If not successful (cancelled or completed all iterations without success)
+            manual_entry_suffix = input(f"Kein Zauber hat gewirkt oder du hast abgebrochen. Gib den Suffix für '{hex_prefix}' ein, um ihn ins Buch zu kritzeln (oder Enter zum Überspringen): ").strip()
+            if manual_entry_suffix:
+                combined_value_to_save = hex_prefix + manual_entry_suffix
+                print(f"Der Zauberspruch '{combined_value_to_save}' wird dir aufs Bett gesprühschissen !", flush=True)
+                save_to_magic_file(combined_value_to_save, MAGIC)
+
+    else: # Original hex string sending logic
+        hex_string = user_input # Use the full user_input as the hex_string
+        try:
+            payload = bytes.fromhex(hex_string)
+        except ValueError:
+            print("Tja hast halt geschissen bist halt keine Hexe oder was?")
+            continue
+
+        sock.sendto(payload, (MCAST_GRP, MCAST_PORT))
+        print(f"Hexenspruch mit {len(payload)} bytes wurde gezaubert.")
+
+sock.close()
+print("Marcel Davis, leiter für Kundenzufriedenheit! Er geht erst wieder wenn die Checksum so hart ausgeschalgen wurde bis Sie aufgibt!.")