chromate-rb 0.0.1.pre → 0.0.3.pre

data/lib/chromate/elements/tags.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'chromate/element'
+
+module Chromate
+  module Elements
+    module Tags
+      def select?
+        tag_name == 'select'
+      end
+
+      def option?
+        tag_name == 'option'
+      end
+
+      def radio?
+        tag_name == 'input' && attributes['type'] == 'radio'
+      end
+
+      def checkbox?
+        tag_name == 'input' && attributes['type'] == 'checkbox'
+      end
+
+      def base?
+        !select? && !option? && !radio? && !checkbox?
+      end
+    end
+  end
+end

data/lib/chromate/exceptions.rb

@@ -5,5 +5,7 @@ module Chromate
     class ChromateError < StandardError; end
     class InvalidBrowserError < ChromateError; end
     class InvalidPlatformError < ChromateError; end
+    class ConnectionTimeoutError < StandardError; end
+    class DebugURLError < StandardError; end
   end
 end

data/lib/chromate/files/agents.json

@@ -0,0 +1,11 @@
+{
+  "windows": [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36"
+  ],
+  "mac": [
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36"
+  ],
+  "linux": [
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36"
+  ]
+}

data/lib/chromate/files/stealth.js

@@ -0,0 +1,199 @@
+/**
+ * Script de Stealth pour masquer l'automatisation
+ *
+ * Ce script est destiné à être injecté via la commande
+ * Page.addScriptToEvaluateOnNewDocument afin qu'il s'exécute
+ * avant le chargement du contenu de la page.
+ *
+ * Il redéfinit plusieurs propriétés du navigateur pour
+ * réduire les indices susceptibles d'indiquer qu'une automatisation est en cours.
+ */
+(() => {
+  'use strict';
+
+  // 1) Masquer navigator.webdriver
+  (function removeWebDriverProperty() {
+    // 1) Récupérer le prototype de Navigator
+    const proto = Object.getPrototypeOf(navigator);
+
+    // Vérifier si la propriété webdriver existe sur le prototype
+    if ('webdriver' in proto) {
+      try {
+        // 2) Tenter de supprimer la propriété si elle est configurable
+        const webdriverDescriptor = Object.getOwnPropertyDescriptor(proto, 'webdriver');
+        if (webdriverDescriptor && webdriverDescriptor.configurable) {
+          delete proto.webdriver;
+        } else {
+          // 3) Sinon, on essaye de la redéfinir pour qu'elle retourne undefined et ne soit pas énumérable
+          Object.defineProperty(proto, 'webdriver', {
+            get: () => undefined,
+            configurable: false, // on la rend non-configurable pour éviter d'autres re-déclarations
+            enumerable: false
+          });
+        }
+      } catch (err) {
+        // 4) En cas d'échec (non-configurable), on peut tenter un hack sur l'opérateur 'in'
+        //    => ATTENTION : ceci peut avoir des effets de bord dans d'autres scripts
+        patchInOperatorForNavigator('webdriver');
+      }
+    } else {
+      // Si la propriété n'existe pas sur le prototype, vérifier si elle existe directement sur navigator
+      if ('webdriver' in navigator) {
+        try {
+          delete navigator.webdriver;
+        } catch (err) {
+          patchInOperatorForNavigator('webdriver');
+        }
+      }
+    }
+
+    /**
+     * Hack optionnel pour empêcher `'webdriver' in navigator` de renvoyer true.
+     * On redéfinit la méthode hasOwnProperty / l'opérateur in pour l'objet navigator.
+     * Cette approche peut avoir des effets de bord, donc à utiliser en dernier recours.
+     */
+    function patchInOperatorForNavigator(propName) {
+      const originalHasOwn = Object.prototype.hasOwnProperty;
+      Object.prototype.hasOwnProperty = function (property) {
+        // Si c'est navigator et qu'on teste la propriété 'webdriver', on la cache
+        if (this === navigator && property === propName) {
+          return false;
+        }
+        return originalHasOwn.call(this, property);
+      };
+
+      // Variante plus radicale : proxyfier l'objet navigator pour intercepter l'opérateur 'in'.
+      // (Non présenté ici, car encore plus invasif.)
+    }
+  })();
+
+  // 2) Surcharger navigator.permissions.query (pour ne pas renvoyer "default")
+  if (navigator.permissions && navigator.permissions.query) {
+    const originalQuery = navigator.permissions.query;
+    navigator.permissions.query = (params) => {
+      // Ex. : si on interroge les notifications, on renvoie "granted"
+      if (params.name === 'notifications') {
+        return Promise.resolve({ state: 'granted' });
+      }
+      // Pour les autres, on tente la requête d'origine, sinon "granted"
+      return originalQuery(params).catch(() => ({ state: 'granted' }));
+    };
+  }
+
+  // 3) Créer un PluginArray réaliste
+  //    - On réutilise le prototype existant pour ne pas éveiller de soupçons
+  const pluginArrayProto = Object.getPrototypeOf(navigator.plugins);
+  function FakePlugin(name, description, filename) {
+    this.name = name;
+    this.description = description;
+    this.filename = filename;
+  }
+  // On pointe vers Plugin.prototype pour se comporter comme un plugin "réel"
+  FakePlugin.prototype = Plugin.prototype;
+
+  const fakePlugins = [
+    new FakePlugin('Chrome PDF Plugin', 'Portable Document Format', 'internal-pdf-viewer'),
+    new FakePlugin('Chrome PDF Viewer', '', 'mhjfbmdgcfjbbpaeojofohoefgiehjai')
+  ];
+
+  Object.defineProperty(navigator, 'plugins', {
+    get() {
+      const pluginArray = Object.create(pluginArrayProto);
+      // On copie les faux plugins dans l’objet
+      for (let i = 0; i < fakePlugins.length; i++) {
+        pluginArray[i] = fakePlugins[i];
+      }
+      pluginArray.length = fakePlugins.length;
+      return pluginArray;
+    }
+  });
+
+  // 4) Aligner navigator.languages avec vos entêtes Accept-Language
+  Object.defineProperty(navigator, 'languages', {
+    get: () => ['en-US', 'en'],
+    configurable: true
+  });
+
+  // 5) Override de getContext pour forcer un contexte WebGL factice
+  const originalGetContext = HTMLCanvasElement.prototype.getContext;
+  HTMLCanvasElement.prototype.getContext = function (type, ...args) {
+    if (['webgl', 'experimental-webgl', 'webgl2'].includes(type)) {
+      // Tenter d'obtenir le contexte natif (au cas où)
+      let ctx = originalGetContext.apply(this, [type, ...args]);
+      if (ctx) {
+        // Si un contexte natif est obtenu, retourner ce contexte
+        return ctx;
+      }
+      console.log("No native WebGL context found, returning fake context");
+      // Forcer la création d'un contexte factice
+      const proto = (window.WebGLRenderingContext && window.WebGLRenderingContext.prototype) || {};
+      const fakeContext = Object.create(proto);
+
+      fakeContext.getParameter = function (param) {
+        if (param === 37445) return 'Intel Inc.';
+        if (param === 37446) return 'Intel Iris OpenGL Engine';
+        return null;
+      };
+      fakeContext.getSupportedExtensions = function () {
+        return ['WEBGL_debug_renderer_info'];
+      };
+      fakeContext.getExtension = function (name) {
+        if (name === 'WEBGL_debug_renderer_info') {
+          return { UNMASKED_VENDOR_WEBGL: 37445, UNMASKED_RENDERER_WEBGL: 37446 };
+        }
+        return null;
+      };
+
+      // Ajout de stubs pour d'autres méthodes WebGL essentielles
+      fakeContext.clear = function () { };
+      fakeContext.clearColor = function () { };
+      fakeContext.viewport = function () { };
+      fakeContext.createShader = function () { return {}; };
+      fakeContext.shaderSource = function () { };
+      fakeContext.compileShader = function () { };
+      fakeContext.createProgram = function () { return {}; };
+      fakeContext.attachShader = function () { };
+      fakeContext.linkProgram = function () { };
+      fakeContext.useProgram = function () { };
+
+      return fakeContext;
+    }
+    return originalGetContext.apply(this, [type, ...args]);
+  };
+
+  // 6) Optionnel : Override de toDataURL pour renvoyer une image fixe
+  const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
+  HTMLCanvasElement.prototype.toDataURL = function (...args) {
+    const gl = this.getContext('webgl') || this.getContext('experimental-webgl') || this.getContext('webgl2');
+    if (gl) {
+      return "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=";
+    }
+    return originalToDataURL.apply(this, args);
+  };
+
+  // 7) Correction des dimensions d’images
+  Object.defineProperty(HTMLImageElement.prototype, 'naturalWidth', {
+    get() { return 128; }
+  });
+  Object.defineProperty(HTMLImageElement.prototype, 'naturalHeight', {
+    get() { return 128; }
+  });
+
+  // 8) Randomisation pour varier l'injection
+  (function () {
+    const randomSuffix = Math.random().toString(36).substring(2);
+    document.documentElement.setAttribute('data-stealth', randomSuffix);
+  })();
+
+  // 9) Masquer la modification des fonctions natives
+  (function () {
+    const originalToString = Function.prototype.toString;
+    Function.prototype.toString = function () {
+      if (this === navigator.permissions.query) {
+        return "function query() { [native code] }";
+      }
+      return originalToString.apply(this, arguments);
+    };
+  })();
+
+})();

