sonx 0.1.0__py3-none-any.whl

son/__main__.py

@@ -0,0 +1,3 @@
+from son.cli.main import app
+
+app()

son/cli/connect.py

@@ -0,0 +1,77 @@
+import asyncio
+import sys
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+
+from son.client.connector import SonConnector
+from son.core.protocol import CONNECTION_PORT
+from son.core.types import get_default_shell
+
+app = typer.Typer(help="Connect to a remote sond instance")
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def connect(
+    host: str = typer.Argument(..., help="sond hostname or IP address"),
+    port: int = typer.Option(CONNECTION_PORT, "--port", "-p", help="sond port"),
+    password: str = typer.Option("", "--password", "-P", help="auth password"),
+    shell: str = typer.Option("", "--shell", "-s", help="shell type (powershell, cmd, bash)"),
+):
+    target_shell = shell or get_default_shell()
+
+    async def run():
+        connector = SonConnector(host, port, password)
+        try:
+            await connector.connect()
+        except Exception as e:
+            console.print(f"[red]connection failed:[/] {e}")
+            raise typer.Exit(1)
+
+        console.print(Panel(
+            f"[bold green]connected[/] to [cyan]{host}:{port}[/] via [yellow]{target_shell}[/]\n"
+            "[dim]type 'exit' to disconnect[/]",
+            border_style="green",
+        ))
+
+        await connector.open_shell(shell=target_shell)
+
+        async def read_stdin():
+            loop = asyncio.get_running_loop()
+            while True:
+                line = await loop.run_in_executor(None, sys.stdin.readline)
+                if not line:
+                    break
+                if line.strip().lower() == "exit":
+                    break
+                await connector.send_input(line)
+
+        async def handle_output(data: str):
+            sys.stdout.write(data)
+            sys.stdout.flush()
+
+        connector.on_output(handle_output)
+        connector.on_disconnect(lambda: console.print("\n[red]disconnected[/]"))
+
+        tasks = [
+            asyncio.create_task(connector.listen()),
+            asyncio.create_task(read_stdin()),
+        ]
+
+        try:
+            await asyncio.gather(*tasks)
+        except (asyncio.CancelledError, KeyboardInterrupt):
+            pass
+        finally:
+            await connector.disconnect()
+            for t in tasks:
+                t.cancel()
+
+    try:
+        asyncio.run(run())
+    except KeyboardInterrupt:
+        pass

son/cli/discover.py

@@ -0,0 +1,66 @@
+import asyncio
+import time
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.live import Live
+
+from son.client.discovery import DiscoveryListener
+from son.core.types import DiscoveryInfo
+
+app = typer.Typer(help="Discover sond instances on the local network")
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def discover(
+    timeout: Optional[float] = typer.Option(None, "--timeout", "-t", help="scan duration in seconds"),
+):
+    discovered: list[DiscoveryInfo] = []
+    start = time.monotonic()
+
+    def on_discover(info: DiscoveryInfo):
+        for d in discovered:
+            if d.ip == info.ip and d.port == info.port:
+                return
+        discovered.append(info)
+        console.print(f"  [green]✓[/] found [bold]{info.hostname}[/] at {info.ip}:{info.port}")
+
+    async def run():
+        listener = DiscoveryListener()
+        listener.on_discover(on_discover)
+        console.print("[dim]scanning for sond instances...[/]")
+        task = asyncio.create_task(listener.start())
+
+        if timeout:
+            await asyncio.sleep(timeout)
+        else:
+            await asyncio.sleep(5)
+
+        listener.stop()
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+
+    asyncio.run(run())
+
+    if not discovered:
+        console.print("\n[yellow]no sond instances found[/]")
+        return
+
+    table = Table(title=f"Found {len(discovered)} sond instance(s)")
+    table.add_column("Hostname", style="cyan")
+    table.add_column("IP", style="green")
+    table.add_column("Port", style="yellow")
+    table.add_column("OS")
+
+    for d in discovered:
+        table.add_row(d.hostname, d.ip, str(d.port), d.os)
+
+    console.print("\n")
+    console.print(table)
+    console.print("\n[dim]connect:[/] [bold]son connect <hostname|ip>[/]")

