fantomas 0.1.2__py3-none-any.whl

fantomas/proxy.py

@@ -0,0 +1,193 @@
+import base64
+import asyncio
+import time
+import os
+import subprocess
+from billiard import Process, Queue
+from mitmproxy import http
+from mitmproxy.tools.dump import DumpMaster
+from mitmproxy.options import Options
+from urllib.parse import urlparse
+import requests
+from .utils import get_value_or_default, load_config
+
+class Proxy:
+    def __init__(self,config_proxy=None):
+        self.config_proxy = config_proxy
+        self.upstream_enabled = 0
+        self.upstream_provider = ""
+        self.upstream_request_type = "broker"
+        self.proxy_process = None
+        self.count_data_queue = None
+        self.modifiers_array = []
+        self.retrievers_array = []
+        self.modifiers_request_array = []
+
+        if self.config_proxy:
+            self._parse_config_proxy()
+
+
+    def launch_proxy(self):
+        self._clean_previous_old_proxy()
+        time.sleep(0.3)
+
+        if self.upstream_enabled:
+            upstream_proxy_url = self.fetch_upstream_proxy()
+        else:
+            upstream_proxy_url = None
+        
+        self.set_data_queue()
+            
+        self.proxy_process = SubprocessedMitmProxy(
+            upstream_proxy_url=upstream_proxy_url,
+            count_data_queue=self.count_data_queue,
+            upstream_enabled=self.upstream_enabled,
+            modifiers_array = self.modifiers_array,
+            retrievers_array=self.retrievers_array,
+            modifiers_request_array=self.modifiers_request_array
+        )
+        self.proxy_process.start()
+        return self
+
+    def exit_local_proxy(self):
+        self.proxy_process.terminate()
+        
+    def switch_upstream_proxy(self):
+        self.exit_local_proxy()
+        self.launch_proxy()
+    
+    def set_data_queue(self):
+         self.count_data_queue = Queue()
+         return self.count_data_queue
+            
+    def get_data_count(self):
+         for _ in range(self.count_data_queue.qsize()):
+             element = self.count_data_queue.get()
+         return element
+
+    def retrieve(self,queue_id):
+        for retriever in self.retrievers_array:
+            if retriever["queue_id"]==queue_id:
+                for _ in range(retriever["queue"].qsize()):
+                    element = retriever["queue"].get()
+                return element
+    
+    def _clean_previous_old_proxy(self):
+        result = subprocess.run(f"lsof -t -i:{8081}", shell=True, capture_output=True, text=True)
+        if result.stdout.strip():
+            pid = result.stdout.strip()            
+            os.system(f"kill -9 {pid}")
+        else:
+            pass
+
+
+    def _parse_config_proxy(self):
+        self.config_proxy = load_config(self.config_proxy) if isinstance(self.config_proxy, str) else self.config_proxy
+        self.enabled = get_value_or_default(self.config_proxy.get("proxy_enabled"), self.upstream_enabled)
+        self.upstream_enabled = get_value_or_default(self.config_proxy.get("proxy_upstream_enabled"), self.upstream_enabled)
+        self.upstream_provider = get_value_or_default(self.config_proxy.get("proxy_upstream_provider"), self.upstream_provider)
+        self.upstream_request_type = get_value_or_default(self.config_proxy.get("proxy_upstream_request_type"), self.upstream_request_type)
+
+
+    def fetch_upstream_proxy(self):
+        return UpstreamProxyFetcher(self.upstream_provider,self.upstream_request_type).fetch_proxy()
+    
+    def add_retriever(self,queue_id: str,retriever_function):
+        queue = Queue()
+        proxy_queue_dict = {"queue_id":queue_id,"queue":queue,"retriever_function":retriever_function}
+        self.retrievers_array.append(proxy_queue_dict)
+    
+    def add_modifier(self,modifier_function):
+        self.modifiers_array.append(modifier_function)
+    
+    def add_request_modifier(self,modifier_request_function):
+        self.modifiers_request_array.append(modifier_request_function)
+
+class SubprocessedMitmProxy(Process):
+    def __init__(self, *, upstream_proxy_url: str, count_data_queue, upstream_enabled,modifiers_array,retrievers_array,modifiers_request_array):
+        super().__init__()
+        self.upstream_proxy_url = upstream_proxy_url
+        self.count_data_queue = count_data_queue
+        self.upstream_enabled = upstream_enabled
+        self.modifiers_array = modifiers_array
+        self.retrievers_array = retrievers_array
+        self.modifiers_request_array = modifiers_request_array
+
+    def run(self):
+        asyncio.run(self.asyncio_run())
+
+    async def asyncio_run(self):
+        upstream_mode = "upstream:http://"+self.upstream_proxy_url.split('@')[1]
+        if self.upstream_enabled:
+            opts = Options(listen_port=8081, mode=[upstream_mode], ssl_insecure=False)
+        else:
+            opts = Options(listen_port=8081, ssl_insecure=False)
+        master = DumpMaster(opts, with_termlog=False, with_dumper=False)
+        master.addons.add(ProxyAddOn(self.upstream_proxy_url, self.count_data_queue, self.modifiers_array, self.retrievers_array, self.modifiers_request_array))
+        await master.run()
+
+
+class ProxyAddOn:
+    def __init__(self, upstream_proxy_url, count_data_queue, modifiers_array,retrievers_array,modifiers_request_array):
+        self.total_data = 0
+        self.upstream_proxy_url = upstream_proxy_url
+        self.count_data_queue = count_data_queue
+        self.proxy_parsed_url = None
+        self.modifiers_array = modifiers_array
+        self.retrievers_array = retrievers_array
+        self.modifiers_request_array = modifiers_request_array
+
+    def http_connect_upstream(self, flow: http.HTTPFlow):
+        self.proxy_parsed_url = urlparse(self.upstream_proxy_url)
+        if self.proxy_parsed_url.username or self.proxy_parsed_url.password:
+            credentials = f"{self.proxy_parsed_url.username}:{self.proxy_parsed_url.password}"
+            encoded_credentials = base64.b64encode(credentials.encode()).decode()
+            flow.request.headers["proxy-authorization"] = f"Basic {encoded_credentials}"
+
+    def response(self, flow: http.HTTPFlow) -> None:
+
+        #Data Count
+        if flow.response:
+            content_length = flow.response.headers.get('Content-Length')
+            if content_length:
+                 self.total_data += int(content_length)
+                 self.count_data_queue.put(self.total_data)
+
+        #Executing retrievers
+        for j in self.retrievers_array:
+            j["retriever_function"](flow, j["queue"])
+
+        
+        #Executing modifiers
+        for i in self.modifiers_array:
+            i(flow)
+
+    def request(self, flow: http.HTTPFlow) -> None:
+        for i in self.modifiers_request_array:
+            i(flow)
+        
+class UpstreamProxyFetcher:
+    def __init__(self, provider, upstream_request_type):
+        self.ip = None
+        self.url = None
+        self.provider = provider
+        self.upstream_request_type = upstream_request_type
+
+    def fetch_proxy(self):
+        if self.upstream_request_type == "broker":
+            response = requests.get(self.provider)
+            if response.status_code == 200:
+                result = response.json()
+                self.ip = result.get('ip', 'No IP returned')
+                self.url = result.get('url', 'No URL returned')
+            else:
+                raise Exception(f"Request failed with status code {response.status_code}")
+        elif self.upstream_request_type == "direct":
+            self.url = self.provider
+
+        return self.url
+
+
+    
+                
+

fantomas/random_sleeper.py

@@ -0,0 +1,6 @@
+import time
+import random
+
+
+def rsleep (sleeping_time, activate_random=True,factor=None):
+    time.sleep(sleeping_time)

fantomas/raw_chrome.py

@@ -0,0 +1,31 @@
+import os
+import subprocess
+import threading
+import socket
+
+class RawChrome:
+    def __init__(self, display_number, browser_options, temp_path):
+        self.display_number = display_number
+        self.port = self.find_free_port()
+        self.temp_path = temp_path
+        self.browser_options = browser_options
+
+    def run_app_with_gpu(self):
+        env = os.environ.copy()
+        env["DISPLAY"] = self.display_number
+
+        command = ["vglrun","google-chrome","--user-data-dir="+str(self.temp_path),"--remote-debugging-port="+str(self.port)]
+        command.extend(self.browser_options)
+
+        subprocess.run(command, env=env)
+
+    def start_in_thread(self):
+        thread = threading.Thread(target=self.run_app_with_gpu, daemon=True)
+        thread.start()
+        return {"thread":thread, "port":self.port, "display":self.display_number}
+
+    @staticmethod
+    def find_free_port():
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(('', 0))  # Let the OS choose a free port
+            return s.getsockname()[1]  # Get the assigned port

