Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.
Python ai-agentsai-toolsbrowser-agentbrowser-automationbrowser-usecdpcloud-browsercomputer-useheadless-browserllmmcpplaywrightpythonremote-browserstealth-browserweb-automationweb-scraping
IP blocking feature
mertunsall5160ca356237
diff --git a/browser_use/browser/profile.py b/browser_use/browser/profile.pyindex feaeb7720..46739ee2f 100644--- a/browser_use/browser/profile.py+++ b/browser_use/browser/profile.py@@ -570,6 +570,10 @@ class BrowserProfile(BrowserConnectArgs, BrowserLaunchPersistentContextArgs, Brodefault=None,description='List of prohibited domains for navigation e.g. ["*.google.com", "https://example.com", "chrome-extension://*"]. Allowed domains take precedence over prohibited domains. Lists with 100+ items are auto-optimized to sets (no pattern matching).',)+ block_ip_addresses: bool = Field(+ default=False,+ description='Block navigation to URLs containing IP addresses (both IPv4 and IPv6). When True, blocks all IP-based URLs including localhost and private networks.',+ )keep_alive: bool | None = Field(default=None, description='Keep browser alive after agent run.')# --- Proxy settings ---diff --git a/browser_use/browser/watchdogs/security_watchdog.py b/browser_use/browser/watchdogs/security_watchdog.pyindex 2cb866d02..b5c301d97 100644--- a/browser_use/browser/watchdogs/security_watchdog.py+++ b/browser_use/browser/watchdogs/security_watchdog.py@@ -136,6 +136,26 @@ class SecurityWatchdog(BaseWatchdog):else:return (host, f'www.{host}') # ('example.com', 'www.example.com')+ def _is_ip_address(self, host: str) -> bool:+ """Check if a hostname is an IP address (IPv4 or IPv6).++ Args:+ host: The hostname to check++ Returns:+ True if the host is an IP address, False otherwise+ """+ import ipaddress++ try:+ # Try to parse as IP address (handles both IPv4 and IPv6)+ ipaddress.ip_address(host)+ return True+ except ValueError:+ return False+ except Exception:+ return False+def _is_url_allowed(self, url: str) -> bool:"""Check if a URL is allowed based on the allowed_domains configuration.@@ -146,14 +166,7 @@ class SecurityWatchdog(BaseWatchdog):True if the URL is allowed, False otherwise"""- # If no allowed_domains specified, allow all URLs- if (- not self.browser_session.browser_profile.allowed_domains- and not self.browser_session.browser_profile.prohibited_domains- ):- return True-- # Always allow internal browser targets+ # Always allow internal browser targets (before any other checks)if url in ['about:blank', 'chrome://new-tab-page/', 'chrome://new-tab-page', 'chrome://newtab/']:return True@@ -171,6 +184,18 @@ class SecurityWatchdog(BaseWatchdog):if not host:return False+ # Check if IP addresses should be blocked (before domain checks)+ if self.browser_session.browser_profile.block_ip_addresses:+ if self._is_ip_address(host):+ return False++ # If no allowed_domains specified, allow all URLs+ if (+ not self.browser_session.browser_profile.allowed_domains+ and not self.browser_session.browser_profile.prohibited_domains+ ):+ return True+# Check allowed domains (fast path for sets, slow path for lists with patterns)if self.browser_session.browser_profile.allowed_domains:allowed_domains = self.browser_session.browser_profile.allowed_domainsdiff --git a/tests/ci/test_browser_watchdog_security_ip_blocking.py b/tests/ci/test_browser_watchdog_security_ip_blocking.pynew file mode 100644index 000000000..162bff0d1--- /dev/null+++ b/tests/ci/test_browser_watchdog_security_ip_blocking.py@@ -0,0 +1,489 @@+"""+Comprehensive tests for IP address blocking in SecurityWatchdog.++Tests cover IPv4, IPv6, localhost, private networks, edge cases, and interactions+with allowed_domains and prohibited_domains configurations.+"""++from bubus import EventBus++from browser_use.browser import BrowserProfile, BrowserSession+from browser_use.browser.watchdogs.security_watchdog import SecurityWatchdog+++class TestIPv4Blocking:+ """Test blocking of IPv4 addresses."""++ def test_block_public_ipv4_addresses(self):+ """Test that public IPv4 addresses are blocked when block_ip_addresses=True."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Public IPv4 addresses should be blocked+ assert watchdog._is_url_allowed('http://180.1.1.1/supersafe.txt') is False+ assert watchdog._is_url_allowed('https://8.8.8.8/') is False+ assert watchdog._is_url_allowed('http://1.1.1.1:8080/api') is False+ assert watchdog._is_url_allowed('https://142.250.185.46/search') is False+ assert watchdog._is_url_allowed('http://93.184.216.34/') is False++ def test_block_private_ipv4_networks(self):+ """Test that private network IPv4 addresses are blocked."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Private network ranges (RFC 1918)+ assert watchdog._is_url_allowed('http://192.168.1.1/') is False+ assert watchdog._is_url_allowed('http://192.168.0.100/admin') is False+ assert watchdog._is_url_allowed('http://10.0.0.1/') is False+ assert watchdog._is_url_allowed('http://10.255.255.255/') is False+ assert watchdog._is_url_allowed('http://172.16.0.1/') is False+ assert watchdog._is_url_allowed('http://172.31.255.254/') is False++ def test_block_localhost_ipv4(self):+ """Test that localhost IPv4 addresses are blocked."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Localhost/loopback addresses+ assert watchdog._is_url_allowed('http://127.0.0.1/') is False+ assert watchdog._is_url_allowed('http://127.0.0.1:8080/') is False+ assert watchdog._is_url_allowed('https://127.0.0.1:3000/api/test') is False+ assert watchdog._is_url_allowed('http://127.1.2.3/') is False # Any 127.x.x.x++ def test_block_ipv4_with_ports_and_paths(self):+ """Test that IPv4 addresses with ports and paths are blocked."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # With various ports+ assert watchdog._is_url_allowed('http://8.8.8.8:80/') is False+ assert watchdog._is_url_allowed('https://8.8.8.8:443/') is False+ assert watchdog._is_url_allowed('http://192.168.1.1:8080/') is False+ assert watchdog._is_url_allowed('http://10.0.0.1:3000/api') is False++ # With paths and query strings+ assert watchdog._is_url_allowed('http://1.2.3.4/path/to/resource') is False+ assert watchdog._is_url_allowed('http://5.6.7.8/api?key=value') is False+ assert watchdog._is_url_allowed('https://9.10.11.12/path/to/file.html#anchor') is False++ def test_allow_ipv4_when_blocking_disabled(self):+ """Test that IPv4 addresses are allowed when block_ip_addresses=False (default)."""+ browser_profile = BrowserProfile(block_ip_addresses=False, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # All IP addresses should be allowed when blocking is disabled+ assert watchdog._is_url_allowed('http://180.1.1.1/supersafe.txt') is True+ assert watchdog._is_url_allowed('http://192.168.1.1/') is True+ assert watchdog._is_url_allowed('http://127.0.0.1:8080/') is True+ assert watchdog._is_url_allowed('http://8.8.8.8/') is True+++class TestIPv6Blocking:+ """Test blocking of IPv6 addresses."""++ def test_block_ipv6_addresses(self):+ """Test that IPv6 addresses are blocked when block_ip_addresses=True."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Public IPv6 addresses (with brackets as per URL standard)+ assert watchdog._is_url_allowed('http://[2001:db8::1]/') is False+ assert watchdog._is_url_allowed('https://[2001:4860:4860::8888]/') is False+ assert watchdog._is_url_allowed('http://[2606:4700:4700::1111]/path') is False+ assert watchdog._is_url_allowed('https://[2001:db8:85a3::8a2e:370:7334]/api') is False++ def test_block_ipv6_localhost(self):+ """Test that IPv6 localhost addresses are blocked."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # IPv6 loopback+ assert watchdog._is_url_allowed('http://[::1]/') is False+ assert watchdog._is_url_allowed('http://[::1]:8080/') is False+ assert watchdog._is_url_allowed('https://[::1]:3000/api') is False+ assert watchdog._is_url_allowed('http://[0:0:0:0:0:0:0:1]/') is False # Expanded form++ def test_block_ipv6_with_ports_and_paths(self):+ """Test that IPv6 addresses with ports and paths are blocked."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # IPv6 with ports+ assert watchdog._is_url_allowed('http://[2001:db8::1]:80/') is False+ assert watchdog._is_url_allowed('https://[2001:db8::1]:443/') is False+ assert watchdog._is_url_allowed('http://[::1]:8080/api') is False++ # IPv6 with paths+ assert watchdog._is_url_allowed('http://[2001:db8::1]/path/to/resource') is False+ assert watchdog._is_url_allowed('https://[2001:db8::1]/api?key=value') is False++ def test_allow_ipv6_when_blocking_disabled(self):+ """Test that IPv6 addresses are allowed when block_ip_addresses=False."""+ browser_profile = BrowserProfile(block_ip_addresses=False, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # All IPv6 addresses should be allowed+ assert watchdog._is_url_allowed('http://[2001:db8::1]/') is True+ assert watchdog._is_url_allowed('http://[::1]:8080/') is True+ assert watchdog._is_url_allowed('https://[2001:4860:4860::8888]/') is True+++class TestDomainNamesStillAllowed:+ """Test that regular domain names are not affected by IP blocking."""++ def test_domain_names_allowed_with_ip_blocking(self):+ """Test that domain names continue to work when IP blocking is enabled."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Regular domain names should still be allowed+ assert watchdog._is_url_allowed('https://example.com') is True+ assert watchdog._is_url_allowed('https://www.google.com') is True+ assert watchdog._is_url_allowed('http://subdomain.example.org/path') is True+ assert watchdog._is_url_allowed('https://api.github.com/repos') is True+ assert watchdog._is_url_allowed('http://localhost/') is True # "localhost" is a domain name, not IP+ assert watchdog._is_url_allowed('http://localhost:8080/api') is True++ def test_domains_with_numbers_allowed(self):+ """Test that domain names containing numbers are still allowed."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Domains with numbers (but not valid IP addresses)+ assert watchdog._is_url_allowed('https://example123.com') is True+ assert watchdog._is_url_allowed('https://123example.com') is True+ assert watchdog._is_url_allowed('https://server1.example.com') is True+ assert watchdog._is_url_allowed('http://web2.site.org') is True+++class TestIPBlockingWithAllowedDomains:+ """Test interaction between IP blocking and allowed_domains."""++ def test_ip_blocked_even_in_allowed_domains(self):+ """Test that IPs are blocked even if they're in allowed_domains list."""+ # Note: It doesn't make sense to add IPs to allowed_domains, but if someone does,+ # IP blocking should take precedence+ browser_profile = BrowserProfile(+ block_ip_addresses=True,+ allowed_domains=['example.com', '192.168.1.1'], # IP in allowlist+ headless=True,+ user_data_dir=None,+ )+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # IP should be blocked despite being in allowed_domains+ assert watchdog._is_url_allowed('http://192.168.1.1/') is False++ # Regular domain should work as expected+ assert watchdog._is_url_allowed('https://example.com') is True++ # Other domains not in allowed_domains should be blocked+ assert watchdog._is_url_allowed('https://other.com') is False++ def test_allowed_domains_with_ip_blocking_enabled(self):+ """Test that allowed_domains works normally with IP blocking enabled."""+ browser_profile = BrowserProfile(+ block_ip_addresses=True, allowed_domains=['example.com', '*.google.com'], headless=True, user_data_dir=None+ )+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Allowed domains should work+ assert watchdog._is_url_allowed('https://example.com') is True+ assert watchdog._is_url_allowed('https://www.google.com') is True++ # Not allowed domains should be blocked+ assert watchdog._is_url_allowed('https://other.com') is False++ # IPs should be blocked regardless+ assert watchdog._is_url_allowed('http://8.8.8.8/') is False+ assert watchdog._is_url_allowed('http://192.168.1.1/') is False+++class TestIPBlockingWithProhibitedDomains:+ """Test interaction between IP blocking and prohibited_domains."""++ def test_ip_blocked_regardless_of_prohibited_domains(self):+ """Test that IPs are blocked when IP blocking is on, independent of prohibited_domains."""+ browser_profile = BrowserProfile(+ block_ip_addresses=True, prohibited_domains=['example.com'], headless=True, user_data_dir=None+ )+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # IPs should be blocked due to IP blocking+ assert watchdog._is_url_allowed('http://192.168.1.1/') is False+ assert watchdog._is_url_allowed('http://8.8.8.8/') is False++ # Prohibited domain should be blocked+ assert watchdog._is_url_allowed('https://example.com') is False++ # Other domains should be allowed+ assert watchdog._is_url_allowed('https://other.com') is True++ def test_prohibited_domains_without_ip_blocking(self):+ """Test that prohibited_domains works normally when IP blocking is disabled."""+ browser_profile = BrowserProfile(+ block_ip_addresses=False, prohibited_domains=['example.com', '8.8.8.8'], headless=True, user_data_dir=None+ )+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Prohibited domain should be blocked+ assert watchdog._is_url_allowed('https://example.com') is False++ # IP in prohibited list should be blocked (by prohibited_domains, not IP blocking)+ assert watchdog._is_url_allowed('http://8.8.8.8/') is False++ # Other IPs should be allowed (IP blocking is off)+ assert watchdog._is_url_allowed('http://192.168.1.1/') is True++ # Other domains should be allowed+ assert watchdog._is_url_allowed('https://other.com') is True+++class TestEdgeCases:+ """Test edge cases and invalid inputs."""++ def test_invalid_urls_handled_gracefully(self):+ """Test that invalid URLs don't cause crashes."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Invalid URLs should return False+ assert watchdog._is_url_allowed('not-a-url') is False+ assert watchdog._is_url_allowed('') is False+ assert watchdog._is_url_allowed('http://') is False+ assert watchdog._is_url_allowed('://example.com') is False++ def test_internal_browser_urls_allowed(self):+ """Test that internal browser URLs are still allowed with IP blocking."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Internal URLs should always be allowed+ assert watchdog._is_url_allowed('about:blank') is True+ assert watchdog._is_url_allowed('chrome://new-tab-page/') is True+ assert watchdog._is_url_allowed('chrome://new-tab-page') is True+ assert watchdog._is_url_allowed('chrome://newtab/') is True++ def test_ipv4_lookalike_domains_allowed(self):+ """Test that domains that look like IPs but aren't are still allowed."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # These look like IPs but have too many/few octets or invalid ranges+ # The IP parser should reject them, so they're treated as domain names+ assert watchdog._is_url_allowed('http://999.999.999.999/') is True # Invalid IP range+ assert watchdog._is_url_allowed('http://1.2.3.4.5/') is True # Too many octets+ assert watchdog._is_url_allowed('http://1.2.3/') is True # Too few octets++ def test_different_schemes_with_ips(self):+ """Test that IP blocking works across different URL schemes."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # HTTP and HTTPS+ assert watchdog._is_url_allowed('http://192.168.1.1/') is False+ assert watchdog._is_url_allowed('https://192.168.1.1/') is False++ # FTP (if browser supports it)+ assert watchdog._is_url_allowed('ftp://192.168.1.1/') is False++ # WebSocket (parsed as regular URL)+ assert watchdog._is_url_allowed('ws://192.168.1.1:8080/') is False+ assert watchdog._is_url_allowed('wss://192.168.1.1:8080/') is False+++class TestIsIPAddressHelper:+ """Test the _is_ip_address helper method directly."""++ def test_valid_ipv4_detection(self):+ """Test that valid IPv4 addresses are correctly detected."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Valid IPv4 addresses+ assert watchdog._is_ip_address('127.0.0.1') is True+ assert watchdog._is_ip_address('192.168.1.1') is True+ assert watchdog._is_ip_address('8.8.8.8') is True+ assert watchdog._is_ip_address('255.255.255.255') is True+ assert watchdog._is_ip_address('0.0.0.0') is True++ def test_valid_ipv6_detection(self):+ """Test that valid IPv6 addresses are correctly detected."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Valid IPv6 addresses (without brackets - those are URL-specific)+ assert watchdog._is_ip_address('::1') is True+ assert watchdog._is_ip_address('2001:db8::1') is True+ assert watchdog._is_ip_address('2001:4860:4860::8888') is True+ assert watchdog._is_ip_address('fe80::1') is True+ assert watchdog._is_ip_address('2001:db8:85a3::8a2e:370:7334') is True++ def test_invalid_ip_detection(self):+ """Test that non-IP strings are correctly identified as not IPs."""+ browser_profile = BrowserProfile(block_ip_addresses=True, headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Domain names (not IPs)+ assert watchdog._is_ip_address('example.com') is False+ assert watchdog._is_ip_address('www.google.com') is False+ assert watchdog._is_ip_address('localhost') is False++ # Invalid IPs+ assert watchdog._is_ip_address('999.999.999.999') is False+ assert watchdog._is_ip_address('1.2.3') is False+ assert watchdog._is_ip_address('1.2.3.4.5') is False+ assert watchdog._is_ip_address('not-an-ip') is False+ assert watchdog._is_ip_address('') is False++ # IPs with ports or paths (not valid for the helper - it only checks hostnames)+ assert watchdog._is_ip_address('192.168.1.1:8080') is False+ assert watchdog._is_ip_address('192.168.1.1/path') is False+++class TestDefaultBehavior:+ """Test that default behavior (no IP blocking) is maintained."""++ def test_default_block_ip_addresses_is_false(self):+ """Test that block_ip_addresses defaults to False."""+ browser_profile = BrowserProfile(headless=True, user_data_dir=None)++ # Default should be False+ assert browser_profile.block_ip_addresses is False++ def test_no_blocking_by_default(self):+ """Test that IPs are not blocked by default."""+ browser_profile = BrowserProfile(headless=True, user_data_dir=None)+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # All IPs should be allowed by default+ assert watchdog._is_url_allowed('http://180.1.1.1/supersafe.txt') is True+ assert watchdog._is_url_allowed('http://192.168.1.1/') is True+ assert watchdog._is_url_allowed('http://127.0.0.1:8080/') is True+ assert watchdog._is_url_allowed('http://[::1]/') is True+ assert watchdog._is_url_allowed('https://8.8.8.8/') is True+++class TestComplexScenarios:+ """Test complex real-world scenarios."""++ def test_mixed_configuration_comprehensive(self):+ """Test a complex configuration with multiple security settings."""+ browser_profile = BrowserProfile(+ block_ip_addresses=True,+ allowed_domains=['example.com', '*.google.com'],+ prohibited_domains=['bad.example.com'], # Should be ignored when allowlist is set+ headless=True,+ user_data_dir=None,+ )+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Allowed domains should work+ assert watchdog._is_url_allowed('https://example.com') is True+ assert watchdog._is_url_allowed('https://www.google.com') is True+ assert watchdog._is_url_allowed('https://mail.google.com') is True++ # IPs should be blocked+ assert watchdog._is_url_allowed('http://8.8.8.8/') is False+ assert watchdog._is_url_allowed('http://192.168.1.1/') is False++ # Domains not in allowlist should be blocked+ assert watchdog._is_url_allowed('https://other.com') is False++ def test_localhost_development_scenario(self):+ """Test typical local development scenario."""+ # Developer wants to block external IPs but allow domain names+ browser_profile = BrowserProfile(+ block_ip_addresses=True,+ headless=True,+ user_data_dir=None, # No domain restrictions+ )+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Domain names should work (including localhost as a name)+ assert watchdog._is_url_allowed('http://localhost:3000/') is True+ assert watchdog._is_url_allowed('http://localhost:8080/api') is True++ # But localhost IP should be blocked+ assert watchdog._is_url_allowed('http://127.0.0.1:3000/') is False++ # External domains should work+ assert watchdog._is_url_allowed('https://api.example.com') is True++ # External IPs should be blocked+ assert watchdog._is_url_allowed('http://8.8.8.8/') is False++ def test_security_hardening_scenario(self):+ """Test maximum security scenario with IP blocking and domain restrictions."""+ browser_profile = BrowserProfile(+ block_ip_addresses=True,+ allowed_domains=['example.com', 'api.example.com'],+ headless=True,+ user_data_dir=None,+ )+ browser_session = BrowserSession(browser_profile=browser_profile)+ event_bus = EventBus()+ watchdog = SecurityWatchdog(browser_session=browser_session, event_bus=event_bus)++ # Only specified domains allowed+ assert watchdog._is_url_allowed('https://example.com') is True+ assert watchdog._is_url_allowed('https://api.example.com') is True++ # IPs blocked+ assert watchdog._is_url_allowed('http://192.168.1.1/') is False++ # Other domains blocked+ assert watchdog._is_url_allowed('https://other.com') is False++ # Even localhost blocked+ assert watchdog._is_url_allowed('http://127.0.0.1/') is False