praetorian-cli 2.2.1__py3-none-any.whl → 2.2.3__py3-none-any.whl

praetorian_cli/sdk/test/ui_mocks.py

@@ -0,0 +1,133 @@
+class MockConsole:
+    def __init__(self):
+        self.lines = []
+
+    def print(self, msg=""):
+        self.lines.append(str(msg))
+
+
+class MockAegis:
+    def __init__(self, responses=None):
+        self.calls = []
+        self._responses = responses or {}
+
+    def ssh_to_agent(self, agent, options, user, display_info=True):
+        self.calls.append({
+            'method': 'ssh_to_agent',
+            'agent': agent,
+            'options': list(options),
+            'user': user,
+            'display_info': display_info,
+        })
+
+    def run_job(self, agent, capabilities=None, config=None):
+        self.calls.append({
+            'method': 'run_job',
+            'agent': agent,
+            'capabilities': capabilities,
+            'config': config,
+        })
+        if capabilities is None:
+            return self._responses.get('list_caps', {'capabilities': []})
+        return self._responses.get('run', {'success': True, 'job_id': 'abc123', 'job_key': 'k', 'status': 'queued'})
+
+    # Newer TUI code uses these helpers
+    def validate_capability(self, name):
+        caps = self._responses.get('capabilities', {
+            'windows-smb': {'name': 'windows-smb', 'description': 'Windows SMB capability', 'target': 'asset'},
+            'linux-enum': {'name': 'linux-enum', 'description': 'Linux enum capability', 'target': 'asset'},
+        })
+        return caps.get(name)
+
+    def create_job_config(self, agent, credentials=None):
+        # Return provided credentials or an empty config as JSON-ready dict
+        return credentials or self._responses.get('config', {})
+
+    def get_available_ad_domains(self):
+        return self._responses.get('domains', ['example.local'])
+
+
+class MockSDK:
+    def __init__(self, responses=None):
+        self.aegis = MockAegis(responses=responses)
+        self.jobs = MockJobs(responses=responses)
+
+
+class MockJobs:
+    def __init__(self, responses=None):
+        self._responses = responses or {}
+        self.calls = []
+
+    def add(self, target_key, capabilities, config_json):
+        self.calls.append({
+            'method': 'add',
+            'target_key': target_key,
+            'capabilities': capabilities,
+            'config': config_json,
+        })
+        # Return a minimal job-like record the UI expects
+        return [self._responses.get('job', {
+            'key': 'jobs#abc123deadbeef',
+            'status': 'queued',
+        })]
+
+    def list(self, prefix_filter=None):
+        # Return (jobs, next_page_token)
+        jobs = self._responses.get('jobs', [])
+        return jobs, None
+
+
+class MockCloudflaredStatus:
+    def __init__(self, hostname='cf.example.com', tunnel_name='tunnel-1', authorized_users=''):
+        self.hostname = hostname
+        self.tunnel_name = tunnel_name
+        self.authorized_users = authorized_users
+
+
+class MockHealthCheck:
+    def __init__(self, cf_status=None):
+        self.cloudflared_status = cf_status or MockCloudflaredStatus()
+
+
+class MockAgent:
+    def __init__(self, hostname="agent01", client_id="C.1"):
+        # Basic identity
+        self.hostname = hostname
+        self.client_id = client_id
+        # System info (optional in UI)
+        self.os = None
+        self.os_version = None
+        self.architecture = None
+        self.fqdn = None
+        # Activity/timestamps
+        self.last_seen_at = 0
+        # Networking
+        self.network_interfaces = []
+        # Tunnel/health
+        self.has_tunnel = True
+        self.health_check = MockHealthCheck()
+
+    def to_detailed_string(self):
+        return f"Agent {self.hostname} ({self.client_id})"
+
+
+class MockMenuBase:
+    def __init__(self):
+        self.console = MockConsole()
+        self.paused = False
+        # Minimal color map used by the UI (optional)
+        self.colors = {
+            'primary': 'cyan',
+            'accent': 'magenta',
+            'dim': 'dim',
+            'success': 'green',
+            'warning': 'yellow',
+            'error': 'red',
+        }
+
+    def pause(self):
+        self.paused = True
+
+    def clear_screen(self):
+        # No-op for tests; add a blank line like the real UI would
+        self.console.print()