data/lib/chromate/hardwares/keyboard_controller.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Hardwares
+    class KeyboardController
+      attr_accessor :element, :client
+
+      # @param [Chromate::Element] element
+      # @param [Chromate::Client] client
+      def initialize(element: nil, client: nil)
+        @element        = element
+        @client         = client
+        @type_interval  = rand(0.05..0.1)
+      end
+
+      # @param [Chromate::Element] element
+      # @return [self]
+      def set_element(element) # rubocop:disable Naming/AccessorMethodName
+        @element = element
+        @type_interval = rand(0.05..0.1)
+
+        self
+      end
+
+      # @param [String] key
+      # @return [self]
+      def press_key(_key)
+        raise NotImplementedError
+      end
+
+      # @param [String] text
+      # @return [self]
+      def type(text)
+        text.each_char do |char|
+          sleep(rand(0.01..0.05)) if rand(10).zero?
+
+          press_key(char)
+          sleep(@type_interval)
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/chromate/hardwares/keyboards/virtual_controller.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Hardwares
+    module Keyboards
+      class VirtualController < Chromate::Hardwares::KeyboardController
+        def press_key(key = 'Enter')
+          params = {
+            key: key,
+            code: key_to_code(key),
+            windowsVirtualKeyCode: key_to_virtual_code(key)
+          }
+
+          params[:text] = key if key.length == 1
+
+          # Dispatch keyDown event
+          client.send_message('Input.dispatchKeyEvent', params.merge(type: 'keyDown'))
+
+          # Dispatch keyUp event
+          client.send_message('Input.dispatchKeyEvent', params.merge(type: 'keyUp'))
+
+          self
+        end
+
+        private
+
+        # @param [String] key
+        # @return [String]
+        def key_to_code(key)
+          case key
+          when 'Enter' then 'Enter'
+          when 'Tab' then 'Tab'
+          when 'Backspace' then 'Backspace'
+          when 'Delete' then 'Delete'
+          when 'Escape' then 'Escape'
+          when 'ArrowLeft' then 'ArrowLeft'
+          when 'ArrowRight' then 'ArrowRight'
+          when 'ArrowUp' then 'ArrowUp'
+          when 'ArrowDown' then 'ArrowDown'
+          else
+            "Key#{key.upcase}"
+          end
+        end
+
+        # @param [String] key
+        # @return [Integer]
+        def key_to_virtual_code(key)
+          case key
+          when 'Enter' then 0x0D
+          when 'Tab' then 0x09
+          when 'Backspace' then 0x08
+          when 'Delete' then 0x2E
+          when 'Escape' then 0x1B
+          when 'ArrowLeft' then 0x25
+          when 'ArrowRight' then 0x27
+          when 'ArrowUp' then 0x26
+          when 'ArrowDown' then 0x28
+          else
+            key.upcase.ord
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chromate/hardwares/mouse_controller.rb

@@ -6,62 +6,106 @@ module Chromate
       CLICK_DURATION_RANGE = (0.01..0.1)
       DOUBLE_CLICK_DURATION_RANGE = (0.1..0.5)
 
-      attr_accessor :element, :client, :mouse_position
+      def self.reset_mouse_position
+        @@mouse_position = { x: 0, y: 0 } # rubocop:disable Style/ClassVars
+      end
+
+      attr_accessor :element, :client
 
       # @param [Chromate::Element] element
       # @param [Chromate::Client] client
       def initialize(element: nil, client: nil)
         @element        = element
         @client         = client
-        @mouse_position = { x: 0, y: 0 }
       end
 
+      # @param [Chromate::Element] element
+      # @return [self]
+      def set_element(element) # rubocop:disable Naming/AccessorMethodName
+        @element = element
+
+        self
+      end
+
+      # @return [Hash]
+      def mouse_position
+        @@mouse_position ||= { x: 0, y: 0 } # rubocop:disable Style/ClassVars
+      end
+
+      # @return [self]
       def hover
         raise NotImplementedError
       end
 
+      # @return [self]
       def click
         raise NotImplementedError
       end
 
+      # @return [self]
       def double_click
         raise NotImplementedError
       end
 
+      # @return [self]
       def right_click
         raise NotImplementedError
       end
 
+      # @params [Chromate::Element] element
+      # @return [self]
+      def drag_and_drop_to(element)
+        raise NotImplementedError
+      end
+
+      # @return [Integer]
       def position_x
         mouse_position[:x]
       end
 
