snowflake-connector-python 3.16.0__cp313-cp313-win_amd64.whl

snowflake/connector/snow_logging.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import logging
+import warnings
+from collections.abc import Mapping
+from typing import Any
+
+
+def getSnowLogger(
+    name: str,
+    extra: Mapping[str, object] | None = None,
+) -> SnowLogger:
+    logger = logging.getLogger(name)
+    return SnowLogger(logger, extra)  # type:ignore[arg-type]
+
+
+class SnowLogger(logging.LoggerAdapter):
+    """Snowflake Python logger wrapper of the built-in Python logger.
+
+    This logger wrapper supports user-provided logging info about
+    file name, function name and line number. This wrapper can be
+    used in Cython code (.pyx).
+    """
+
+    def debug(  # type: ignore[override]
+        self,
+        msg: str,
+        path_name: str | None = None,
+        func_name: str | None = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        self.log(logging.DEBUG, msg, path_name, func_name, *args, **kwargs)
+
+    def info(  # type: ignore[override]
+        self,
+        msg: str,
+        path_name: str | None = None,
+        func_name: str | None = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        self.log(logging.INFO, msg, path_name, func_name, *args, **kwargs)
+
+    def warning(  # type: ignore[override]
+        self,
+        msg: str,
+        path_name: str | None = None,
+        func_name: str | None = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        self.log(logging.WARNING, msg, path_name, func_name, *args, **kwargs)
+
+    def warn(  # type: ignore[override]
+        self,
+        msg: str,
+        path_name: str | None = None,
+        func_name: str | None = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        warnings.warn(
+            "The 'warn' method is deprecated, " "use 'warning' instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.warning(msg, path_name, func_name, *args, **kwargs)
+
+    def error(  # type: ignore[override]
+        self,
+        msg: str,
+        path_name: str | None = None,
+        func_name: str | None = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        self.log(logging.ERROR, msg, path_name, func_name, *args, **kwargs)
+
+    def exception(  # type: ignore[override]
+        self,
+        msg: str,
+        path_name: str | None = None,
+        func_name: str | None = None,
+        *args: Any,
+        exc_info: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """Convenience method for logging an ERROR with exception information."""
+        self.error(msg, path_name, func_name, *args, exc_info=exc_info, **kwargs)
+
+    def critical(  # type: ignore[override]
+        self,
+        msg: str,
+        path_name: str | None = None,
+        func_name: str | None = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        self.log(logging.CRITICAL, msg, path_name, func_name, *args, **kwargs)
+
+    fatal = critical
+
+    def log(  # type: ignore[override]
+        self,
+        level: int,
+        msg: str,
+        path_name: str | None = None,
+        func_name: str | None = None,
+        line_num: int = 0,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Generalized log method of SnowLogger wrapper.
+
+        Args:
+            level: Logging level.
+            msg: Logging message.
+            path_name: Absolute or relative path of the file where the logger gets called.
+            func_name: Function inside which the logger gets called.
+            line_num: Line number at which the logger gets called.
+        """
+        if not path_name:
+            path_name = "path_name not provided"
+        if not func_name:
+            func_name = "func_name not provided"
+        if not isinstance(level, int):
+            if logging.raiseExceptions:
+                raise TypeError("level must be an integer")
+            else:
+                return
+        if self.logger.isEnabledFor(level):
+            record = self.logger.makeRecord(
+                self.logger.name,
+                level,
+                path_name,
+                line_num,
+                msg,
+                args,
+                None,
+                func_name,
+                **kwargs,
+            )
+            self.logger.handle(record)

snowflake/connector/sqlstate.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+SQLSTATE_CONNECTION_WAS_NOT_ESTABLISHED = "08001"
+SQLSTATE_CONNECTION_ALREADY_EXISTS = "08002"
+SQLSTATE_CONNECTION_NOT_EXISTS = "08003"
+SQLSTATE_CONNECTION_REJECTED = "08004"
+SQLSTATE_CONNECTION_FAILED_BUT_REESTABLISHED = "08506"
+SQLSTATE_HOST_NOT_FOUND = "08508"
+SQLSTATE_FEATURE_NOT_SUPPORTED = "0A000"
+SQLSTATE_IO_ERROR = "58030"

snowflake/connector/ssd_internal_keys.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+from binascii import unhexlify
+
+# key version
+ocsp_internal_dep1_key_ver = 0.1
+ocsp_internal_dep2_key_ver = 0.1
+
+# OCSP Hard coded public keys
+ocsp_internal_ssd_pub_dep1 = None
+ocsp_internal_ssd_pub_dep2 = None
+
+# Default cert if for key update directives
+SF_KEY_UPDATE_SSD_DEFAULT_CERT_ID = 0
+
+
+def ret_int_pub_key_ver(issuer):
+    if issuer == "dep1":
+        return ocsp_internal_dep1_key_ver
+    else:
+        return ocsp_internal_dep2_key_ver
+
+
+def ret_wildcard_hkey():
+    issuer_name_hash = unhexlify("040130")
+    issuer_key_hash = unhexlify("040130")
+    serial_number = unhexlify("020100")
+    hkey = (issuer_name_hash, issuer_key_hash, serial_number)
+    return hkey

snowflake/connector/ssl_wrap_socket.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+#
+# SSL wrap socket for PyOpenSSL.
+# Mostly copied from
+#
+# https://github.com/shazow/urllib3/blob/master/urllib3/contrib/pyopenssl.py
+#
+# and added OCSP validator on the top.
+import logging
+import time
+from functools import wraps
+from inspect import getfullargspec as get_args
+from socket import socket
+from typing import Any
+
+import certifi
+import OpenSSL.SSL
+
+from .constants import OCSPMode
+from .errorcode import ER_OCSP_RESPONSE_CERT_STATUS_REVOKED
+from .errors import OperationalError
+from .vendored.urllib3 import connection as connection_
+from .vendored.urllib3.contrib.pyopenssl import PyOpenSSLContext, WrappedSocket
+from .vendored.urllib3.util import ssl_ as ssl_
+
+DEFAULT_OCSP_MODE: OCSPMode = OCSPMode.FAIL_OPEN
+FEATURE_OCSP_MODE: OCSPMode = DEFAULT_OCSP_MODE
+
+"""
+OCSP Response cache file name
+"""
+FEATURE_OCSP_RESPONSE_CACHE_FILE_NAME: str | None = None
+
+log = logging.getLogger(__name__)
+
+
+def inject_into_urllib3() -> None:
+    """Monkey-patch urllib3 with PyOpenSSL-backed SSL-support and OCSP."""
+    log.debug("Injecting ssl_wrap_socket_with_ocsp")
+    connection_.ssl_wrap_socket = ssl_wrap_socket_with_ocsp
+
+
+@wraps(ssl_.ssl_wrap_socket)
+def ssl_wrap_socket_with_ocsp(*args: Any, **kwargs: Any) -> WrappedSocket:
+    # Extract host_name
+    hostname_index = get_args(ssl_.ssl_wrap_socket).args.index("server_hostname")
+    server_hostname = (
+        args[hostname_index]
+        if len(args) > hostname_index
+        else kwargs.get("server_hostname", None)
+    )
+    # Remove context if present
+    ssl_context_index = get_args(ssl_.ssl_wrap_socket).args.index("ssl_context")
+    context_in_args = len(args) > ssl_context_index
+    ssl_context = (
+        args[hostname_index] if context_in_args else kwargs.get("ssl_context", None)
+    )
+    if not isinstance(ssl_context, PyOpenSSLContext):
+        # Create new default context
+        if context_in_args:
+            new_args = list(args)
+            new_args[ssl_context_index] = None
+            args = tuple(new_args)
+        else:
+            del kwargs["ssl_context"]
+    # Fix ca certs location
+    ca_certs_index = get_args(ssl_.ssl_wrap_socket).args.index("ca_certs")
+    ca_certs_in_args = len(args) > ca_certs_index
+    if not ca_certs_in_args and not kwargs.get("ca_certs"):
+        kwargs["ca_certs"] = certifi.where()
+
+    ret = ssl_.ssl_wrap_socket(*args, **kwargs)
+
+    log.debug(
+        "OCSP Mode: %s, " "OCSP response cache file name: %s",
+        FEATURE_OCSP_MODE.name,
+        FEATURE_OCSP_RESPONSE_CACHE_FILE_NAME,
+    )
+    if FEATURE_OCSP_MODE != OCSPMode.DISABLE_OCSP_CHECKS:
+        from .ocsp_asn1crypto import SnowflakeOCSPAsn1Crypto as SFOCSP
+
+        v = SFOCSP(
+            ocsp_response_cache_uri=FEATURE_OCSP_RESPONSE_CACHE_FILE_NAME,
+            use_fail_open=FEATURE_OCSP_MODE == OCSPMode.FAIL_OPEN,
+            hostname=server_hostname,
+        ).validate(server_hostname, ret.connection)
+        if not v:
+            raise OperationalError(
+                msg=(
+                    "The certificate is revoked or "
+                    "could not be validated: hostname={}".format(server_hostname)
+                ),
+                errno=ER_OCSP_RESPONSE_CERT_STATUS_REVOKED,
+            )
+    else:
+        log.debug(
+            "This connection does not perform OCSP checks. "
+            "Revocation status of the certificate will not be checked against OCSP Responder."
+        )
+
+    return ret
+
+
+def _openssl_connect(
+    hostname: str, port: int = 443, max_retry: int = 20, timeout: int | None = None
+) -> OpenSSL.SSL.Connection:
+    """The OpenSSL connection without validating certificates.
+
+    This is used to diagnose SSL issues.
+    """
+    err = None
+    sleeping_time = 1
+    for _ in range(max_retry):
+        try:
+            client = socket()
+            client.connect((hostname, port))
+            context = OpenSSL.SSL.Context(OpenSSL.SSL.SSLv23_METHOD)
+            if timeout is not None:
+                context.set_timeout(timeout)
+            client_ssl = OpenSSL.SSL.Connection(context, client)
+            client_ssl.set_connect_state()
+            client_ssl.set_tlsext_host_name(hostname.encode("utf-8"))
+            client_ssl.do_handshake()
+            return client_ssl
+        except (
+            OpenSSL.SSL.SysCallError,
+            OSError,
+        ) as ex:
+            err = ex
+            sleeping_time = min(sleeping_time * 2, 16)
+            time.sleep(sleeping_time)
+    if err:
+        raise err