gcli-control 0.1.0__py3-none-any.whl

gcli/__init__.py

@@ -0,0 +1,6 @@
+"""
+gcli — remote access tool via npoint.io.
+Encrypted command relay using AES-256-GCM over npoint.io JSON bins.
+"""
+__version__ = "0.1.0"
+__author__ = "gcli"

gcli/__main__.py

@@ -0,0 +1,104 @@
+"""
+gcli — remote access tool via npoint.io.
+
+Commands:
+    gcli host [--password P] [--bin ID] [--poll-interval N]
+    gcli ssh  [--password P] [--bin ID]
+    gcli stop [--bin ID]
+"""
+import argparse
+import sys
+import getpass
+import logging
+
+from .host import start_daemon, stop_daemon, DEFAULT_BIN_ID, DEFAULT_POLL
+from .client import SSHSession
+from .colors import banner, info, error
+
+logger = logging.getLogger("gcli")
+
+
+def cmd_host(args):
+    """Start the gcli host daemon."""
+    password = args.password
+    if not password:
+        password = getpass.getpass("Password: ")
+
+    print(info(f"[gcli] Starting host daemon (bin={args.bin})..."))
+    start_daemon(
+        password=password,
+        bin_id=args.bin,
+        poll_interval=args.poll_interval,
+        foreground=args.foreground,
+    )
+
+
+def cmd_ssh(args):
+    """Connect to a remote gcli host."""
+    password = args.password
+    if not password:
+        password = getpass.getpass("Password: ")
+
+    print(banner())
+    session = SSHSession(
+        password=password,
+        bin_id=args.bin,
+    )
+    session.repl()
+
+
+def cmd_stop(args):
+    """Stop a running gcli daemon."""
+    stop_daemon(bin_id=args.bin)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="gcli",
+        description="Remote access tool via npoint.io — encrypted command relay",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # ---- gcli host ----
+    host_parser = subparsers.add_parser("host", help="Start the background host daemon")
+    host_parser.add_argument("-p", "--password", default=None, help="Encryption password")
+    host_parser.add_argument("-b", "--bin", default=DEFAULT_BIN_ID, help="npoint.io bin ID")
+    host_parser.add_argument("--poll-interval", type=float, default=DEFAULT_POLL,
+                             help="Poll interval in seconds (default: 2.0)")
+    host_parser.add_argument("--foreground", action="store_true",
+                             help="Run in foreground (don't detach)")
+
+    # ---- gcli ssh ----
+    ssh_parser = subparsers.add_parser("ssh", help="Connect to a remote gcli host")
+    ssh_parser.add_argument("-p", "--password", default=None, help="Encryption password")
+    ssh_parser.add_argument("-b", "--bin", default=DEFAULT_BIN_ID, help="npoint.io bin ID")
+
+    # ---- gcli stop ----
+    stop_parser = subparsers.add_parser("stop", help="Stop the host daemon")
+    stop_parser.add_argument("-b", "--bin", default=DEFAULT_BIN_ID, help="npoint.io bin ID")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        print(banner())
+        parser.print_help()
+        sys.exit(1)
+
+    try:
+        if args.command == "host":
+            print(banner())
+            cmd_host(args)
+        elif args.command == "ssh":
+            cmd_ssh(args)
+        elif args.command == "stop":
+            cmd_stop(args)
+    except KeyboardInterrupt:
+        print(f"\n{error('[gcli] Interrupted.')}")
+        sys.exit(130)
+    except Exception as e:
+        logger.error("Fatal error: %s", e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

gcli/client.py

@@ -0,0 +1,362 @@
+"""
+gcli ssh — client that connects to a remote gcli host via npoint.
+Sends encrypted commands, polls for results, provides interactive REPL.
+"""
+import sys
+import time
+import uuid
+import logging
+from typing import Optional, List, Dict
+
+# readline: available on Linux/macOS, needs pyreadline on Windows
+try:
+    import readline  # noqa: F401
+except ImportError:
+    try:
+        import pyreadline as readline  # noqa: F401
+    except ImportError:
+        readline = None  # type: ignore
+
+from .protocol import (
+    read_doc, append_command, claim_results, claim_all_results,
+    is_host_alive, init_doc,
+)
+from .colors import Style, prompt, success, error, warn, info, banner
+
+logger = logging.getLogger("gcli.client")
+
+DEFAULT_BIN_ID = "599ac3c39189fcc26e5a"
+DEFAULT_POLL = 1.0  # seconds
+DEFAULT_TIMEOUT = 30.0  # seconds for exec commands
+
+BUILTIN_COMMANDS = [
+    ":help",
+    ":info",
+    ":ping",
+    ":upload <local_path> <remote_path>",
+    ":download <remote_path> <local_path>",
+    ":timeout <seconds>",
+    ":history",
+    ":exit",
+]
+
+
+def _setup_completion():
+    """Set up readline tab-completion for built-in commands."""
+    if readline is None:
+        return
+
+    def completer(text, state):
+        if text.startswith(":"):
+            matches = [c for c in BUILTIN_COMMANDS if c.startswith(text)]
+        else:
+            matches = []
+        return matches[state] if state < len(matches) else None
+
+    readline.set_completer(completer)
+    readline.set_completer_delims(" \t")
+    readline.parse_and_bind("tab: complete")
+
+
+class SSHSession:
+    """Interactive session to a remote gcli host."""
+
+    def __init__(self, password: str, bin_id: str = DEFAULT_BIN_ID,
+                 poll_interval: float = DEFAULT_POLL):
+        self.password = password
+        self.bin_id = bin_id
+        self.poll_interval = poll_interval
+        self.seen_results: set = set()
+        self.connected = False
+        self.session_id = str(uuid.uuid4())
+        self.exec_timeout: float = DEFAULT_TIMEOUT
+        self.history: List[Dict] = []  # recent command/result pairs
+
+    def connect(self, timeout: float = 10.0) -> bool:
+        """
+        Try to connect to the host by sending a ping and waiting for a pong.
+        Returns True if host responded.
+        """
+        print(info(f"[gcli] Connecting to host via npoint (bin={self.bin_id})..."))
+        print(info("[gcli] Sending ping..."))
+
+        cmd_id = self._send("ping", {"type": "ping"})
+
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            try:
+                doc = read_doc(self.bin_id)
+                if not is_host_alive(doc):
+                    time.sleep(self.poll_interval)
+                    continue
+                result = claim_results(doc, self.password, cmd_id, self.seen_results)
+                if result and result.get("pong"):
+                    print(success("[gcli] Host responded! Connected."))
+                    self.connected = True
+                    return True
+            except RuntimeError as e:
+                logger.debug("Read error during connect: %s", e)
+            time.sleep(self.poll_interval)
+
+        print(error("[gcli] Connection timed out. Is the host running?"))
+        return False
+
+    def repl(self) -> None:
+        """Interactive command loop."""
+        _setup_completion()
+
+        if not self.connected:
+            if not self.connect():
+                return
+
+        print(f"\n{info('[gcli ssh] Type commands to execute on the remote host.')}")
+        print(info("[gcli] Type :help for available commands"))
+        print()
+
+        try:
+            while self.connected:
+                try:
+                    line = input(prompt("gcli")).strip()
+                except (EOFError, KeyboardInterrupt):
+                    print(f"\n{warn('[gcli] Disconnecting...')}")
+                    break
+
+                if not line:
+                    continue
+
+                # Built-in commands
+                if line == ":exit" or line == ":quit":
+                    self._send_disconnect()
+                    break
+                elif line == ":help":
+                    self._do_help()
+                elif line == ":info":
+                    self._do_info()
+                elif line == ":ping":
+                    self._do_ping()
+                elif line == ":history":
+                    self._do_history()
+                elif line.startswith(":timeout"):
+                    self._do_timeout(line)
+                elif line.startswith(":upload"):
+                    self._do_upload(line)
+                elif line.startswith(":download"):
+                    self._do_download(line)
+                else:
+                    # Remote exec
+                    self._do_exec(line)
+        except Exception as e:
+            logger.error("REPL error: %s", e)
+        finally:
+            self.connected = False
+            print(info("[gcli] Session closed."))
+
+    # -------------------------------------------------------------------
+    # Built-in command handlers
+    # -------------------------------------------------------------------
+
+    def _do_help(self) -> None:
+        """Show available commands."""
+        print(f"\n{Style.CYAN}{Style.BOLD}--- Available Commands ---{Style.RESET}")
+        print(f"  {Style.GREEN}Any text{Style.RESET}              Execute shell command on remote host")
+        print(f"  {Style.GREEN}:help{Style.RESET}               Show this help message")
+        print(f"  {Style.GREEN}:info{Style.RESET}               Show remote system info")
+        print(f"  {Style.GREEN}:ping{Style.RESET}               Ping remote host (show latency)")
+        print(f"  {Style.GREEN}:upload <local> <remote>{Style.RESET}  Upload a file to remote host")
+        print(f"  {Style.GREEN}:download <remote> <local>{Style.RESET}  Download a file from remote host")
+        print(f"  {Style.GREEN}:timeout <seconds>{Style.RESET}   Set exec command timeout (current: {self.exec_timeout}s)")
+        print(f"  {Style.GREEN}:history{Style.RESET}            Show recent command history")
+        print(f"  {Style.GREEN}:exit{Style.RESET}               Disconnect and close session")
+        print(f"{Style.CYAN}{Style.BOLD}--------------------------{Style.RESET}\n")
+
+    def _do_timeout(self, line: str) -> None:
+        """Set or display the exec timeout."""
+        parts = line.split()
+        if len(parts) == 1:
+            print(info(f"[gcli] Current timeout: {self.exec_timeout}s"))
+            return
+        try:
+            new_timeout = float(parts[1])
+            if new_timeout < 1:
+                print(error("[gcli] Timeout must be at least 1 second"))
+                return
+            self.exec_timeout = new_timeout
+            print(success(f"[gcli] Timeout set to {self.exec_timeout}s"))
+        except ValueError:
+            print(error("[gcli] Invalid timeout value. Usage: :timeout <seconds>"))
+
+    def _do_history(self) -> None:
+        """Show recent command history."""
+        if not self.history:
+            print(info("[gcli] No command history yet."))
+            return
+
+        print(f"\n{Style.CYAN}{Style.BOLD}--- Command History ---{Style.RESET}")
+        for i, entry in enumerate(self.history[-20:], 1):
+            cmd = entry.get("cmd", "")
+            ok = entry.get("ok", False)
+            ts = entry.get("ts", "")
+            status_icon = f"{Style.GREEN}OK{Style.RESET}" if ok else f"{Style.RED}FAIL{Style.RESET}"
+            print(f"  {Style.DIM}{i:3d}{Style.RESET} [{status_icon}] {cmd}")
+        print(f"{Style.CYAN}{Style.BOLD}-----------------------{Style.RESET}\n")
+
+    # -------------------------------------------------------------------
+    # Command handlers
+    # -------------------------------------------------------------------
+
+    def _do_exec(self, cmd: str) -> None:
+        """Send a command for remote execution and display the result."""
+        t0 = time.time()
+        cmd_id = self._send("exec", {"type": "exec", "cmd": cmd, "timeout": int(self.exec_timeout)})
+        result = self._poll_result(cmd_id, timeout=self.exec_timeout + 5)
+        elapsed = (time.time() - t0) * 1000
+
+        if result is None:
+            print(error("[gcli] No response from host (timed out)"))
+            self.history.append({"cmd": cmd, "ok": False, "ts": time.strftime("%H:%M:%S")})
+            return
+
+        ok = result.get("ok", False)
+        self.history.append({"cmd": cmd, "ok": ok, "ts": time.strftime("%H:%M:%S")})
+
+        if ok:
+            stdout = result.get("stdout", "")
+            stderr = result.get("stderr", "")
+            if stdout:
+                print(stdout, end="")
+            if stderr:
+                print(stderr, end="", file=sys.stderr)
+        else:
+            err = result.get("error") or result.get("stderr", "unknown error")
+            print(error(f"[gcli] Error: {err}"))
+
+    def _do_info(self) -> None:
+        """Request remote system information."""
+        cmd_id = self._send("info", {"type": "info"})
+        result = self._poll_result(cmd_id)
+        if result is None:
+            print(error("[gcli] No response from host (timed out)"))
+            return
+        if result.get("ok"):
+            print(f"\n{Style.CYAN}{Style.BOLD}--- Remote System Info ---{Style.RESET}")
+            for k, v in result.items():
+                if k in ("ok", "cmd_id"):
+                    continue
+                print(f"  {Style.GREEN}{k:15s}{Style.RESET}: {v}")
+            print(f"{Style.CYAN}{Style.BOLD}--------------------------{Style.RESET}\n")
+        else:
+            print(error(f"[gcli] Info error: {result.get('error', 'unknown')}"))
+
+    def _do_ping(self) -> None:
+        """Send a ping and show latency."""
+        t0 = time.time()
+        cmd_id = self._send("ping", {"type": "ping"})
+        result = self._poll_result(cmd_id)
+        if result and result.get("pong"):
+            latency = (time.time() - t0) * 1000
+            print(success(f"[gcli] Pong! Round-trip: {latency:.0f}ms"))
+        else:
+            print(error("[gcli] No pong received"))
+
+    def _do_upload(self, line: str) -> None:
+        """
+        Upload a local file to the remote host.
+        Usage: :upload <local_path> <remote_path>
+        """
+        import base64
+        from pathlib import Path
+
+        parts = line.split(maxsplit=2)
+        if len(parts) < 3:
+            print(warn("Usage: :upload <local_path> <remote_path>"))
+            return
+
+        local_path = parts[1]
+        remote_path = parts[2]
+
+        try:
+            raw = Path(local_path).read_bytes()
+            data_b64 = base64.b64encode(raw).decode("ascii")
+        except FileNotFoundError:
+            print(error(f"[gcli] Local file not found: {local_path}"))
+            return
+        except Exception as e:
+            print(error(f"[gcli] Read error: {e}"))
+            return
+
+        print(info(f"[gcli] Uploading {local_path} -> {remote_path} ({len(raw)} bytes)..."))
+        cmd_id = self._send("upload", {
+            "type": "upload",
+            "path": remote_path,
+            "data": data_b64,
+        })
+        result = self._poll_result(cmd_id)
+        if result is None:
+            print(error("[gcli] Upload timed out"))
+        elif result.get("ok"):
+            print(success(f"[gcli] Upload complete: {result.get('bytes_written', '?')} bytes written"))
+        else:
+            print(error(f"[gcli] Upload failed: {result.get('error', 'unknown')}"))
+
+    def _do_download(self, line: str) -> None:
+        """
+        Download a file from the remote host.
+        Usage: :download <remote_path> <local_path>
+        """
+        import base64
+        from pathlib import Path
+
+        parts = line.split(maxsplit=2)
+        if len(parts) < 3:
+            print(warn("Usage: :download <remote_path> <local_path>"))
+            return
+
+        remote_path = parts[1]
+        local_path = parts[2]
+
+        print(info(f"[gcli] Downloading {remote_path} -> {local_path}..."))
+        cmd_id = self._send("download", {
+            "type": "download",
+            "path": remote_path,
+        })
+        result = self._poll_result(cmd_id)
+        if result is None:
+            print(error("[gcli] Download timed out"))
+        elif result.get("ok"):
+            data_b64 = result.get("data", "")
+            raw = base64.b64decode(data_b64)
+            Path(local_path).write_bytes(raw)
+            print(success(f"[gcli] Download complete: {len(raw)} bytes written to {local_path}"))
+        else:
+            print(error(f"[gcli] Download failed: {result.get('error', 'unknown')}"))
+
+    def _send_disconnect(self) -> None:
+        """Send a disconnect command to the host."""
+        cmd_id = self._send("disconnect", {"type": "disconnect"})
+        self._poll_result(cmd_id, timeout=3.0)
+        print(warn("[gcli] Disconnected."))
+
+    # -------------------------------------------------------------------
+    # Low-level send / poll
+    # -------------------------------------------------------------------
+
+    def _send(self, cmd_type: str, payload: dict) -> str:
+        """Encrypt and send a command. Returns the command id."""
+        payload["type"] = cmd_type
+        payload["id"] = payload.get("id") or str(uuid.uuid4())
+        cmd_id = append_command(self.bin_id, self.password, payload)
+        return cmd_id
+
+    def _poll_result(self, cmd_id: str, timeout: float = 10.0) -> Optional[dict]:
+        """Poll npoint for a result matching cmd_id. Returns decrypted payload or None."""
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            try:
+                doc = read_doc(self.bin_id)
+                result = claim_results(doc, self.password, cmd_id, self.seen_results)
+                if result is not None:
+                    return result
+            except RuntimeError as e:
+                logger.debug("Read error during poll: %s", e)
+            time.sleep(self.poll_interval)
+        return None

gcli/colors.py

@@ -0,0 +1,85 @@
+"""
+Terminal colour helpers for gcli.
+Works on both Windows (via ctypes/win32) and Linux/macOS (ANSI escapes).
+"""
+import sys
+import os
+
+
+def _setup_windows_console():
+    """Enable ANSI escape sequences on Windows 10+."""
+    if sys.platform == "win32":
+        try:
+            import ctypes
+            kernel32 = ctypes.windll.kernel32
+            # STD_OUTPUT_HANDLE = -11
+            handle = kernel32.GetStdHandle(-11)
+            mode = ctypes.c_ulong()
+            kernel32.GetConsoleMode(handle, ctypes.byref(mode))
+            # ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+            kernel32.SetConsoleMode(handle, mode.value | 0x0004)
+        except Exception:
+            pass
+
+
+# Initialise on import
+_setup_windows_console()
+
+# Check if we should use colours
+_NO_COLOR = os.environ.get("NO_COLOR") or not sys.stdout.isatty()
+
+
+class Style:
+    RESET = "" if _NO_COLOR else "\033[0m"
+    BOLD = "" if _NO_COLOR else "\033[1m"
+    DIM = "" if _NO_COLOR else "\033[2m"
+
+    RED = "" if _NO_COLOR else "\033[91m"
+    GREEN = "" if _NO_COLOR else "\033[92m"
+    YELLOW = "" if _NO_COLOR else "\033[93m"
+    BLUE = "" if _NO_COLOR else "\033[94m"
+    MAGENTA = "" if _NO_COLOR else "\033[95m"
+    CYAN = "" if _NO_COLOR else "\033[96m"
+    WHITE = "" if _NO_COLOR else "\033[97m"
+
+    # Background
+    BG_RED = "" if _NO_COLOR else "\033[41m"
+    BG_GREEN = "" if _NO_COLOR else "\033[42m"
+
+
+def coloured(text: str, style: str) -> str:
+    """Wrap text with colour style."""
+    return f"{style}{text}{Style.RESET}"
+
+
+def prompt(text: str = "gcli") -> str:
+    """Return a coloured prompt string."""
+    return f"{Style.CYAN}{Style.BOLD}{text}>{Style.RESET} "
+
+
+def success(text: str) -> str:
+    return f"{Style.GREEN}{text}{Style.RESET}"
+
+
+def error(text: str) -> str:
+    return f"{Style.RED}{text}{Style.RESET}"
+
+
+def warn(text: str) -> str:
+    return f"{Style.YELLOW}{text}{Style.RESET}"
+
+
+def info(text: str) -> str:
+    return f"{Style.CYAN}{text}{Style.RESET}"
+
+
+def banner() -> str:
+    """Return the gcli startup banner."""
+    return f"""
+{Style.CYAN}{Style.BOLD}  _____ _____ ____  __  __ ___ _   _    _    _
+ / ____|  __/ ___||  \\/  |_ _| \\ | |  / \\  | |
+| |  __| | | |  __ | |\\/| || ||  \\| | / _ \\ | |
+| |_| | |_| |___ || |  | || || |\\  |/ ___ \\| |___
+ \\____|____/\\____/|_|  |_|___|_| \\_/_/   \\_\\_____|
+{Style.RESET}{Style.DIM}  Remote access via npoint.io | Encrypted AES-256-GCM{Style.RESET}
+"""

gcli/crypto.py

@@ -0,0 +1,51 @@
+"""
+AES-256-GCM encryption/decryption for gcli.
+Password -> PBKDF2 -> 256-bit key -> AES-256-GCM.
+"""
+import os
+import json
+import base64
+import hashlib
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+SALT = b"gcli-v1-salt-2024"  # fixed salt (password provides secrecy)
+ITERATIONS = 600_000          # OWASP 2023 recommendation for PBKDF2-SHA256
+
+
+def derive_key(password: str) -> bytes:
+    """Derive a 256-bit key from a password using PBKDF2."""
+    return hashlib.pbkdf2_hmac(
+        "sha256",
+        password.encode("utf-8"),
+        SALT,
+        ITERATIONS,
+        dklen=32,
+    )
+
+
+def encrypt(plaintext: str, password: str) -> str:
+    """Encrypt plaintext string -> base64 string. Format: nonce(12) + ciphertext + tag(16)."""
+    key = derive_key(password)
+    nonce = os.urandom(12)
+    aesgcm = AESGCM(key)
+    ct = aesgcm.encrypt(nonce, plaintext.encode("utf-8"), None)
+    return base64.b64encode(nonce + ct).decode("ascii")
+
+
+def decrypt(blob: str, password: str) -> str:
+    """Decrypt base64 string -> plaintext string."""
+    key = derive_key(password)
+    raw = base64.b64decode(blob)
+    nonce, ct = raw[:12], raw[12:]
+    aesgcm = AESGCM(key)
+    return aesgcm.decrypt(nonce, ct, None).decode("utf-8")
+
+
+def encrypt_dict(data: dict, password: str) -> str:
+    """Encrypt a dict -> base64 string (JSON-serialised then encrypted)."""
+    return encrypt(json.dumps(data, separators=(",", ":")), password)
+
+
+def decrypt_dict(blob: str, password: str) -> dict:
+    """Decrypt a base64 string -> dict."""
+    return json.loads(decrypt(blob, password))