chromate-rb 0.0.2.pre → 0.0.3.pre

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

@@ -13,6 +13,15 @@ module Chromate
         @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)
@@ -23,6 +32,8 @@ module Chromate
       # @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

data/lib/chromate/hardwares/mouse_controller.rb

@@ -19,6 +19,14 @@ module Chromate
         @client         = client
       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

data/lib/chromate/hardwares.rb

@@ -19,18 +19,18 @@ module Chromate
       browser = args[:client].browser
       if browser.options[:native_control]
         if mac?
-          Chromate::CLogger.log('🐁 Loading MacOs mouse controller')
+          Chromate::CLogger.log('👨🏼‍💻🐁 Loading MacOs mouse controller')
           require 'chromate/hardwares/mouses/mac_os_controller'
           return Mouses::MacOsController.new(**args)
         end
         if linux?
-          Chromate::CLogger.log('🐁 Loading Linux mouse controller')
+          Chromate::CLogger.log('👨🏼‍💻🐁 Loading Linux mouse controller')
           require 'chromate/hardwares/mouses/linux_controller'
           return Mouses::LinuxController.new(**args)
         end
         raise 'Native mouse controller is not supported on Windows' if windows?
       else
-        Chromate::CLogger.log('🐁 Loading Virtual mouse controller')
+        Chromate::CLogger.log('🤖🐁 Loading Virtual mouse controller')
         Mouses::VirtualController.new(**args)
       end
     end
@@ -41,7 +41,7 @@ module Chromate
     # @option args [Chromate::Element] :element
     # @return [Chromate::Hardwares::KeyboardController]
     def keyboard(**args)
-      Chromate::CLogger.log('⌨️ Loading Virtual keyboard controller')
+      Chromate::CLogger.log('🤖⌨️ Loading Virtual keyboard controller')
       Keyboards::VirtualController.new(**args)
     end
     module_function :keyboard

data/lib/chromate/user_agent.rb

@@ -30,29 +30,31 @@ module Chromate
       end
     end
 
-    def self.os_version
-      case os
-      when 'Linux'
-        '5.15'
-      when 'Mac'
-        '13.0'
-      when 'Windows'
-        '10.0'
+    def self.arch
+      case RUBY_PLATFORM
+      when /x64-mingw32/
+        'x64'
+      when /x86_64-mingw32/
+        'x86_64'
       else
-        raise 'Unknown OS'
+        'x86'
       end
     end
 
+    def self.agents
+      @agents ||= JSON.parse(File.read(File.join(__dir__, 'files/agents.json')))
+    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'
+      agents['linux'].sample
     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'
+      agents['mac'].sample
     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'
+      agents['windows'].sample
     end
   end
 end

data/lib/chromate/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chromate-rb
 version: !ruby/object:Gem::Version
-  version: 0.0.2.pre
+  version: 0.0.3.pre
 platform: ruby
 authors:
 - Eth3rnit3
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-24 00:00:00.000000000 Z
+date: 2025-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.17.0
+- !ruby/object:Gem::Dependency
+  name: user_agent_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.18.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.18.0
 - !ruby/object:Gem::Dependency
   name: websocket-client-simple
   requirement: !ruby/object:Gem::Requirement
@@ -61,9 +75,13 @@ files:
 - dockerfiles/Dockerfile
 - dockerfiles/README.md
 - dockerfiles/docker-entrypoint.sh
+- docs/BOT_BROWSER.md
 - docs/README.md
 - docs/browser.md
+- docs/client.md
 - docs/element.md
+- docs/elements/checkbox.md
+- docs/elements/radio.md
 - lib/bot_browser.rb
 - lib/bot_browser/downloader.rb
 - lib/bot_browser/installer.rb
@@ -72,13 +90,20 @@ files:
 - lib/chromate/actions/navigate.rb
 - lib/chromate/actions/screenshot.rb
 - lib/chromate/actions/stealth.rb
+- lib/chromate/binary.rb
 - lib/chromate/browser.rb
 - lib/chromate/c_logger.rb
 - lib/chromate/client.rb
 - lib/chromate/configuration.rb
 - lib/chromate/element.rb
+- lib/chromate/elements/checkbox.rb
+- lib/chromate/elements/option.rb
+- lib/chromate/elements/radio.rb
 - lib/chromate/elements/select.rb
+- lib/chromate/elements/tags.rb
 - lib/chromate/exceptions.rb
+- lib/chromate/files/agents.json
+- lib/chromate/files/stealth.js
 - lib/chromate/hardwares.rb
 - lib/chromate/hardwares/keyboard_controller.rb
 - lib/chromate/hardwares/keyboards/virtual_controller.rb