son/cli/main.py

@@ -0,0 +1,19 @@
+import typer
+
+from son.cli import discover, connect, tunnel, web
+
+app = typer.Typer(
+    name="son",
+    help="Superior Organised Network - remote access tool",
+    no_args_is_help=True,
+)
+
+app.add_typer(discover.app, name="discover")
+app.add_typer(connect.app, name="connect")
+app.add_typer(tunnel.app, name="tunnel")
+app.add_typer(web.app, name="web")
+
+
+@app.callback()
+def callback():
+    pass

son/cli/tunnel.py

@@ -0,0 +1,76 @@
+import asyncio
+import re
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from son.client.connector import SonConnector
+from son.client.tunnel import TunnelManager
+from son.core.protocol import CONNECTION_PORT
+
+app = typer.Typer(help="Create tunnels through a sond agent")
+console = Console()
+
+LOCAL_FORWARD_RE = re.compile(r"^(?:-L\s+)?(\d+):([^:]+):(\d+)$")
+
+
+@app.callback(invoke_without_command=True)
+def tunnel(
+    host: str = typer.Argument(..., help="sond hostname or IP"),
+    port: int = typer.Option(CONNECTION_PORT, "--port", "-p", help="sond port"),
+    password: str = typer.Option("", "--password", "-P", help="auth password"),
+    local: Optional[str] = typer.Option(
+        None, "--local", "-L",
+        help="local forward: local_port:remote_host:remote_port",
+    ),
+):
+    if not local:
+        console.print("[red]specify a tunnel with --local (-L), e.g. -L 8080:localhost:80[/]")
+        raise typer.Exit(1)
+
+    m = LOCAL_FORWARD_RE.match(local)
+    if not m:
+        console.print("[red]invalid format, use: local_port:remote_host:remote_port[/]")
+        raise typer.Exit(1)
+
+    local_port = int(m.group(1))
+    remote_host = m.group(2)
+    remote_port = int(m.group(3))
+
+    async def run():
+        connector = SonConnector(host, port, password)
+        try:
+            await connector.connect()
+        except Exception as e:
+            console.print(f"[red]connection failed:[/] {e}")
+            raise typer.Exit(1)
+
+        mgr = TunnelManager(connector)
+
+        await mgr.listen("127.0.0.1", local_port, remote_host, remote_port)
+
+        console.print(Panel(
+            f"[bold green]tunnel active[/]\n"
+            f"  [cyan]127.0.0.1:{local_port}[/] → [yellow]{remote_host}:{remote_port}[/] via [bold]{host}[/]",
+            border_style="green",
+        ))
+        console.print("[dim]press Ctrl+C to stop[/]\n")
+
+        listen_task = asyncio.create_task(connector.listen())
+
+        try:
+            await asyncio.Event().wait()
+        except (asyncio.CancelledError, KeyboardInterrupt):
+            pass
+        finally:
+            await mgr.stop_all()
+            listen_task.cancel()
+            await connector.disconnect()
+            console.print("[red]tunnel closed[/]")
+
+    try:
+        asyncio.run(run())
+    except KeyboardInterrupt:
+        pass

son/cli/web.py

@@ -0,0 +1,15 @@
+import typer
+from rich.console import Console
+
+app = typer.Typer(help="Start the local web UI")
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def web(
+    port: int = typer.Option(8585, "--port", "-p", help="web UI port"),
+    host: str = typer.Option("127.0.0.1", "--host", "-H", help="bind address"),
+):
+    from son.web.server import run
+    console.print(f"[green]starting web UI at [bold]http://{host}:{port}[/][/]")
+    run(host=host, port=port)

son/client/connector.py

