Update UC Mode code

Author: mdmintz

seleniumbase/core/browser_launcher.py

@@ -734,6 +734,7 @@ def _set_chrome_options(
             or IS_LINUX  # switches to Xvfb (non-headless)
         )
     ):
+        chrome_options.add_argument("--disable-popup-blocking")
         # Skip remaining options that trigger anti-bot services
         return chrome_options
     chrome_options.add_argument("--test-type")

seleniumbase/undetected/__init__.py

@@ -9,6 +9,8 @@
 import selenium.webdriver.chrome.webdriver
 import selenium.webdriver.common.service
 import selenium.webdriver.remote.command
+from .cdp import CDP
+from .cdp import PageElement
 from .dprocess import start_detached
 from .options import ChromeOptions
 from .patcher import IS_POSIX
@@ -133,13 +135,12 @@ def __init__(
                 constants.MultiBrowser.DRIVER_FIXING_LOCK
             )
             with uc_lock:
-                patcher = Patcher(
+                self.patcher = Patcher(
                     executable_path=driver_executable_path,
                     force=patcher_force_close,
                     version_main=version_main,
                 )
-                patcher.auto()
-                self.patcher = patcher
+                self.patcher.auto()
         if not options:
             options = ChromeOptions()
         try:
@@ -280,7 +281,7 @@ def __init__(
         service_ = None
         if patch_driver:
             service_ = selenium.webdriver.chrome.service.Service(
-                executable_path=patcher.executable_path,
+                executable_path=self.patcher.executable_path,
                 log_path=os.devnull,
             )
         else:
@@ -380,19 +381,28 @@ def clear_cdp_listeners(self):
         if self.reactor and isinstance(self.reactor, Reactor):
             self.reactor.handlers.clear()
 
-    def window_new(self):
+    def window_new(self, url=None):
         self.execute(
             selenium.webdriver.remote.command.Command.NEW_WINDOW,
             {"type": "window"},
         )
+        if url:
+            self.remove_cdc_props_as_needed()
+            return super().get(url)
+        return None
 
     def tab_new(self, url):
         """This opens a url in a new tab."""
         if not hasattr(self, "cdp"):
-            from .cdp import CDP
+            self.cdp = CDP(self.options)
+        self.cdp.tab_new(str(url))
 
-            cdp = CDP(self.options)
-            cdp.tab_new(str(url))
+    def tab_list(self):
+        if not hasattr(self, "cdp"):
+            self.cdp = CDP(self.options)
+
+        retval = self.get(self.cdp.endpoints["list"])
+        return [PageElement(o) for o in retval]
 
     def reconnect(self, timeout=0.1):
         try:

seleniumbase/undetected/cdp.py

@@ -89,6 +89,9 @@ async def send(self, method, params):  # noqa
             self.log.info(self._last_json)
 
     def get(self, uri):
+        from urllib.parse import unquote
+
+        uri = unquote(uri, errors="strict")
         resp = self._session.get(self.server_addr + uri)
         try:
             self._last_resp = resp
@@ -99,6 +102,9 @@ def get(self, uri):
             return self._last_json
 
     def post(self, uri, data=None):
+        from urllib.parse import unquote
+
+        uri = unquote(uri, errors="strict")
         if not data:
             data = {}
         resp = self._session.post(self.server_addr + uri, json=data)

seleniumbase/undetected/patcher.py

@@ -47,11 +47,9 @@ def __init__(self, executable_path=None, force=False, version_main=0):
             version_main: 0 = auto
                 Specify main chrome version (rounded, ex: 82)
         """
-        import secrets
-
         self.force = force
         self.executable_path = None
-        prefix = secrets.token_hex(8)
+        prefix = "undetected"
         if not os.path.exists(self.data_path):
             os.makedirs(self.data_path, exist_ok=True)
         if not executable_path:
@@ -222,6 +220,33 @@ def gen_call_function_js_cache_name(match):
             fh.write(file_bin)
         return True
 
+    def is_binary_patched_new(self, executable_path=None):
+        executable_path = executable_path or self.executable_path
+        with io.open(executable_path, "rb") as fh:
+            return fh.read().find(b"undetected chromedriver") != -1
+
+    def patch_exe_new(self):
+        logger.info("patching driver executable %s" % self.executable_path)
+        with io.open(self.executable_path, "r+b") as fh:
+            content = fh.read()
+            match_injected_codeblock = re.search(rb"{window.*;}", content)
+            if match_injected_codeblock:
+                target_bytes = match_injected_codeblock[0]
+                new_target_bytes = (
+                    b'{console.log("undetected chromedriver 1337!")}'.ljust(
+                        len(target_bytes), b" "
+                    )
+                )
+                new_content = content.replace(target_bytes, new_target_bytes)
+                if new_content == content:
+                    pass  # Failure to patch driver
+                else:
+                    # Patch now
+                    fh.seek(0)
+                    fh.write(new_content)
+            else:
+                pass  # Already patched
+
     def __repr__(self):
         return "{0:s}({1:s})".format(
             self.__class__.__name__,