praetorian_cli/sdk/test/utils.py

@@ -5,7 +5,7 @@ from random import randint
 from praetorian_cli.sdk.chariot import Chariot
 from praetorian_cli.sdk.keychain import Keychain
 from praetorian_cli.sdk.model.globals import Risk, Preseed
-from praetorian_cli.sdk.model.utils import risk_key, asset_key, ad_domain_key, attribute_key, seed_key, preseed_key, setting_key, configuration_key
+from praetorian_cli.sdk.model.utils import risk_key, asset_key, ad_domain_key, attribute_key, seed_asset_key, preseed_key, setting_key, configuration_key
 
 
 def epoch_micro():
@@ -27,14 +27,26 @@ def random_dns():
 def random_ad_domain():
     return f'test-{epoch_micro()}.local'
 
+def random_object_id():
+    domain_id_1 = randint(1000000000, 4294967295)  # Start from 1 billion for realism
+    domain_id_2 = randint(1000000000, 4294967295)
+    domain_id_3 = randint(1000000000, 4294967295)
+
+    # Generate a random relative identifier (RID)
+    # Common ranges: 500-999 for built-in accounts, 1000+ for user accounts
+    relative_id = randint(1000, 999999)
+    return f"S-1-5-21-{domain_id_1}-{domain_id_2}-{domain_id_3}-{relative_id}"
+
+
 def make_test_values(o):
     o.asset_dns = random_dns()
     o.asset_name = random_ip()
     o.asset_key = asset_key(o.asset_dns, o.asset_name)
     o.ad_domain_name = random_ad_domain()
-    o.ad_domain_key = ad_domain_key(o.ad_domain_name, o.ad_domain_name)
-    o.seed_dns = random_dns()
-    o.seed_key = seed_key('domain', o.seed_dns)
+    o.ad_object_id = random_object_id()
+    o.ad_domain_key = ad_domain_key(o.ad_domain_name, o.ad_object_id)
+    o.seed_asset_dns = random_dns()
+    o.seed_asset_key = seed_asset_key(o.seed_asset_dns)
     o.risk_name = f'test-risk-name-{epoch_micro()}'
     o.risk_key = risk_key(o.asset_dns, o.risk_name)
     o.comment = f'Test comment {epoch_micro()}'

praetorian_cli/ui/__init__.py

@@ -0,0 +1,3 @@
+"""User interface (UI) modules for interactive consoles and TUI components."""
+
+

praetorian_cli/ui/aegis/__init__.py

@@ -0,0 +1,5 @@
+"""Aegis interactive console (TUI) package."""
+
+from .menu import run_aegis_menu, AegisMenu  # re-export for convenience
+
+

praetorian_cli/ui/aegis/commands/__init__.py

@@ -0,0 +1,2 @@
+"""Command handlers for Aegis TUI."""
+

praetorian_cli/ui/aegis/commands/help.py

