chromate-rb 0.0.1.pre → 0.0.2.pre

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

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

@@ -85,7 +85,7 @@ module Chromate
           system_point = CGEventGetLocation(event)
           CFRelease(event)
 
-          # Convertir les coordonnées système en coordonnées navigateur
+          # Convert the system coordinates to browser coordinates
           browser_x = system_point[:x] / @scale_factor
           browser_y = (@display_height - system_point[:y]) / @scale_factor
 
@@ -94,7 +94,7 @@ module Chromate
             y: browser_y
           }
 
-          # Retourner un nouveau CGPoint avec les coordonnées système
+          # Return the browser coordinates
           CGPoint.new.tap do |p|
             p[:x] = system_point[:x]
             p[:y] = system_point[:y]
@@ -102,7 +102,7 @@ module Chromate
         end
 
         def convert_coordinates(browser_x, browser_y)
-          # Convertir les coordonnées du navigateur en coordonnées système
+          # Convert the browser coordinates to system coordinates
           system_x = browser_x * @scale_factor
           system_y = @display_height - (browser_y * @scale_factor)
 
@@ -113,12 +113,12 @@ module Chromate
         end
 
         def determine_scale_factor
-          # Obtenir le facteur d'échelle en comparant les dimensions logiques et physiques
-          # Par défaut, utiliser 2.0 pour les écrans Retina
+          # Determine the scale factor for the display
+          # By default, the scale factor is 2.0 for Retina displays
 
           `system_profiler SPDisplaysDataType | grep -i "retina"`.empty? ? 1.0 : 2.0
         rescue StandardError
-          2.0 # Par défaut pour les écrans Retina modernes
+          2.0 # Default to 2.0 if the scale factor cannot be determined
         end
       end
     end

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

@@ -4,11 +4,19 @@ module Chromate
   module Hardwares
     module Mouses
       class VirtualController < Chromate::Hardwares::MouseController
-        def hover
-          steps     = rand(25..50)
-          points    = bezier_curve(steps: steps)
-          duration  = rand(0.1..0.3)
+        def hover # rubocop:disable Metrics/AbcSize
+          # Define the target position
+          target_x = element.x + (element.width / 2) + rand(-20..20)
+          target_y = element.y + (element.height / 2) + rand(-20..20)
+          start_x = mouse_position[:x]
+          start_y = mouse_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)
+
+          # Move the mouse along the Bézier curve
           points.each do |point|
             dispatch_mouse_event('mouseMoved', point[:x], point[:y])
             sleep(duration / steps)
@@ -35,12 +43,53 @@ module Chromate
           dispatch_mouse_event('mouseReleased', target_x, target_y, button: 'right', click_count: 1)
         end
 
+        # @param [Chromate::Element] element
+        # @return [self]
+        def drag_and_drop_to(element) # rubocop:disable Metrics/AbcSize
+          hover
+
+          target_x = element.x + (element.width / 2)
+          target_y = element.y + (element.height / 2)
+          start_x = mouse_position[:x]
+          start_y = mouse_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: Start the drag (dragStart, dragEnter)
+          move_mouse_to(start_x, start_y)
+          dispatch_drag_event('dragEnter', start_x, start_y)
+
+          # Step 2: Drag the element (dragOver)
+          points.each do |point|
+            move_mouse_to(point[:x], point[:y])
+            dispatch_drag_event('dragOver', point[:x], point[:y])
+            sleep(duration / steps)
+          end
+
+          # Step 3: Drop the element (drop)
+          move_mouse_to(target_x, target_y)
+          dispatch_drag_event('drop', target_x, target_y)
+
+          # Step 4: End the drag (dragEnd)
+          dispatch_drag_event('dragEnd', target_x, target_y)
+
+          update_mouse_position(target_x, target_y)
+
+          self
+        end
+
         private
 
+        # @return [self]
         def click!
           dispatch_mouse_event('mousePressed', target_x, target_y, button: 'left', click_count: 1)
           sleep(rand(CLICK_DURATION_RANGE))
           dispatch_mouse_event('mouseReleased', target_x, target_y, button: 'left', click_count: 1)
+
+          self
         end
 
         # @param [String] type mouseMoved, mousePressed, mouseReleased
@@ -64,9 +113,48 @@ module Chromate
           client.send_message('Input.dispatchMouseEvent', params)
         end
 