fantomas/raw_screen.py

@@ -0,0 +1,47 @@
+import subprocess
+import os
+import time
+import signal
+import random
+
+
+class RawScreen:
+    def __init__(self):
+        self.display_number = self.attribute_display_number()
+        self.screen_res = "1900x1060"
+
+    def attribute_display_number(self):
+        x_sockets = os.listdir("/tmp/.X11-unix/")
+        x_displays = [int(s[1:]) for s in x_sockets if s.startswith("X")]
+        print(x_displays)
+        while True:
+            x = random.randint(1,1000) 
+            if x not in x_displays:
+                self.display_number = ":"+str(x)
+                return ":"+str(x)
+
+    def launch_xephyr(self):
+        
+        print(f"Lancement de Xephyr sur DISPLAY {self.display_number}...")
+        self.xephyr_process = subprocess.Popen(["Xephyr", self.display_number, "-screen", self.screen_res], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return self.display_number
+    
+    def wait_for_display_ready(self, timeout=5):
+        print("Attente de l'initialisation de Xephyr...")
+        for _ in range(timeout * 10):
+            result = subprocess.run(["xdpyinfo", "-display", self.display_number],
+                                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            if result.returncode == 0:
+                print("Xephyr est prêt.")
+                return True
+            time.sleep(0.1)
+        raise RuntimeError("Timeout: Xephyr ne s'est pas lancé correctement.")
+    
+    def exit_xephyr(self):
+        print("Fermeture de Xephyr...")
+        self.xephyr_process.send_signal(signal.SIGTERM)
+        self.xephyr_process.wait()
+
+
+
+

fantomas/screen.py

@@ -0,0 +1,41 @@
+import subprocess
+import io
+from pyvirtualdisplay import Display
+from .utils import get_value_or_default, load_config
+
+
+class Screen:
+    def __init__(self, screen_params=None):
+        self.screen_params = screen_params
+        self.visible = 1
+        self.height = 1200
+        self.width = 800
+        self.display = None
+        if self.screen_params:
+            self.parse_screen_params()
+
+    def parse_screen_params(self):
+        self.screen_params = load_config(self.screen_params)
+        self.visible = get_value_or_default(self.screen_params.get("screen_visible"), self.visible)
+        self.height = get_value_or_default(self.screen_params.get("screen_height"), self.height)
+        self.width = get_value_or_default(self.screen_params.get("screen_width"), self.width)
+    
+    def screenshot_screen(self):
+        screenshot_process = subprocess.run(
+        ["import", "-window", "root", "png:-"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL)
+        if not screenshot_process.stdout:
+                raise ValueError("Empty Screenshot")
+
+        image_bytes = io.BytesIO(screenshot_process.stdout)
+        image_bytes.seek(0)
+        return image_bytes
+    
+    def launch_screen(self):
+        self.display = Display(visible=self.visible, size=(self.width, self.height))
+        self.display.start()
+        return self
+    
+    def stop_screen(self):
+        self.display.stop()

fantomas/secondary_flow.py

@@ -0,0 +1,27 @@
+from .fantomas_no_driver import FantomasNoDriver
+import time
+
+
+class SecondaryFlow():
+
+    def __init__(self, sf_ctx,sf_function):
+        self.sf_ctx = sf_ctx
+        self.sf_no_driver_instance = sf_ctx.sf_no_driver_instance
+        self.sf_browser = sf_ctx.sf_browser
+        self.sf_function = sf_function
+
+    def launch_secondary_flow(self):
+        import multiprocessing
+        sf_queue = multiprocessing.Queue()
+        sf_process = multiprocessing.Process(target=self.launch_secondary_browser_sync, args=(sf_queue,self.sf_function))
+        sf_process.start()
+        sf_process.join()
+        queue_result = sf_queue.get()
+        return queue_result
+    
+    def launch_secondary_browser_sync(self, sf_queue,sf_function):
+        self.sf_no_driver_instance.loop().run_until_complete(self.launch_secondary_browser_async(sf_queue,sf_function))
+        
+    async def launch_secondary_browser_async(self,sf_queue,sf_function):
+        await sf_function(self.sf_browser, self.sf_ctx, sf_queue)
+    

fantomas/utils.py

@@ -0,0 +1,21 @@
+import json
+
+
+def get_value_or_default(value, default):
+    """Return value if not None, otherwise return default."""
+    return value if value is not None else default
+
+
+def load_config(config):
+    """Load configuration from file path or return dict as-is.
+
+    Args:
+        config: Either a file path (str) to a JSON file or a dict
+
+    Returns:
+        dict: The configuration dictionary
+    """
+    if isinstance(config, str):
+        with open(config, 'r', encoding='utf-8') as json_file:
+            return json.load(json_file)
+    return config

fantomas/virtual_cursor_path.py

@@ -0,0 +1,76 @@
+import numpy as np
+
+class VirtualCursorPath:
+    def __init__(self):
+        pass
+
+    def get_virtual_cursor_path(self,current_position,desired_position,viewport_width,viewport_height):
+        path = self._calculate_path(current_position[0],current_position[1],desired_position[0],desired_position[1],viewport_width,viewport_height)
+        path[0]=self._avoid_bounds(path[0], 0,viewport_width)
+        path[1]=self._avoid_bounds(path[1], 0,viewport_height)
+        return path
+
+
+    @staticmethod
+    def _avoid_bounds(array_of_cursor_coordinates,minima_coordinate,maxima_coordinate):
+        array_avoiding_minima = [1 if cursor_coordinate == minima_coordinate else cursor_coordinate for cursor_coordinate in array_of_cursor_coordinates]
+        array_avoiding_maxima = [maxima_coordinate-1 if cursor_coordinate == maxima_coordinate else cursor_coordinate for cursor_coordinate in array_avoiding_minima]
+        return array_avoiding_maxima
+
+    @staticmethod
+    def _calculate_path(start_x, start_y,dest_x, dest_y, x_max, y_max, G_0=5, W_0=10, M_0=15, D_0=30):
+        sqrt3 = np.sqrt(3)
+        sqrt5 = np.sqrt(5)
+        x_array = []
+        y_array = []
+        current_x,current_y = start_x,start_y
+        v_x = v_y = W_x = W_y = 0
+        while True:
+            dist = np.hypot(dest_x - start_x, dest_y - start_y)
+            if dist < 1:
+                break
+
+            # Force calculation
+            W_mag = min(W_0, dist)
+            if dist >= D_0:
+                W_x = W_x / sqrt3 + (2 * np.random.random() - 1) * W_mag / sqrt5
+                W_y = W_y / sqrt3 + (2 * np.random.random() - 1) * W_mag / sqrt5
+            else:
+                W_x /= sqrt3
+                W_y /= sqrt3
+                if M_0 < 3:
+                    M_0 = np.random.random() * 3 + 3
+                else:
+                    M_0 /= sqrt5
+
+            # Speed calculation
+            v_x += (W_x + G_0 * (dest_x - start_x) / dist)
+            v_y += (W_y + G_0 * (dest_y - start_y) / dist)
+
+            # Limit the maximum speed
+            v_mag = np.hypot(v_x, v_y)
+            if v_mag > M_0:
+                v_x = (v_x / v_mag) * M_0
+                v_y = (v_y / v_mag) * M_0
+
+            # Update positions
+            start_x += v_x
+            start_y += v_y
+            
+            # Limit positions to [0, x_max] and [0, y_max]
+            start_x = max(0, min(start_x, x_max))
+            start_y = max(0, min(start_y, y_max))
+            
+            move_x = int(np.round(start_x))
+            move_y = int(np.round(start_y))
+
+            if current_x != move_x or current_y != move_y:
+                current_x = move_x
+                current_y = move_y
+                x_array.append(current_x)
+                y_array.append(current_y)
+        return [x_array,y_array]
+    
+
+if __name__ == "__main__":
+    path = VirtualCursorPath().get_virtual_cursor_path([0,0],[100,200],1000,1000)