@@ -0,0 +1,125 @@
+import asyncio
+import json
+import logging
+from typing import Callable, Optional
+
+import websockets
+
+from son.core.protocol import (
+    WS_OPEN, WS_INPUT, WS_OUTPUT, WS_RESIZE, WS_CLOSE,
+    WS_AUTH, WS_AUTH_OK, WS_AUTH_FAIL,
+    WS_TUNNEL_OPEN, WS_TUNNEL_DATA, WS_TUNNEL_CLOSE,
+)
+
+log = logging.getLogger(__name__)
+
+
+class SonConnector:
+    def __init__(self, host: str, port: int, password: str = ""):
+        self._host = host
+        self._port = port
+        self._password = password
+        self._ws = None
+        self._shell_open = False
+        self._on_output: Optional[Callable] = None
+        self._on_disconnect: Optional[Callable] = None
+        self._on_tunnel_data: Optional[Callable] = None
+        self._on_tunnel_close: Optional[Callable] = None
+
+    @property
+    def connected(self) -> bool:
+        return self._ws is not None and not self._ws.close_code
+
+    def on_output(self, callback: Callable):
+        self._on_output = callback
+
+    def on_disconnect(self, callback: Callable):
+        self._on_disconnect = callback
+
+    def on_tunnel_data(self, callback: Callable):
+        self._on_tunnel_data = callback
+
+    def on_tunnel_close(self, callback: Callable):
+        self._on_tunnel_close = callback
+
+    async def connect(self):
+        uri = f"ws://{self._host}:{self._port}"
+        self._ws = await websockets.connect(uri)
+        if self._password:
+            await self._send({"type": WS_AUTH, "password": self._password})
+            resp = json.loads(await self._ws.recv())
+            if resp.get("type") == WS_AUTH_FAIL:
+                raise PermissionError("authentication failed")
+        log.info("connected to %s:%s", self._host, self._port)
+        return self
+
+    async def open_shell(self, shell: str = "", cols: int = 120, rows: int = 30):
+        await self._send({"type": WS_OPEN, "shell": shell, "cols": cols, "rows": rows})
+        self._shell_open = True
+
+    async def send_input(self, data: str):
+        if self._shell_open:
+            await self._send({"type": WS_INPUT, "data": data})
+
+    async def resize(self, cols: int, rows: int):
+        if self._shell_open:
+            await self._send({"type": WS_RESIZE, "cols": cols, "rows": rows})
+
+    async def close_shell(self):
+        if self._shell_open:
+            await self._send({"type": WS_CLOSE})
+            self._shell_open = False
+
+    async def tunnel_open(self, remote_host: str, remote_port: int, tunnel_id: int):
+        await self._send({
+            "type": WS_TUNNEL_OPEN,
+            "tunnel_id": tunnel_id,
+            "remote_host": remote_host,
+            "remote_port": remote_port,
+        })
+
+    async def tunnel_send(self, tunnel_id: int, data: str):
+        await self._send({
+            "type": WS_TUNNEL_DATA,
+            "tunnel_id": tunnel_id,
+            "data": data,
+        })
+
+    async def tunnel_close(self, tunnel_id: int):
+        await self._send({"type": WS_TUNNEL_CLOSE, "tunnel_id": tunnel_id})
+
+    async def _send(self, msg: dict):
+        if self._ws:
+            try:
+                await self._ws.send(json.dumps(msg))
+            except websockets.exceptions.ConnectionClosed:
+                pass
+
+    async def listen(self):
+        try:
+            async for raw in self._ws:
+                msg = json.loads(raw)
+                msg_type = msg.get("type")
+                if msg_type == WS_OUTPUT:
+                    if self._on_output:
+                        self._on_output(msg.get("data", ""))
+                elif msg_type == WS_TUNNEL_DATA:
+                    if self._on_tunnel_data:
+                        self._on_tunnel_data(msg.get("tunnel_id"), msg.get("data", ""))
+                elif msg_type == WS_TUNNEL_CLOSE:
+                    if self._on_tunnel_close:
+                        self._on_tunnel_close(msg.get("tunnel_id"))
+                elif msg_type == WS_CLOSE:
+                    self._shell_open = False
+                    break
+        except (websockets.exceptions.ConnectionClosed, asyncio.CancelledError):
+            pass
+        finally:
+            if self._on_disconnect:
+                self._on_disconnect()
+
+    async def disconnect(self):
+        await self.close_shell()
+        if self._ws:
+            await self._ws.close()
+        log.info("disconnected")