-        def update_mouse_position(target_x, target_y)
-          @mouse_position[:x] = target_x
-          @mouse_position[:y] = target_y
+        # @param [Integer] steps
+        # @param [Integer] x
+        # @param [Integer] y
+        # @return [Array<Hash>]
+        def dispatch_drag_event(type, x, y) # rubocop:disable Naming/MethodParameterName
+          params = {
+            type: type,
+            x: x,
+            y: y,
+            data: {
+              items: [
+                {
+                  mimeType: 'text/plain',
+                  data: 'dragged'
+                }
+              ],
+              dragOperationsMask: 1
+            }
+          }
+
+          client.send_message('Input.dispatchDragEvent', params)
+        end
+
+        # @param [Integer] x_target
+        # @param [Integer] y_target
+        # @return [self]
+        def move_mouse_to(x_target, y_target)
+          params = {
+            type: 'mouseMoved',
+            x: x_target,
+            y: y_target,
+            button: 'none',
+            clickCount: 0,
+            deltaX: 0,
+            deltaY: 0,
+            modifiers: 0,
+            timestamp: (Time.now.to_f * 1000).to_i
+          }
+
+          client.send_message('Input.dispatchMouseEvent', params)
+
+          self
         end
       end
     end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'chromate/helpers'
+
+module X11
+  extend FFI::Library
+  ffi_lib 'X11'
+
+  # Types
+  typedef :ulong, :Window
+  typedef :pointer, :Display
+
+  # X11 functions
+  attach_function :XOpenDisplay, [:string], :pointer
+  attach_function :XCloseDisplay, [:pointer], :int
+  attach_function :XDefaultRootWindow, [:pointer], :ulong
+  attach_function :XWarpPointer, %i[pointer ulong ulong int int uint uint int int], :int
+  attach_function :XQueryPointer, %i[pointer ulong pointer pointer pointer pointer pointer pointer pointer], :bool
+  attach_function :XFlush, [:pointer], :int
+  attach_function :XQueryTree, %i[pointer ulong pointer pointer pointer pointer], :int
+  attach_function :XFetchName, %i[pointer ulong pointer], :int
+  attach_function :XFree, [:pointer], :int
+  attach_function :XRaiseWindow, %i[pointer ulong], :int
+  attach_function :XSetInputFocus, %i[pointer ulong int ulong], :int
+
+  # Constants
+  REVERT_TO_PARENT = 2
+end
+
+module Xtst
+  extend FFI::Library
+  ffi_lib 'Xtst'
+
+  attach_function :XTestFakeButtonEvent, %i[pointer uint int ulong], :int
+end

data/lib/chromate/hardwares.rb

@@ -1,14 +1,20 @@
 # frozen_string_literal: true
 
 require 'chromate/c_logger'
+require 'chromate/hardwares/keyboard_controller'
 require 'chromate/hardwares/mouse_controller'
 require 'chromate/hardwares/mouses/virtual_controller'
+require 'chromate/hardwares/keyboards/virtual_controller'
 require 'chromate/helpers'
 
 module Chromate
   module Hardwares
     extend Helpers
 
+    # @param [Hash] args
+    # @option args [Chromate::Client] :client
+    # @option args [Chromate::Element] :element
+    # @return [Chromate::Hardwares::MouseController]
     def mouse(**args)
       browser = args[:client].browser
       if browser.options[:native_control]
@@ -29,5 +35,15 @@ module Chromate
       end
     end
     module_function :mouse
+
+    # @param [Hash] args
+    # @option args [Chromate::Client] :client
+    # @option args [Chromate::Element] :element
+    # @return [Chromate::Hardwares::KeyboardController]
+    def keyboard(**args)
+      Chromate::CLogger.log('⌨️ Loading Virtual keyboard controller')
+      Keyboards::VirtualController.new(**args)
+    end
+    module_function :keyboard
   end
 end

data/lib/chromate/helpers.rb

@@ -1,23 +1,30 @@
 # frozen_string_literal: true
 
 require 'rbconfig'
-module Helpers
-  def linux?
-    RbConfig::CONFIG['host_os'] =~ /linux|bsd/i
-  end
 
-  def mac?
-    RbConfig::CONFIG['host_os'] =~ /darwin/i
-  end
+module Chromate
+  module Helpers
+    # @return [Boolean]
+    def linux?
+      RbConfig::CONFIG['host_os'] =~ /linux|bsd/i
+    end
 
