TestValidateSafeUrl Class — langchain Architecture

Source Code

libs/core/tests/unit_tests/test_ssrf_protection.py lines 85–183

class TestValidateSafeUrl:
    """Tests for validate_safe_url function."""

    def test_valid_public_https_url(self) -> None:
        """Test that valid public HTTPS URLs are accepted."""
        url = "https://hooks.slack.com/services/xxx"
        result = validate_safe_url(url)
        assert result == url

    def test_valid_public_http_url(self) -> None:
        """Test that valid public HTTP URLs are accepted."""
        url = "http://example.com/webhook"
        result = validate_safe_url(url)
        assert result == url

    def test_localhost_blocked_by_default(self) -> None:
        """Test that localhost URLs are blocked by default."""
        with pytest.raises(ValueError, match="Localhost"):
            validate_safe_url("http://localhost:8080/webhook")

        with pytest.raises(ValueError, match="localhost"):
            validate_safe_url("http://127.0.0.1:8080/webhook")

    def test_localhost_allowed_with_flag(self) -> None:
        """Test that localhost is allowed with allow_private=True."""
        url = "http://localhost:8080/webhook"
        result = validate_safe_url(url, allow_private=True)
        assert result == url

        url = "http://127.0.0.1:8080/webhook"
        result = validate_safe_url(url, allow_private=True)
        assert result == url

    def test_private_ip_blocked_by_default(self) -> None:
        """Test that private IPs are blocked by default."""
        with pytest.raises(ValueError, match="private IP"):
            validate_safe_url("http://192.168.1.1/webhook")

        with pytest.raises(ValueError, match="private IP"):
            validate_safe_url("http://10.0.0.1/webhook")

        with pytest.raises(ValueError, match="private IP"):
            validate_safe_url("http://172.16.0.1/webhook")

    def test_private_ip_allowed_with_flag(self) -> None:
        """Test that private IPs are allowed with allow_private=True."""
        # Note: These will fail DNS resolution in tests, so we skip actual validation
        # In production, they would be validated properly

    def test_cloud_metadata_always_blocked(self) -> None:
        """Test that cloud metadata endpoints are always blocked."""
        with pytest.raises(ValueError, match="metadata"):
            validate_safe_url("http://169.254.169.254/latest/meta-data/")

        # Even with allow_private=True
        with pytest.raises(ValueError, match="metadata"):
            validate_safe_url(
                "http://169.254.169.254/latest/meta-data/",
                allow_private=True,
            )

    def test_invalid_scheme_blocked(self) -> None:
        """Test that non-HTTP(S) schemes are blocked."""
        with pytest.raises(ValueError, match="scheme"):
            validate_safe_url("ftp://example.com/file")

        with pytest.raises(ValueError, match="scheme"):
            validate_safe_url("file:///etc/passwd")

        with pytest.raises(ValueError, match="scheme"):
            validate_safe_url("javascript:alert(1)")

    def test_https_only_mode(self) -> None:
        """Test that HTTP is blocked when allow_http=False."""
        with pytest.raises(ValueError, match="HTTPS"):
            validate_safe_url("http://example.com/webhook", allow_http=False)

        # HTTPS should still work
        url = "https://example.com/webhook"
        result = validate_safe_url(url, allow_http=False)
        assert result == url