son/client/discovery.py

@@ -0,0 +1,72 @@
+import asyncio
+import socket
+import logging
+from typing import Callable
+
+from son.core.protocol import DISCOVERY_PORT, DISCOVERY_MAGIC
+from son.core.types import DiscoveryInfo
+
+log = logging.getLogger(__name__)
+
+
+class DiscoveryListener:
+    def __init__(self):
+        self._running = False
+        self._on_discover: Callable[[DiscoveryInfo], None] | None = None
+        self._seen: set[str] = set()
+
+    def on_discover(self, callback: Callable[[DiscoveryInfo], None]):
+        self._on_discover = callback
+
+    async def start(self):
+        self._running = True
+        loop = asyncio.get_running_loop()
+        transport: asyncio.DatagramTransport | None = None
+
+        class Proto(asyncio.DatagramProtocol):
+            def connection_made(self, t):
+                nonlocal transport
+                transport = t
+                sock = t.get_extra_info("socket")
+                if sock is not None:
+                    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                    sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+
+            def datagram_received(self, data: bytes, addr):
+                if not data.startswith(DISCOVERY_MAGIC):
+                    return
+                payload = data[len(DISCOVERY_MAGIC) + 1:]
+                try:
+                    info = DiscoveryInfo.from_bytes(payload)
+                    key = f"{info.ip}:{info.port}"
+                    if key not in self._seen:
+                        self._seen.add(key)
+                        log.debug("discovered: %s", info)
+                        if self._on_discover:
+                            self._on_discover(info)
+                except Exception as e:
+                    log.debug("bad discovery packet from %s: %s", addr, e)
+
+            def error_received(self, exc):
+                log.warning("discovery listener error: %s", exc)
+
+        try:
+            _, _ = await loop.create_datagram_endpoint(
+                Proto,
+                local_addr=("0.0.0.0", DISCOVERY_PORT),
+                allow_broadcast=True,
+            )
+            log.info("discovery listener started on port %s", DISCOVERY_PORT)
+            while self._running:
+                await asyncio.sleep(1)
+        except asyncio.CancelledError:
+            pass
+        finally:
+            if transport:
+                transport.close()
+
+    def stop(self):
+        self._running = False
+
+    def reset_seen(self):
+        self._seen.clear()

son/client/tunnel.py

@@ -0,0 +1,113 @@
+import asyncio
+import logging
+from typing import Optional
+
+from son.client.connector import SonConnector
+
+log = logging.getLogger(__name__)
+
+
+class TunnelEndpoint:
+    def __init__(self, conn_id: int, remote_host: str, remote_port: int,
+                 reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
+        self._conn_id = conn_id
+        self._remote_host = remote_host
+        self._remote_port = remote_port
+        self._reader = reader
+        self._writer = writer
+        self._connector: Optional[SonConnector] = None
+        self._reader_task: Optional[asyncio.Task] = None
+        self._closed = False
+
+    def start(self, connector: SonConnector):
+        self._connector = connector
+        self._reader_task = asyncio.create_task(self._read_local())
+        asyncio.create_task(
+            connector.tunnel_open(self._remote_host, self._remote_port, self._conn_id)
+        )
+
+    async def _read_local(self):
+        try:
+            while not self._closed:
+                data = await self._reader.read(65536)
+                if not data:
+                    break
+                await self._connector.tunnel_send(
+                    self._conn_id,
+                    data.decode("utf-8", errors="replace"),
+                )
+        except (asyncio.CancelledError, Exception):
+            pass
+        finally:
+            await self._close()
+
+    async def write_remote(self, data: str):
+        if self._closed:
+            return
+        try:
+            self._writer.write(data.encode("utf-8"))
+            await self._writer.drain()
+        except Exception:
+            await self._close()
+
+    async def _close(self):
+        if self._closed:
+            return
+        self._closed = True
+        if self._reader_task:
+            self._reader_task.cancel()
+        try:
+            self._writer.close()
+        except Exception:
+            pass
+        await self._connector.tunnel_close(self._conn_id)
+
+    async def close(self):
+        await self._close()
+
+
+class TunnelManager:
+    def __init__(self, connector: SonConnector):
+        self._connector = connector
+        self._servers: list[asyncio.Server] = []
+        self._endpoints: dict[int, TunnelEndpoint] = {}
+        self._next_conn_id = 0
+        self._connector.on_tunnel_data(self._on_tunnel_data)
+        self._connector.on_tunnel_close(self._on_tunnel_close)
+
+    async def listen(
+        self,
+        local_host: str,
+        local_port: int,
+        remote_host: str,
+        remote_port: int,
+    ):
+        async def on_connect(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
+            conn_id = self._next_conn_id
+            self._next_conn_id += 1
+            ep = TunnelEndpoint(conn_id, remote_host, remote_port, reader, writer)
+            self._endpoints[conn_id] = ep
+            ep.start(self._connector)
+
+        server = await asyncio.start_server(on_connect, host=local_host, port=local_port)
+        self._servers.append(server)
+        log.info("listening on %s:%s -> remote %s:%s", local_host, local_port, remote_host, remote_port)
+
+    def _on_tunnel_data(self, tunnel_id: int, data: str):
+        ep = self._endpoints.get(tunnel_id)
+        if ep:
+            asyncio.create_task(ep.write_remote(data))
+
+    def _on_tunnel_close(self, tunnel_id: int):
+        ep = self._endpoints.pop(tunnel_id, None)
+        if ep:
+            asyncio.create_task(ep.close())
+
+    async def stop_all(self):
+        for s in self._servers:
+            s.close()
+            await s.wait_closed()
+        self._servers.clear()
+        for ep in list(self._endpoints.values()):
+            await ep.close()
+        self._endpoints.clear()

son/core/protocol.py

@@ -0,0 +1,21 @@
+DISCOVERY_PORT = 8484
+CONNECTION_PORT = 9443
+DISCOVERY_INTERVAL = 2.0
+DISCOVERY_MAGIC = b"SONDISCOVERY"
+
+SHELL_BUFFER_SIZE = 65536
+
+WS_OPEN = "open"
+WS_INPUT = "input"
+WS_OUTPUT = "output"
+WS_RESIZE = "resize"
+WS_CLOSE = "close"
+WS_ERROR = "error"
+WS_TUNNEL_OPEN = "tunnel_open"
+WS_TUNNEL_DATA = "tunnel_data"
+WS_TUNNEL_CLOSE = "tunnel_close"
+WS_AUTH = "auth"
+WS_AUTH_OK = "auth_ok"
+WS_AUTH_FAIL = "auth_fail"
+WS_PING = "ping"
+WS_PONG = "pong"

son/core/types.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass, field, asdict
+from typing import Optional
+import json
+import socket
+
+
+@dataclass
+class DiscoveryInfo:
+    hostname: str
+    ip: str
+    port: int
+    version: str
+    os: str
+    shells: list[str] = field(default_factory=lambda: ["powershell", "cmd"])
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self))
+
+    @classmethod
+    def from_json(cls, data: str) -> "DiscoveryInfo":
+        d = json.loads(data)
+        return cls(**d)
+
+    def to_bytes(self) -> bytes:
+        return self.to_json().encode("utf-8")
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "DiscoveryInfo":
+        return cls.from_json(data.decode("utf-8"))
+
+
+@dataclass
+class ShellConfig:
+    shell: str = "powershell"
+    cols: int = 120
+    rows: int = 30
+
+
+def get_default_shell() -> str:
+    import sys
+    if sys.platform == "win32":
+        return "powershell"
+    return "bash"
+
+
+def get_hostname() -> str:
+    return socket.gethostname()
+
+
+def get_local_ip() -> str:
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(("10.255.255.255", 1))
+        return s.getsockname()[0]
+    except Exception:
+        return "127.0.0.1"
+    finally:
+        s.close()