-  def windows?
-    RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/i
-  end
+    # @return [Boolean]
+    def mac?
+      RbConfig::CONFIG['host_os'] =~ /darwin/i
+    end
+
+    # @return [Boolean]
+    def windows?
+      RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/i
+    end
 
-  def find_available_port
-    server = TCPServer.new('127.0.0.1', 0)
-    port = server.addr[1]
-    server.close
-    port
+    # @return [Integer]
+    def find_available_port
+      server = TCPServer.new('127.0.0.1', 0)
+      port = server.addr[1]
+      server.close
+      port
+    end
   end
 end

data/lib/chromate/user_agent.rb

@@ -2,26 +2,25 @@
 
 module Chromate
   class UserAgent
+    # @return [String]
     def self.call
-      new.call
-    end
-
-    attr_reader :os
-
-    def initialize
-      @os = find_os
-    end
-
-    def call
-      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36'
+      case os
+      when 'Linux'
+        linux_agent
+      when 'Mac'
+        mac_agent
+      when 'Windows'
+        windows_agent
+      else
+        raise 'Unknown OS'
+      end
     end
 
-    private
-
-    def find_os
+    # @return [String<'Mac', 'Linux', 'Windows', 'Unknown'>]
+    def self.os
       case RUBY_PLATFORM
       when /darwin/
-        'Macintosh'
+        'Mac'
       when /linux/
         'Linux'
       when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
@@ -30,5 +29,30 @@ module Chromate
         'Unknown'
       end
     end
+
+    def self.os_version
+      case os
+      when 'Linux'
+        '5.15'
+      when 'Mac'
+        '13.0'
+      when 'Windows'
+        '10.0'
+      else
+        raise 'Unknown OS'
+      end
+    end
+
+    def self.linux_agent
+      'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
+    end
+
+    def self.mac_agent
+      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
+    end
+
+    def self.windows_agent
+      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
+    end
   end
 end

data/lib/chromate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Chromate
-  VERSION = '0.0.1.pre'
+  VERSION = '0.0.2.pre'
 end

data/lib/chromate.rb

@@ -6,10 +6,12 @@ require_relative 'chromate/configuration'
 
 module Chromate
   class << self
+    # @yield [Chromate::Configuration]
     def configure
       yield configuration
     end
 
+    # @return [Chromate::Configuration]
     def configuration
       @configuration ||= Configuration.new
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chromate-rb
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre
+  version: 0.0.2.pre
 platform: ruby
 authors:
 - Eth3rnit3
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-18 00:00:00.000000000 Z
+date: 2024-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -54,13 +54,24 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- docker_root/Gemfile
+- docker_root/Gemfile.lock
+- docker_root/TestInDocker.gif
+- docker_root/app.rb
 - dockerfiles/Dockerfile
+- dockerfiles/README.md
 - dockerfiles/docker-entrypoint.sh
+- docs/README.md
 - docs/browser.md
+- docs/element.md
+- lib/bot_browser.rb
+- lib/bot_browser/downloader.rb
+- lib/bot_browser/installer.rb
 - lib/chromate.rb
 - lib/chromate/actions/dom.rb
 - lib/chromate/actions/navigate.rb
 - lib/chromate/actions/screenshot.rb
+- lib/chromate/actions/stealth.rb
 - lib/chromate/browser.rb
 - lib/chromate/c_logger.rb
 - lib/chromate/client.rb
@@ -69,15 +80,22 @@ files:
 - lib/chromate/elements/select.rb
 - lib/chromate/exceptions.rb
 - lib/chromate/hardwares.rb
+- lib/chromate/hardwares/keyboard_controller.rb
+- lib/chromate/hardwares/keyboards/virtual_controller.rb
 - lib/chromate/hardwares/mouse_controller.rb
 - lib/chromate/hardwares/mouses/linux_controller.rb
 - lib/chromate/hardwares/mouses/mac_os_controller.rb
 - lib/chromate/hardwares/mouses/virtual_controller.rb
+- lib/chromate/hardwares/mouses/x11.rb
 - lib/chromate/helpers.rb
 - lib/chromate/user_agent.rb
 - lib/chromate/version.rb
+- logo.png
+- results/bot.png
 - results/brotector.png
 - results/cloudflare.png
+- results/headers.png
+- results/pixelscan.png
 - sig/chromate.rbs
 homepage: http://github.com/Eth3rnit3/chromate
 licenses: