snowflake-connector-python 4.7.2__tar.gz → 4.7.3__tar.gz

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/DESCRIPTION.md

@@ -7,6 +7,26 @@ https://docs.snowflake.com/
 Source code is also available at: https://github.com/snowflakedb/snowflake-connector-python
 
 # Release Notes
+- v4.7.3(Sep 3,2026)
+  - Added experimental Python 3.14t (free-threaded CPython) wheel support. **Experimental — not intended for production use.**
+  - Fixed TLS hostname verification rejecting matching certificate SANs when a Snowflake account locator contains an underscore (SNOW-4011646).
+  - Fixed `connect()` being significantly slower on deep call stacks (e.g. Django apps with several middleware/decorator layers) because `get_application_path()` used `inspect.stack()`, which reads and parses the source file of every frame on the stack. It now walks frame references directly instead (SNOW-3691001, #2908).
+  - Fixed `split_statements` truncating unquoted URLs containing `://` at the `//`, misreading it as a line comment. The guards added alongside `//` comment support in 4.7.2 (SNOW-3772985) only recognized `file://`, so every other scheme (`http://`, `https://`, `s3://`, `snow://`, `azure://`) was cut short. Any `scheme://` is now recognized, on both the line-comment and block-comment paths (the latter affected globs such as `s3://bucket/*.csv`) (SNOW-3930192).
+  - Result batch construction now logs only whether a `qrmk` is present, for both the sync and async result paths (SNOW-3675590).
+  - DEBUG logging in `create_batches_from_response()` reports chunk-header names with type/length value metadata (SNOW-3675590).
+  - The malformed-response ERROR log in `create_batches_from_response()` reports a structural summary of the response (SNOW-3675590).
+  - SQL text is masked before it is written to DEBUG logs: `_format_query_for_log()` runs the query through `SecretDetector`, covering the cursor and connection paths on both sync and async. The cancel-query log paths use the same masking (SNOW-3675590).
+  - Deferred the SQL-masking cost to log emit-time: query DEBUG lines pass a lazy `_format_query_for_log_lazy()` wrapper whose `__str__` masks only when a handler emits the record (SNOW-3675590).
+  - Corrected the invalid-account-identifier error message so it matches the validator, which allows '.' as a label separator.
+  - The `WORKLOAD_IDENTITY` authenticator runs only against recognized Snowflake hosts: the connection host is normalized and suffix-anchored against `snowflakecomputing.com`, `.cn`, and `.mil` before the workload-identity flow proceeds. The `SNOWFLAKE_WIF_ALLOWED_HOST_SUFFIXES` environment variable additively extends the recognized-host list (SNOW-3675580).
+  - Improved the robustness and correctness of OCSP revocation checking (SNOW-3675581).
+    - When `SF_OCSP_RESPONSE_CACHE_SERVER_URL` is set, the connector uses it as the OCSP cache server, including on PrivateLink hosts.
+    - A PrivateLink OCSP cache URL is derived only for hosts that consist of hostname characters, include a `.privatelink.` label, and end at `snowflakecomputing.com`, `.cn`, or `.mil`. Other hosts use the public default cache URL; set `SF_OCSP_RESPONSE_CACHE_SERVER_URL` to use a different cache server.
+  - Extended log secret masking coverage (SNOW-3675583). The connection-token pattern accepts `:` and `%` in the token value. Added patterns for OAuth access and refresh tokens in serialized JSON, for one-time passcodes, and for OAuth client identifiers and secrets. The passcode pattern accepts quoted values. The password pattern requires at least six characters in the value, so ordinary prose following the word "password" is not redacted.
+  - Request headers are copied before mutation on the async path, and masking is applied to the `Authorization` header in error logs (SNOW-3675593).
+  - Applied secret masking to the `snowflake.connector` loggers by default, independent of how application logging is configured. The same filter also covers the third-party loggers the connector uses (`botocore`, `boto3`, `aiohttp`, `aiobotocore`, `aioboto3`, vendored `urllib3`). Set `SNOWFLAKE_DISABLE_LOG_SECRET_MASKING=true` to opt out; it is honored at emit time, including after import (SNOW-3675583).
+  - Fixed the on-disk OCSP response validation cache failing with `RuntimeError: UnixFileLock on ... was inherited across fork; construct a new instance` when it was written from a forked child process. This could surface on fork-based platforms when fetching results with `client_fetch_use_mp=True`, where chunk downloads run in worker processes that perform their own certificate revocation checks. The cache's file lock is now re-created when the owning process changes, matching what already happened for the `spawn` start method.
+
 - v4.7.2(Aug 6,2026)
   - Fixed a thread leak in the file transfer agent by properly shutting down ThreadPoolExecutors after PUT/GET transfers (SNOW-3556240, #2878).
   - Fixed `split_statements` treating `//` as SQL instead of a line comment, which could merge multiple statements when a `//` comment contained an apostrophe (SNOW-3772985).

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-connector-python
-Version: 4.7.2
+Version: 4.7.3
 Summary: Snowflake Connector for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc
@@ -97,6 +97,26 @@ https://docs.snowflake.com/
 Source code is also available at: https://github.com/snowflakedb/snowflake-connector-python
 
 # Release Notes
+- v4.7.3(Sep 3,2026)
+  - Added experimental Python 3.14t (free-threaded CPython) wheel support. **Experimental — not intended for production use.**
+  - Fixed TLS hostname verification rejecting matching certificate SANs when a Snowflake account locator contains an underscore (SNOW-4011646).
+  - Fixed `connect()` being significantly slower on deep call stacks (e.g. Django apps with several middleware/decorator layers) because `get_application_path()` used `inspect.stack()`, which reads and parses the source file of every frame on the stack. It now walks frame references directly instead (SNOW-3691001, #2908).
+  - Fixed `split_statements` truncating unquoted URLs containing `://` at the `//`, misreading it as a line comment. The guards added alongside `//` comment support in 4.7.2 (SNOW-3772985) only recognized `file://`, so every other scheme (`http://`, `https://`, `s3://`, `snow://`, `azure://`) was cut short. Any `scheme://` is now recognized, on both the line-comment and block-comment paths (the latter affected globs such as `s3://bucket/*.csv`) (SNOW-3930192).
+  - Result batch construction now logs only whether a `qrmk` is present, for both the sync and async result paths (SNOW-3675590).
+  - DEBUG logging in `create_batches_from_response()` reports chunk-header names with type/length value metadata (SNOW-3675590).
+  - The malformed-response ERROR log in `create_batches_from_response()` reports a structural summary of the response (SNOW-3675590).
+  - SQL text is masked before it is written to DEBUG logs: `_format_query_for_log()` runs the query through `SecretDetector`, covering the cursor and connection paths on both sync and async. The cancel-query log paths use the same masking (SNOW-3675590).
+  - Deferred the SQL-masking cost to log emit-time: query DEBUG lines pass a lazy `_format_query_for_log_lazy()` wrapper whose `__str__` masks only when a handler emits the record (SNOW-3675590).
+  - Corrected the invalid-account-identifier error message so it matches the validator, which allows '.' as a label separator.
+  - The `WORKLOAD_IDENTITY` authenticator runs only against recognized Snowflake hosts: the connection host is normalized and suffix-anchored against `snowflakecomputing.com`, `.cn`, and `.mil` before the workload-identity flow proceeds. The `SNOWFLAKE_WIF_ALLOWED_HOST_SUFFIXES` environment variable additively extends the recognized-host list (SNOW-3675580).
+  - Improved the robustness and correctness of OCSP revocation checking (SNOW-3675581).
+    - When `SF_OCSP_RESPONSE_CACHE_SERVER_URL` is set, the connector uses it as the OCSP cache server, including on PrivateLink hosts.
+    - A PrivateLink OCSP cache URL is derived only for hosts that consist of hostname characters, include a `.privatelink.` label, and end at `snowflakecomputing.com`, `.cn`, or `.mil`. Other hosts use the public default cache URL; set `SF_OCSP_RESPONSE_CACHE_SERVER_URL` to use a different cache server.
+  - Extended log secret masking coverage (SNOW-3675583). The connection-token pattern accepts `:` and `%` in the token value. Added patterns for OAuth access and refresh tokens in serialized JSON, for one-time passcodes, and for OAuth client identifiers and secrets. The passcode pattern accepts quoted values. The password pattern requires at least six characters in the value, so ordinary prose following the word "password" is not redacted.
+  - Request headers are copied before mutation on the async path, and masking is applied to the `Authorization` header in error logs (SNOW-3675593).
+  - Applied secret masking to the `snowflake.connector` loggers by default, independent of how application logging is configured. The same filter also covers the third-party loggers the connector uses (`botocore`, `boto3`, `aiohttp`, `aiobotocore`, `aioboto3`, vendored `urllib3`). Set `SNOWFLAKE_DISABLE_LOG_SECRET_MASKING=true` to opt out; it is honored at emit time, including after import (SNOW-3675583).
+  - Fixed the on-disk OCSP response validation cache failing with `RuntimeError: UnixFileLock on ... was inherited across fork; construct a new instance` when it was written from a forked child process. This could surface on fork-based platforms when fetching results with `client_fetch_use_mp=True`, where chunk downloads run in worker processes that perform their own certificate revocation checks. The cache's file lock is now re-created when the owning process changes, matching what already happened for the `spawn` start method.
+
 - v4.7.2(Aug 6,2026)
   - Fixed a thread leak in the file transfer agent by properly shutting down ThreadPoolExecutors after PUT/GET transfers (SNOW-3556240, #2878).
   - Fixed `split_statements` treating `//` as SQL instead of a line comment, which could merge multiple statements when a `//` comment contained an apostrophe (SNOW-3772985).

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/README.md

@@ -53,6 +53,29 @@ These tools are integrated into `tox` to allow us to easily set them up universa
   and we would like to have an overall coverage data file created for them.
 * **flake8**: (Deprecated) Similar to `fix_lint`, but only runs `flake8` checks.
 
+## Log secret masking
+
+By default, the connector masks secrets (tokens, passwords, cloud credentials,
+private keys) in records emitted by `snowflake.connector` loggers and by the
+third-party loggers it uses (`botocore`, `boto3`, `aiohttp`, `aiobotocore`,
+`aioboto3`, and vendored `urllib3`). Masking applies even when logging is
+configured with `logging.basicConfig`, not only when Easy Logging
+(`save_logs = true` in `config.toml`) is enabled. The same opt-out covers
+those trees: they also interpolate the message and clear `record.args`.
+
+To disable masking, set `SNOWFLAKE_DISABLE_LOG_SECRET_MASKING` to `true`.
+The connector reads this on every log record, so it is an escape hatch if
+masking is incompatible with a log pipeline (for example one that depends
+on structured `record.args`). Setting it **before** importing
+`snowflake.connector` also skips installing the masking hook:
+
+```bash
+export SNOWFLAKE_DISABLE_LOG_SECRET_MASKING=true
+```
+
+The masker interpolates each log record and clears `record.args`. Leave
+masking enabled unless you need that escape hatch.
+
 ## Disable telemetry
 
 By default, the Snowflake Connector for Python collects telemetry data to improve the product.

snowflake_connector_python-4.7.3/src/snowflake/connector/_host_util.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+#
+
+"""Host normalization and recognition shared by every subsystem that turns a
+connection host into the authority of a URL the connector builds itself.
+
+Kept subsystem-agnostic so that WORKLOAD_IDENTITY attestation and OCSP cache-URL
+derivation match hosts identically; a second, slightly different rule in either
+place is what this module exists to prevent. The suffix list itself lives in
+``constants`` so the data stays next to the connector's other TLD constants.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from .constants import _SNOWFLAKE_ALLOWED_HOST_SUFFIXES
+
+# Maps only ASCII A-Z to a-z.
+#
+# Deliberately not str.lower(): full Unicode case folding maps some characters
+# into ASCII, so a host containing U+212A KELVIN SIGN folds
+# "snowfla<U+212A>ecomputing.com" into "snowflakecomputing.com" and would match a
+# recognized suffix while DNS still resolves the original, unrelated name.
+# Leaving non-ASCII untouched lets is_ldh_host reject it instead.
+_ASCII_LOWERCASE_TABLE = str.maketrans(
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz"
+)
+
+# Characters legal in a DNS hostname label, plus '_': account labels
+# legitimately contain one.
+_LDH_CHARACTERS = frozenset("abcdefghijklmnopqrstuvwxyz0123456789-_")
+
+
+def normalize_host(host: str | None) -> str:
+    """Normalizes a host (or a configured host suffix) into the single string that
+    every subsequent check and every derived URL must use.
+
+    Trims, lower-cases ASCII only, drops everything from the first ':' onward,
+    then strips exactly one trailing '.' (FQDN form).
+
+    The port must be dropped before the trailing dot: a host in FQDN form
+    carrying an explicit port ("acct.snowflakecomputing.com.:443") still has the
+    dot immediately before the colon, and removing the dot first would leave it
+    attached to the label and match no suffix.
+    """
+    if not host:
+        return ""
+    normalized = host.strip().translate(_ASCII_LOWERCASE_TABLE)
+    if ":" in normalized:
+        normalized = normalized.split(":", 1)[0]
+    if normalized.endswith("."):
+        normalized = normalized[:-1]
+    return normalized
+
+
+def is_ldh_host(normalized_host: str) -> bool:
+    """Whether an already-normalized host is made only of characters legal in a
+    DNS hostname: every dot-separated label non-empty and drawn from
+    ``[a-z0-9_-]``.
+
+    This is an allow-list, not a list of forbidden delimiters, and that
+    distinction is load-bearing. A host is only safe to interpolate into a URL
+    authority if it cannot carry a character that some URL parser treats as
+    ending the host, and enumerating such characters does not work: parsers
+    variously terminate the authority at a space, ';', "'", a percent-escape, or
+    a full-width look-alike of '.', '#' or '?'. Since a host whose trailing
+    labels are a recognized Snowflake domain can still begin with an unrelated
+    name, a parser that stops early resolves that unrelated name instead.
+
+    Args:
+        normalized_host: output of :func:`normalize_host`.
+    """
+    if not normalized_host:
+        return False
+    return all(
+        label and _LDH_CHARACTERS.issuperset(label)
+        for label in normalized_host.split(".")
+    )
+
+
+def has_recognized_snowflake_suffix(
+    normalized_host: str,
+    extra_suffixes: Iterable[str] | None = None,
+) -> bool:
+    """Whether an already-normalized host ends at one of the recognized Snowflake
+    suffixes, matched on a label boundary so that only a listed suffix and its
+    subdomains qualify. The bare apex is accepted by the equality branch.
+
+    Args:
+        normalized_host: output of :func:`normalize_host`.
+        extra_suffixes: additional already-normalized suffixes to accept.
+            Additive only: callers cannot use this to disable the built-in list.
+    """
+    if not normalized_host:
+        return False
+    suffixes: tuple[str, ...] = _SNOWFLAKE_ALLOWED_HOST_SUFFIXES
+    if extra_suffixes:
+        suffixes = (*suffixes, *extra_suffixes)
+    return any(
+        normalized_host == suffix or normalized_host.endswith(f".{suffix}")
+        for suffix in suffixes
+        if suffix
+    )

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/src/snowflake/connector/_utils.py

@@ -9,7 +9,7 @@ import string
 import threading
 import time
 from enum import Enum
-from inspect import stack
+from inspect import currentframe
 from secrets import choice
 from threading import Timer
 from uuid import UUID
@@ -101,12 +101,24 @@ class _TrackedQueryCancellationTimer(Timer):
 
 
 def get_application_path() -> str:
-    """Get the path of the application script using the connector."""
+    """Get the path of the application script using the connector.
+
+    Walks frame.f_back directly instead of using inspect.stack(), which
+    reads and parses the source file of every frame on the call stack.
+    That per-frame disk I/O made connect() take hundreds of milliseconds
+    on deep call stacks (see SNOW-3691001 / GH-2908).
+    """
+    frame = currentframe()
     try:
-        outermost_frame = stack()[-1]
-        return outermost_frame.filename
+        if frame is None:
+            return "unknown"
+        while frame.f_back is not None:
+            frame = frame.f_back
+        return frame.f_code.co_filename
     except Exception:
         return "unknown"
+    finally:
+        del frame
 
 
 _SPCS_ENV_VAR = "SNOWFLAKE_RUNNING_INSIDE_SPCS"

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/src/snowflake/connector/aio/_connection.py

@@ -120,7 +120,6 @@ else:
 
 
 class SnowflakeConnection(SnowflakeConnectionSync):
-    OCSP_ENV_LOCK = asyncio.Lock()
 
     def __init__(
         self,
@@ -233,20 +232,17 @@ class SnowflakeConnection(SnowflakeConnectionSync):
         )
         logger.debug("REST API object was created: %s:%s", self.host, self.port)
 
+        # The PrivateLink OCSP cache URL is now derived per-connection inside
+        # OCSPServer from this connection's hostname (SNOW-3675581); the driver
+        # does not write SF_OCSP_RESPONSE_CACHE_SERVER_URL to the process
+        # environment. An operator-set value is still honored (and takes
+        # precedence) -- log it if present.
         if "SF_OCSP_RESPONSE_CACHE_SERVER_URL" in os.environ:
             logger.debug(
                 "Custom OCSP Cache Server URL found in environment - %s",
                 os.environ["SF_OCSP_RESPONSE_CACHE_SERVER_URL"],
             )
 
-        if ".privatelink.snowflakecomputing." in self.host.lower():
-            await SnowflakeConnection.setup_ocsp_privatelink(
-                self.application, self.host
-            )
-        else:
-            if "SF_OCSP_RESPONSE_CACHE_SERVER_URL" in os.environ:
-                del os.environ["SF_OCSP_RESPONSE_CACHE_SERVER_URL"]
-
         if self._session_parameters is None:
             self._session_parameters = {}
         if self._autocommit is not None:
@@ -715,7 +711,11 @@ class SnowflakeConnection(SnowflakeConnectionSync):
         self, sql: str, request_id: uuid.UUID
     ) -> dict[str, bool | None]:
         """Cancels the query with the exact SQL query and requestId."""
-        logger.debug("_cancel_query sql=[%s], request_id=[%s]", sql, request_id)
+        logger.debug(
+            "_cancel_query sql=[%s], request_id=[%s]",
+            self._format_query_for_log(sql),
+            request_id,
+        )
         url_parameters = {REQUEST_ID: str(uuid.uuid4())}
 
         return await self.rest.request(
@@ -1233,14 +1233,6 @@ class SnowflakeConnection(SnowflakeConnectionSync):
             self._process_error_query_status(sf_qid, status_resp)
         return status
 
-    @staticmethod
-    async def setup_ocsp_privatelink(app, hostname) -> None:
-        hostname = hostname.lower()
-        async with SnowflakeConnection.OCSP_ENV_LOCK:
-            ocsp_cache_server = f"http://ocsp.{hostname}/ocsp_response_cache.json"
-            os.environ["SF_OCSP_RESPONSE_CACHE_SERVER_URL"] = ocsp_cache_server
-            logger.debug("OCSP Cache Server is updated: %s", ocsp_cache_server)
-
     async def rollback(self) -> None:
         """Rolls back the current transaction."""
         await self.cursor().execute("ROLLBACK")

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/src/snowflake/connector/aio/_cursor.py

@@ -142,7 +142,11 @@ class SnowflakeCursorBase(SnowflakeCursorBaseSync, abc.ABC, typing.Generic[Fetch
 
     async def __cancel_query(self, query) -> None:
         if self._sequence_counter >= 0 and not self.is_closed():
-            logger.debug("canceled. %s, request_id: %s", query, self._request_id)
+            logger.debug(
+                "canceled. %s, request_id: %s",
+                self._format_query_for_log_lazy(query),
+                self._request_id,
+            )
             async with self._lock_canceling:
                 await self._connection._cancel_query(query, self._request_id)
 
@@ -234,7 +238,7 @@ class SnowflakeCursorBase(SnowflakeCursorBaseSync, abc.ABC, typing.Generic[Fetch
 
         logger.debug(f"Request id: {self._request_id}")
 
-        logger.debug("running query [%s]", self._format_query_for_log(query))
+        logger.debug("running query [%s]", self._format_query_for_log_lazy(query))
         if _is_put_get is not None:
             # if told the query is PUT or GET, use the information
             self._is_file_transfer = _is_put_get
@@ -574,7 +578,7 @@ class SnowflakeCursorBase(SnowflakeCursorBaseSync, abc.ABC, typing.Generic[Fetch
                 logger.warning("execute: no query is given to execute")
                 return None
 
-        logger.debug("query: [%s]", self._format_query_for_log(command))
+        logger.debug("query: [%s]", self._format_query_for_log_lazy(command))
 
         _statement_params = _statement_params or dict()
         # If we need to add another parameter, please consider introducing a dict for all extra params

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/src/snowflake/connector/aio/_network.py

@@ -730,6 +730,8 @@ class SnowflakeRestful(SnowflakeRestfulSync):
             else:
                 input_data = data
 
+            # Work on a copy so the caller-supplied dict is never mutated.
+            headers = dict(headers)
             if HEADER_AUTHORIZATION_KEY in headers:
                 del headers[HEADER_AUTHORIZATION_KEY]
             if token != NO_TOKEN:

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/src/snowflake/connector/aio/_ocsp_snowflake.py

@@ -33,7 +33,6 @@ from snowflake.connector.ocsp_snowflake import (
 from snowflake.connector.ocsp_snowflake import OCSPServer as OCSPServerSync
 from snowflake.connector.ocsp_snowflake import OCSPTelemetryData
 from snowflake.connector.ocsp_snowflake import SnowflakeOCSP as SnowflakeOCSPSync
-from snowflake.connector.url_util import extract_top_level_domain_from_hostname
 
 if TYPE_CHECKING:
     from snowflake.connector.aio._session_manager import SessionManager
@@ -157,11 +156,7 @@ class SnowflakeOCSP(SnowflakeOCSPSync):
 
         self._use_post_method = use_post_method
         self._root_certs_dict_lock_timeout = root_certs_dict_lock_timeout
-        self.OCSP_CACHE_SERVER = OCSPServer(
-            top_level_domain=extract_top_level_domain_from_hostname(
-                kwargs.pop("hostname", None)
-            )
-        )
+        self.OCSP_CACHE_SERVER = OCSPServer(hostname=kwargs.pop("hostname", None))
 
         self.debug_ocsp_failure_url = None
 

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/src/snowflake/connector/aio/_result_batch.py

@@ -86,12 +86,19 @@ def create_batches_from_response(
             chunk_headers = {}
             for header_key, header_value in data["chunkHeaders"].items():
                 chunk_headers[header_key] = header_value
-                if "encryption" not in header_key:
-                    logger.debug(
-                        f"added chunk header: key={header_key}, value={header_value}"
-                    )
+                # SNOW-3675590: never log the value — chunk-header values can be
+                # secrets (SSE-C customer key). Log the header name plus
+                # non-sensitive value metadata only. Capture real headers via a
+                # proxy (drivers-usage PROXY=1) when debugging.
+                logger.debug(
+                    f"added chunk header: key={header_key} "
+                    f"value={SecretDetector.describe_value(header_value)}"
+                )
         elif qrmk is not None:
-            logger.debug(f"qrmk={SecretDetector.mask_secrets(qrmk)}")
+            # SNOW-3675590: never log the qrmk value — it is the AES-256 SSE-C
+            # result-encryption key. Log only its presence; do not route it
+            # through masking helpers as a substitute.
+            logger.debug("qrmk is present in the result response")
             chunk_headers[SSE_C_ALGORITHM] = SSE_C_AES
             chunk_headers[SSE_C_KEY] = qrmk
 
@@ -154,7 +161,12 @@ def create_batches_from_response(
             session_manager=cursor._connection._session_manager.clone(),
         )
     else:
-        logger.error(f"Don't know how to construct ResultBatches from response: {data}")
+        # SNOW-3675590: log only the structural shape — the raw response can
+        # carry secrets, and this ERROR line is emitted regardless of DEBUG level.
+        logger.error(
+            "Don't know how to construct ResultBatches from response: "
+            f"format={_format!r}, shape={SecretDetector.describe_value(data)}"
+        )
         first_chunk = ArrowResultBatch.from_data(
             "",
             0,

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/src/snowflake/connector/aio/auth/_workload_identity.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
 from ...auth.workload_identity import (
     AuthByWorkloadIdentity as AuthByWorkloadIdentitySync,
 )
+from ...auth.workload_identity import _verify_host_allowed_for_workload_identity
 from .._wif_util import AttestationProvider, create_attestation
 from ._by_plugin import AuthByPlugin as AuthByPluginAsync
 
@@ -42,6 +43,7 @@ class AuthByWorkloadIdentity(AuthByPluginAsync, AuthByWorkloadIdentitySync):
         self, *, conn: SnowflakeConnection | None, **kwargs: typing.Any
     ) -> None:
         """Fetch the token using async wif_util."""
+        _verify_host_allowed_for_workload_identity(conn)
         self.attestation = await create_attestation(
             self.provider,
             self.entra_resource,

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/src/snowflake/connector/auth/workload_identity.py

@@ -1,12 +1,17 @@
 from __future__ import annotations
 
 import json
+import logging
+import os
 import typing
 from enum import Enum, unique
 
 if typing.TYPE_CHECKING:
     from snowflake.connector.connection import SnowflakeConnection
 
+from .._host_util import has_recognized_snowflake_suffix, normalize_host
+from ..errorcode import ER_WIF_UNTRUSTED_HOST
+from ..errors import ProgrammingError
 from ..network import WORKLOAD_IDENTITY_AUTHENTICATOR
 from ..wif_util import (
     AttestationProvider,
@@ -15,6 +20,72 @@ from ..wif_util import (
 )
 from .by_plugin import AuthByPlugin, AuthType
 
+logger = logging.getLogger(__name__)
+
+# Additive escape hatch for on-prem / air-gapped Snowflake deployments whose host
+# does not end in a recognized Snowflake suffix.
+#
+# Read only from the process environment - never from the DSN, connection
+# parameters or configuration files - so connection configuration cannot
+# influence the allowlist. Entries are additive: they extend the
+# recognized-host list and cannot disable it.
+#
+# Scoped to WORKLOAD_IDENTITY on purpose. Widening the hosts an ambient cloud
+# credential may be sent to is a different decision from widening the hosts an
+# OCSP cache may be fetched from, so the OCSP gate passes no extra suffixes.
+_SNOWFLAKE_WIF_ALLOWED_HOST_SUFFIXES_ENV_VAR = "SNOWFLAKE_WIF_ALLOWED_HOST_SUFFIXES"
+
+
+def _extra_wif_allowed_suffixes() -> list[str]:
+    """Reads the additive SNOWFLAKE_WIF_ALLOWED_HOST_SUFFIXES env-var allow-list.
+
+    Comma-separated, additive-only (never disables the built-in allow-list),
+    normalized the same way as the candidate host. Logs at INFO naming the
+    extra suffixes whenever the env var is used, since this widens the set of
+    hosts the ambient cloud credential may be sent to.
+    """
+    raw = os.environ.get(_SNOWFLAKE_WIF_ALLOWED_HOST_SUFFIXES_ENV_VAR, "")
+    if not raw:
+        return []
+    suffixes = [normalize_host(entry) for entry in raw.split(",") if entry.strip()]
+    suffixes = [s for s in suffixes if s]
+    if suffixes:
+        logger.info(
+            "SNOWFLAKE_WIF_ALLOWED_HOST_SUFFIXES is set; extending the WORKLOAD_IDENTITY "
+            "recognized-host allow-list with additional suffixes: %s.",
+            suffixes,
+        )
+    return suffixes
+
+
+def _is_host_allowed_for_workload_identity(host: str) -> bool:
+    """Returns True if `host` (already-normalized or not) is a trusted WIF destination."""
+    return has_recognized_snowflake_suffix(
+        normalize_host(host), _extra_wif_allowed_suffixes()
+    )
+
+
+def _verify_host_allowed_for_workload_identity(
+    conn: SnowflakeConnection | None,
+) -> None:
+    """Suffix-anchored allowlist that restricts Workload Identity attestation to
+    recognized Snowflake hosts before any cloud credential is fetched.
+
+    When ``conn`` is None there is no destination to send the credential to (e.g.
+    unit tests that only exercise attestation creation), so the check is skipped.
+    """
+    if conn is None:
+        return
+    host = conn.host or ""
+    if not _is_host_allowed_for_workload_identity(host):
+        raise ProgrammingError(
+            msg=(
+                f"WORKLOAD_IDENTITY requires a recognized Snowflake host "
+                f"(*.snowflakecomputing.com, .cn or .mil). Got: '{host}'."
+            ),
+            errno=ER_WIF_UNTRUSTED_HOST,
+        )
+
 
 @unique
 class ApiFederatedAuthenticationType(Enum):
@@ -88,6 +159,9 @@ class AuthByWorkloadIdentity(AuthByPlugin):
         self, *, conn: SnowflakeConnection | None, **kwargs: typing.Any
     ) -> None:
         """Fetch the token."""
+        # Verify the host is a recognized Snowflake endpoint before fetching
+        # cloud credentials.
+        _verify_host_allowed_for_workload_identity(conn)
         self.attestation = create_attestation(
             self.provider,
             self.entra_resource,

{snowflake_connector_python-4.7.2 → snowflake_connector_python-4.7.3}/src/snowflake/connector/cache.py

@@ -451,7 +451,8 @@ class SFDictFileCache(SFDictCache):
                 os.unlink(tmp_file_path)
         self.file_timeout = file_timeout
         self._file_lock_path = f"{self.file_path}.lock"
-        self._file_lock = FileLock(self._file_lock_path, timeout=self.file_timeout)
+        self._file_lock_rebuild_lock = Lock()
+        self._new_file_lock()
         self.last_loaded: datetime.datetime | None = None
         if os.path.exists(self.file_path) and load_if_file_exists:
             with self._lock:
@@ -460,6 +461,33 @@ class SFDictFileCache(SFDictCache):
         # SFDictFileCache to determine whether to dump cache to file when _save is called
         self._cache_modified = False
 
+    def _new_file_lock(self) -> None:
+        """Creates the inter-process file lock owned by the current process."""
+        self._file_lock_instance = FileLock(
+            self._file_lock_path, timeout=self.file_timeout
+        )
+        self._file_lock_pid = os.getpid()
+
+    @property
+    def _file_lock(self) -> FileLock:
+        """The inter-process file lock, re-created when we crossed a fork().
+
+        A FileLock remembers the pid that created it and refuses to be acquired
+        by any other process: the underlying OS lock stays owned by the creator,
+        so it would grant the caller no mutual exclusion at all. Rebuilding it
+        for the multiprocessing "spawn" start method is handled by __setstate__,
+        but fork() copies the object without pickling it, so __setstate__ never
+        runs and the inherited lock is unusable. Notice the pid change here and
+        rebuild instead, which keeps the guarantee the lock is meant to provide.
+        """
+        if self._file_lock_pid != os.getpid():
+            # Held only for the object construction below, never across I/O.
+            with self._file_lock_rebuild_lock:
+                # Another thread may have rebuilt the lock in the meantime.
+                if self._file_lock_pid != os.getpid():
+                    self._new_file_lock()
+        return self._file_lock_instance
+
     def _getitem_non_locking(
         self,
         k: K,
@@ -684,7 +712,8 @@ class SFDictFileCache(SFDictCache):
         self.__dict__.update(state)
         self._cache_modified = False
         self._lock = Lock()
-        self._file_lock = FileLock(self._file_lock_path, timeout=self.file_timeout)
+        self._file_lock_rebuild_lock = Lock()
+        self._new_file_lock()
 
     def _add_or_remove(self) -> None:
         """This function gets called when an element is added, or removed.