Proxy with auth

[thewildman]

Hi !
nodriver includes a simple way to use an authenticated proxy by simply passing the proxy string as a param to create_context.
Since this is a fork, I was expecting create_context to work in the same way, but this is apparently not implemented. I have found the quite cumbersome solution in issue #71 , but a more direct approach would be nice I believe.

PS : as a side note, does this project try to occasionally merge nodriver code changes ?

[gavinnn101]

Did the snippet in #71 work for you on the latest version? That and other attempts at using an authenticated proxy have not gone well for me so far..

[thewildman]

Not that I recall. I switched to IP restriction to circumvent the auth issue.

[C0uchP0tat0]

Here’s an example of a minimally working solution based on Chrome extensions for using a proxy with authentication:

import json
import tempfile, os
import zendriver as zd

async def create_proxy_extension(proxy_url):
    proxy_url = proxy_url.replace("http://", "")
    creds, server = proxy_url.split("@")
    username, password = creds.split(":")
    host, port = server.split(":")

    ext_dir = tempfile.mkdtemp(prefix="proxy_ext_")

    manifest = {
            "version": "1.0.0",
            "manifest_version": 3,
            "name": "Proxy Extension",
            "permissions": [
                "proxy",
                "tabs",
                "storage",
                "webRequest",
                "webRequestAuthProvider"
            ],
            "host_permissions": [
                "<all_urls>"
            ],
            "background": {
                "service_worker": "background.js"
            },
            "minimum_chrome_version": "22.0.0"
        }


    background_js = f"""
            var config = {{
            mode: "fixed_servers",
            rules: {{
                singleProxy: {{
                scheme: "http",
                host: "{host}",
                port: {port}
                }},
                bypassList: ["<local>"]
            }}
            }};

            chrome.proxy.settings.set({{value: config, scope: "regular"}}, function() {{}});

            function callbackFn() {{
            return {{
                authCredentials: {{
                username: "{username}",
                password: "{password}"
                }}
            }};
            }}

            chrome.webRequest.onAuthRequired.addListener(
            callbackFn,
            {{urls: ["<all_urls>"]}},
            ["blocking"]
            );
        """

    with open(os.path.join(ext_dir, "manifest.json"), "w") as f:
        json.dump(manifest, f, indent=2)
    with open(os.path.join(ext_dir, "background.js"), "w") as f:
        f.write(background_js)
    return ext_dir


async def main():
    ext = await create_proxy_extension("http://login:password@host:port")
    browser = await zd.start(
        browser_args=[
            f'--load-extension={ext}',
            '--disable-features=DisableLoadExtensionCommandLineSwitch',
        ],
        headless=False
    )
    ext = await browser.get("chrome://extensions/")
    await asyncio.sleep(1)
    page = await browser.get("https://www.myexternalip.com/raw")
    ip = await page.evaluate("document.body.textContent.trim()")
    print("🌍 External IP:", ip)
    await browser.stop()

import asyncio
asyncio.run(main())

[gavinnn101]

chrome v142 removed the --DisableLoadExtensionCommandLineSwitch flag :(

[Fadexz]

Here is an example of what I used. It worked on the first site I was using for testing it but when navigating to another site it wouldn't load and would just cause issues. Haven't experimented enough.

async def auth_challenge_handler(event: zd.cdp.fetch.AuthRequired, page):
    asyncio.create_task(
        page.send(
            zd.cdp.fetch.continue_with_auth(
                request_id=event.request_id,
                auth_challenge_response=zd.cdp.fetch.AuthChallengeResponse(
                    response="ProvideCredentials",
                    username="your_name",
                    password="your_pass",
                ),
            )
        )
    )

async def req_paused(event: zd.cdp.fetch.RequestPaused, page):
    await page.send(zd.cdp.fetch.continue_request(request_id=event.request_id))

async def setup_browser_with_proxy():
    # Get your proxy
    proxy = "127.0.0.1:3000"

    added_browser_args = []
    # Add proxy if available
    if proxy:
        added_browser_args.append(f'--proxy-server={proxy}')
        print(f"Starting browser with proxy: {proxy}")
    else:
        print("No proxy available, starting browser without proxy")

    browser = await zd.start(
        headless=False,
        browser_args=added_browser_args
    )

    page = await browser.get("about:blank")

    # Apply proxy user authentication
    if proxy:
        page.add_handler(zd.cdp.fetch.RequestPaused, lambda event, connection: asyncio.create_task(req_paused(event, page)))
        page.add_handler(zd.cdp.fetch.AuthRequired, lambda event, connection: asyncio.create_task(auth_challenge_handler(event, page)))
        await page.send(zd.cdp.fetch.enable(handle_auth_requests=True))