+      # @return [Integer]
       def position_y
         mouse_position[:y]
       end
 
       private
 
+      # @return [Integer]
       def target_x
         element.x + (element.width / 2)
       end
 
+      # @return [Integer]
       def target_y
         element.y + (element.height / 2)
       end
 
-      def bezier_curve(steps: 50) # rubocop:disable Metrics/AbcSize
-        control_x = (target_x / 2)
-        control_y = (target_y / 2)
+      # @param [Integer] steps
+      # @return [Array<Hash>]
+      def bezier_curve(steps:, start_x: position_x, start_y: position_y, t_x: target_x, t_y: target_y) # rubocop:disable Metrics/AbcSize
+        # Points for the Bézier curve
+        control_x1 = start_x + (rand(50..150) * (t_x > start_x ? 1 : -1))
+        control_y1 = start_y + (rand(50..150) * (t_y > start_y ? 1 : -1))
+        control_x2 = t_x + (rand(50..150) * (t_x > start_x ? -1 : 1))
+        control_y2 = t_y + (rand(50..150) * (t_y > start_y ? -1 : 1))
 
-        (0..steps).map do |t|
-          t /= steps.to_f
-          # Compute the position on the quadratic Bezier curve
-          new_x = (((1 - t)**2) * position_x) + (2 * (1 - t) * t * control_x) + ((t**2) * target_x)
-          new_y = (((1 - t)**2) * position_y) + (2 * (1 - t) * t * control_y) + ((t**2) * target_y)
-          { x: new_x, y: new_y }
+        (0..steps).map do |i|
+          t = i.to_f / steps
+          x = (((1 - t)**3) * start_x) + (3 * ((1 - t)**2) * t * control_x1) + (3 * (1 - t) * (t**2) * control_x2) + ((t**3) * t_x)
+          y = (((1 - t)**3) * start_y) + (3 * ((1 - t)**2) * t * control_y1) + (3 * (1 - t) * (t**2) * control_y2) + ((t**3) * t_y)
+          { x: x, y: y }
         end
       end
+
+      # @param [Integer] target_x
+      # @param [Integer] target_y
+      # @return [Hash]
+      def update_mouse_position(target_x, target_y)
+        @@mouse_position[:x] = target_x
+        @@mouse_position[:y] = target_y
+
+        mouse_position
+      end
     end
   end
 end

data/lib/chromate/hardwares/mouses/linux_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'chromate/helpers'
-require 'open3'
+require_relative 'x11'
 
 module Chromate
   module Hardwares
@@ -17,23 +17,29 @@ module Chromate
           raise InvalidPlatformError, 'MouseController is only supported on Linux' unless linux?
 
           super
+          @display = X11.XOpenDisplay(nil)
+          raise 'Impossible d\'ouvrir l\'affichage X11' if @display.null?
+
+          @root_window = X11.XDefaultRootWindow(@display)
         end
 
         def hover
           focus_chrome_window
-          # system("xdotool mousemove_relative --sync -- #{x} #{y}")
-          system("xdotool mousemove #{target_x} #{target_y}")
-          current_mouse_position
+          smooth_move_to(target_x, target_y)
+          update_mouse_position(target_x, target_y)
         end
 
         def click
           hover
           simulate_button_event(LEFT_BUTTON, true)
+          sleep(rand(CLICK_DURATION_RANGE))
           simulate_button_event(LEFT_BUTTON, false)
         end
 
         def right_click
+          hover
           simulate_button_event(RIGHT_BUTTON, true)
+          sleep(rand(CLICK_DURATION_RANGE))
           simulate_button_event(RIGHT_BUTTON, false)
         end
 
@@ -43,35 +49,132 @@ module Chromate
           click
         end
 
+        def drag_and_drop_to(element)
+          hover
+
+          target_x = element.x + (element.width / 2)
+          target_y = element.y + (element.height / 2)
+          start_x = position_x
+          start_y = position_y
+          steps = rand(25..50)
+          duration = rand(0.1..0.3)
+
+          # Generate a Bézier curve for natural movement
+          points = bezier_curve(steps: steps, start_x: start_x, start_y: start_y, t_x: target_x, t_y: target_y)
+
+          # Step 1: Press the left mouse button
+          simulate_button_event(LEFT_BUTTON, true)
+          sleep(rand(CLICK_DURATION_RANGE))
+
+          # Step 2: Drag the element
+          points.each do |point|
+            move_mouse_to(point[:x], point[:y])
+            sleep(duration / steps)
+          end
+
+          # Step 3: Release the left mouse button
+          simulate_button_event(LEFT_BUTTON, false)
+
+          # Update the mouse position
+          update_mouse_position(target_x, target_y)
+
+          self
+        end
+
         private
 