@@ -0,0 +1,81 @@
+from rich.table import Table
+from rich.box import MINIMAL
+from ..constants import DEFAULT_COLORS
+
+
+
+
+
+def handle_help(menu, args):
+    """Show help for commands or a specific command."""
+    colors = getattr(menu, 'colors', DEFAULT_COLORS)
+    if args and args[0] in ['ssh', 'list', 'info', 'job', 'set']:
+        menu.console.print(f"\nHelp for '{args[0]}' command - see main help for details\n")
+        menu.pause()
+        return
+
+    commands_table = Table(
+        show_header=True,
+        header_style=f"bold {colors['primary']}",
+        border_style=colors['dim'],
+        box=MINIMAL,
+        show_lines=False,
+        padding=(0, 2),
+        pad_edge=False
+    )
+
+    commands_table.add_column("COMMAND", style=f"bold {colors['success']}", min_width=20, no_wrap=True)
+    commands_table.add_column("DESCRIPTION", style="white", no_wrap=False)
+
+    commands_table.add_row("set <id>", "Select an agent by number, client_id, or hostname")
+    commands_table.add_row("list [--all]", "List online agents (--all shows offline too)")
+    commands_table.add_row("ssh [options]", "SSH to selected agent (use 'ssh --help' for options)")
+    commands_table.add_row("info [--raw]", "Show detailed information for selected agent")
+    commands_table.add_row("job list", "List recent jobs for selected agent")
+    commands_table.add_row("job capabilities [--details]", "List available capabilities")
+    commands_table.add_row("job run <capability>", "Run capability on selected agent")
+    commands_table.add_row("reload", "Refresh agent list from server")
+    commands_table.add_row("help [command]", "Show this help or command-specific help")
+    commands_table.add_row("clear", "Clear terminal screen")
+    commands_table.add_row("quit / exit", "Exit the interface")
+
+    menu.console.print()
+    menu.console.print("  Available Commands")
+    menu.console.print()
+    menu.console.print(commands_table)
+
+    examples_table = Table(
+        show_header=True,
+        header_style=f"bold {colors['warning']}",
+        border_style=colors['dim'],
+        box=MINIMAL,
+        show_lines=False,
+        padding=(0, 2),
+        pad_edge=False
+    )
+
+    examples_table.add_column("EXAMPLE", style=f"bold {colors['accent']}", min_width=25, no_wrap=True)
+    examples_table.add_column("DESCRIPTION", style=f"{colors['dim']}", no_wrap=False)
+
+    examples_table.add_row("set 1", "Select first agent")
+    examples_table.add_row("set abc", "Select agent by hostname")
+    examples_table.add_row("ssh -D 1080", "SSH with SOCKS proxy on port 1080")
+    examples_table.add_row("list --all", "Show all agents including offline")
+    examples_table.add_row("job list", "List recent jobs")
+    examples_table.add_row("job capabilities", "List available capabilities")
+    examples_table.add_row("job caps --details", "Show full capability descriptions")
+    examples_table.add_row("job run windows-enum", "Run capability on selected agent")
+    examples_table.add_row("info", "Show agent details")
+    examples_table.add_row("info --raw", "Show raw agent data (JSON format)")
+
+    menu.console.print()
+    menu.console.print("  Examples")
+    menu.console.print()
+    menu.console.print(examples_table)
+    menu.console.print()
+    menu.pause()
+
+
+def complete(menu, text, tokens):
+    # Suggest commands after 'help '
+    return [c for c in menu.commands if c.startswith(text)]

praetorian_cli/ui/aegis/commands/info.py