-        def focus_chrome_window
-          # Recherche de la fenêtre Chrome avec xdotool
-          chrome_window_id = `xdotool search --onlyvisible --name "Chrome"`.strip
+        def smooth_move_to(dest_x, dest_y)
+          start_x = position_x
+          start_y = position_y
+
+          steps = rand(25..50)
+          duration = rand(0.1..0.3)
 
-          if chrome_window_id.empty?
-            puts 'Aucune fenêtre Chrome trouvée'
+          # Build a Bézier curve for natural movement
+          points = bezier_curve(steps: steps, start_x: start_x, start_y: start_y, t_x: dest_x, t_y: dest_y)
+
+          # Move the mouse along the Bézier curve
+          points.each do |point|
+            move_mouse_to(point[:x], point[:y])
+            sleep(duration / steps)
+          end
+        end
+
+        def move_mouse_to(x_target, y_target)
+          X11.XWarpPointer(@display, 0, @root_window, 0, 0, 0, 0, x_target.to_i, y_target.to_i)
+          X11.XFlush(@display)
+        end
+
+        def focus_chrome_window
+          chrome_window = find_window_by_name(@root_window, 'Chrome')
+          if chrome_window.zero?
+            Chromate::CLogger.log('No Chrome window found')
           else
-            # Active la fenêtre Chrome avec xdotool
-            system("xdotool windowactivate #{chrome_window_id}")
+            X11.XRaiseWindow(@display, chrome_window)
+            X11.XSetInputFocus(@display, chrome_window, X11::REVERT_TO_PARENT, 0)
+            X11.XFlush(@display)
           end
         end
 
-        def current_mouse_position
-          x = nil
-          y = nil
-          Open3.popen3('xdotool getmouselocation --shell') do |_, stdout, _, _|
-            output = stdout.read
-            x = output.match(/X=(\d+)/)[1].to_i
-            y = output.match(/Y=(\d+)/)[1].to_i
+        def find_window_by_name(window, name) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          root_return = FFI::MemoryPointer.new(:ulong)
+          parent_return = FFI::MemoryPointer.new(:ulong)
+          children_return = FFI::MemoryPointer.new(:pointer)
+          nchildren_return = FFI::MemoryPointer.new(:uint)
+
+          status = X11.XQueryTree(@display, window, root_return, parent_return, children_return, nchildren_return)
+          return 0 if status.zero?
+
+          nchildren = nchildren_return.read_uint
+          children_ptr = children_return.read_pointer
+
+          return 0 if nchildren.zero? || children_ptr.null?
+
+          children = children_ptr.get_array_of_ulong(0, nchildren)
+          found_window = 0
+
+          children.each do |child|
+            window_name_ptr = FFI::MemoryPointer.new(:pointer)
+            status = X11.XFetchName(@display, child, window_name_ptr)
+            if status != 0 && !window_name_ptr.read_pointer.null?
+              window_name = window_name_ptr.read_pointer.read_string
+              if window_name.include?(name)
+                X11.XFree(window_name_ptr.read_pointer)
+                found_window = child
+                break
+              end
+              X11.XFree(window_name_ptr.read_pointer)
+            end
+            # Recursive search for the window
+            found_window = find_window_by_name(child, name)
+            break if found_window != 0
           end
 
-          { x: x, y: y }
+          X11.XFree(children_ptr)
+          found_window
+        end
+
+        def current_mouse_position
+          root_return = FFI::MemoryPointer.new(:ulong)
+          child_return = FFI::MemoryPointer.new(:ulong)
+          root_x = FFI::MemoryPointer.new(:int)
+          root_y = FFI::MemoryPointer.new(:int)
+          win_x = FFI::MemoryPointer.new(:int)
+          win_y = FFI::MemoryPointer.new(:int)
+          mask_return = FFI::MemoryPointer.new(:uint)
+
+          X11.XQueryPointer(@display, @root_window, root_return, child_return, root_x, root_y, win_x, win_y, mask_return)
+
+          { x: root_x.read_int, y: root_y.read_int }
         end
 
         def simulate_button_event(button, press)
-          action = press ? 'mousedown' : 'mouseup'
-          system("xdotool #{action} #{button}")
+          Xtst.XTestFakeButtonEvent(@display, button, press ? 1 : 0, 0)
+          X11.XFlush(@display)
+        end
+
+        def finalize
+          X11.XCloseDisplay(@display) if @display && !@display.null?
         end
       end
     end