@@ -0,0 +1,136 @@
+def handle_info(menu, args):
+    """Show detailed information for the selected agent."""
+    if not menu.selected_agent:
+        menu.console.print("\n  No agent selected. Use 'set <id>' to select one.\n")
+        menu.pause()
+        return
+
+    # Check for raw flag
+    raw = ('--raw' in args) or ('-r' in args)
+    
+    try:
+        _show_agent_info(menu, menu.selected_agent, raw=raw)
+    except Exception as e:
+        menu.console.print(f"[red]Error getting agent info: {e}[/red]")
+        menu.pause()
+
+
+def _show_agent_info(menu, agent, raw=False):
+    """Show detailed agent info with clean formatting"""
+    import json
+    from datetime import datetime
+    
+    colors = getattr(menu, 'colors', {})
+    hostname = agent.hostname or 'Unknown'
+    
+    # Clear screen and show header
+    menu.clear_screen()
+    menu.console.print()
+    menu.console.print(f"  [{colors.get('primary', 'cyan')}]Agent Details[/{colors.get('primary', 'cyan')}]")
+    menu.console.print()
+
+    if raw:
+        # Raw JSON dump with minimal styling
+        menu.console.print(f"  [{colors.get('dim', 'dim')}]Raw agent data:[/{colors.get('dim', 'dim')}]")
+        menu.console.print()
+        # Convert agent to dict for JSON serialization
+        agent_dict = agent.to_dict() if hasattr(agent, 'to_dict') else agent.__dict__
+        json_lines = json.dumps(agent_dict, default=str, indent=2).split('\n')
+        for line in json_lines:
+            menu.console.print(f"  {line}")
+        menu.pause()
+        return
+    
+    # Gather agent info
+    os_info = (agent.os or 'unknown').lower()
+    os_version = agent.os_version or ''
+    architecture = agent.architecture or 'Unknown'
+    fqdn = agent.fqdn or 'N/A'
+    client_id = agent.client_id or 'N/A'
+    last_seen = agent.last_seen_at or 0
+    health = agent.health_check
+    cf_status = health.cloudflared_status if health else None
+    
+    # Get network interfaces and extract IP addresses
+    network_interfaces = agent.network_interfaces or []
+    ip_info = []
+    
+    # Extract IPs from network interfaces
+    if network_interfaces:
+        for interface in network_interfaces:
+            if hasattr(interface, 'name'):  # NetworkInterface object
+                # Get interface name
+                iface_name = interface.name or ''
+                
+                # Get IP addresses from the ip_addresses field (it's a list)
+                ip_addresses = interface.ip_addresses or []
+                
+                # Add each IP with interface name
+                for ip in ip_addresses:
+                    if ip:  # Skip empty strings
+                        if iface_name and iface_name != 'lo':  # Skip loopback
+                            ip_info.append(f"{ip} ({iface_name})")
+                        elif iface_name != 'lo':
+                            ip_info.append(ip)
+    
+    # Compute status
+    current_time = datetime.now().timestamp()
+    if last_seen > 0:
+        last_seen_seconds = last_seen / 1000000 if last_seen > 1000000000000 else last_seen
+        is_online = (current_time - last_seen_seconds) < 60
+        last_seen_str = datetime.fromtimestamp(last_seen_seconds).strftime("%Y-%m-%d %H:%M:%S")
+        if is_online:
+            status_text = f"[{colors.get('success', 'green')}]● online[/{colors.get('success', 'green')}]"
+        else:
+            status_text = f"[{colors.get('error', 'red')}]○ offline[/{colors.get('error', 'red')}]"
+    else:
+        last_seen_str = "never"
+        status_text = f"[{colors.get('error', 'red')}]○ offline[/{colors.get('error', 'red')}]"
+        is_online = False
+
+    # Simple, clean output
+    menu.console.print(f"  [bold white]{hostname}[/bold white]  {status_text}")
+    menu.console.print(f"  [{colors.get('dim', 'dim')}]{fqdn}[/{colors.get('dim', 'dim')}]")
+    menu.console.print()
+    
+    # System info
+    menu.console.print(f"  [{colors.get('dim', 'dim')}]System[/{colors.get('dim', 'dim')}]")
+    menu.console.print(f"    OS:           {os_info} {os_version}")
+    menu.console.print(f"    Architecture: {architecture}")
+    if ip_info:
+        if len(ip_info) == 1:
+            menu.console.print(f"    IP:           {ip_info[0]}")
+        else:
+            menu.console.print(f"    IPs:          {ip_info[0]}")
+            for ip in ip_info[1:]:
+                menu.console.print(f"                  {ip}")
+    menu.console.print(f"    Client ID:    {client_id[:40]}...")
+    menu.console.print(f"    Last seen:    {last_seen_str}")
+    menu.console.print()
+    
+    # Tunnel info
+    if cf_status:
+        tunnel_name = cf_status.tunnel_name or 'N/A'
+        public_hostname = cf_status.hostname or 'N/A'
+        authorized_users = cf_status.authorized_users or ''
+        
+        menu.console.print(f"  [{colors.get('warning', 'yellow')}]Tunnel active[/{colors.get('warning', 'yellow')}]")
+        menu.console.print(f"    Name:      {tunnel_name}")
+        menu.console.print(f"    Public:    {public_hostname}")
+        
+        if authorized_users:
+            users_list = [u.strip() for u in authorized_users.split(',')]
+            menu.console.print(f"    Authorized: {', '.join(users_list)}")
+    else:
+        menu.console.print(f"  [{colors.get('dim', 'dim')}]No tunnel configured[/{colors.get('dim', 'dim')}]")
+    
+    menu.console.print()
+    menu.pause()
+
+
+def complete(menu, text, tokens):
+    """Command completion for info command"""
+    opts = ['--raw', '-r']
+    if len(tokens) <= 2:
+        return [o for o in opts if o.startswith(text)]
+    return []