chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/util/keyring_wrapper.py

@@ -0,0 +1,327 @@
+# Package: utils
+
+from __future__ import annotations
+
+import sys
+import time
+from getpass import getpass
+from pathlib import Path
+from sys import platform
+from typing import ClassVar, Optional, Union, overload
+
+import colorama
+from keyring.backends.macOS import Keyring as MacKeyring
+from keyring.backends.Windows import WinVaultKeyring as WinKeyring
+from keyring.errors import KeyringError, PasswordDeleteError
+from typing_extensions import Literal
+
+from chia.util.default_root import DEFAULT_KEYS_ROOT_PATH
+from chia.util.errors import KeychainMaxUnlockAttempts
+from chia.util.file_keyring import FileKeyring
+
+# We want to protect the keyring, even if a user-specified master passphrase isn't provided
+#
+# WARNING: Changing the default passphrase will prevent passphrase-less users from accessing
+# their existing keys. Using a new default passphrase requires migrating existing users to
+# the new passphrase.
+DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE = "$ chia passphrase set # all the cool kids are doing it!"
+
+MASTER_PASSPHRASE_SERVICE_NAME = "Chia Passphrase"
+MASTER_PASSPHRASE_USER_NAME = "Chia Passphrase"
+
+
+OSPassphraseStore = Union[MacKeyring, WinKeyring]
+
+
+def get_os_passphrase_store() -> Optional[OSPassphraseStore]:
+    if platform == "darwin":
+        return MacKeyring()  # type: ignore[no-untyped-call]
+    elif platform == "win32" or platform == "cygwin":
+        return WinKeyring()  # type: ignore[no-untyped-call]
+    return None
+
+
+def warn_if_macos_errSecInteractionNotAllowed(error: KeyringError) -> bool:
+    """
+    Check if the macOS Keychain error is errSecInteractionNotAllowed. This commonly
+    occurs when the keychain is accessed while headless (such as remoting into a Mac
+    via SSH). Because macOS Keychain operations may require prompting for login creds,
+    a connection to the WindowServer is required. Returns True if the error was
+    handled.
+    """
+
+    if "-25308" in str(error):
+        print(
+            "WARNING: Unable to access the macOS Keychain (-25308 errSecInteractionNotAllowed). "
+            "Are you logged-in remotely?"
+        )
+        return True
+    return False
+
+
+DEFAULT_PASSPHRASE_PROMPT = (
+    colorama.Fore.YELLOW + colorama.Style.BRIGHT + "(Unlock Keyring)" + colorama.Style.RESET_ALL + " Passphrase: "
+)
+FAILED_ATTEMPT_DELAY = 0.5
+MAX_RETRIES = 3
+
+
+def prompt_for_passphrase(prompt: str) -> str:
+    if sys.platform == "win32" or sys.platform == "cygwin":
+        print(prompt, end="", flush=True)
+        prompt = ""
+    return getpass(prompt)
+
+
+def obtain_current_passphrase(prompt: str = DEFAULT_PASSPHRASE_PROMPT, use_passphrase_cache: bool = False) -> str:
+    from chia.util.keyring_wrapper import KeyringWrapper
+
+    """
+    Obtains the master passphrase for the keyring, optionally using the cached
+    value (if previously set). If the passphrase isn't already cached, the user is
+    prompted interactively to enter their passphrase a max of MAX_RETRIES times
+    before failing.
+    """
+
+    if use_passphrase_cache:
+        passphrase, validated = KeyringWrapper.get_shared_instance().get_cached_master_passphrase()
+        if passphrase:
+            # If the cached passphrase was previously validated, we assume it's... valid
+            if validated:
+                return passphrase
+
+            # Cached passphrase needs to be validated
+            if KeyringWrapper.get_shared_instance().master_passphrase_is_valid(passphrase):
+                KeyringWrapper.get_shared_instance().set_cached_master_passphrase(passphrase, validated=True)
+                return passphrase
+            else:
+                # Cached passphrase is bad, clear the cache
+                KeyringWrapper.get_shared_instance().set_cached_master_passphrase(None)
+
+    # Prompt interactively with up to MAX_RETRIES attempts
+    for i in range(MAX_RETRIES):
+        colorama.init()
+
+        passphrase = prompt_for_passphrase(prompt)
+
+        if KeyringWrapper.get_shared_instance().master_passphrase_is_valid(passphrase):
+            # If using the passphrase cache, and the user inputted a passphrase, update the cache
+            if use_passphrase_cache:
+                KeyringWrapper.get_shared_instance().set_cached_master_passphrase(passphrase, validated=True)
+            return passphrase
+
+        time.sleep(FAILED_ATTEMPT_DELAY)
+        print("Incorrect passphrase\n")
+    raise KeychainMaxUnlockAttempts()
+
+
+class KeyringWrapper:
+    """
+    KeyringWrapper provides an abstraction that the Keychain class can use
+    without requiring knowledge of the keyring backend. During initialization,
+    a keyring backend is selected based on the OS.
+
+    The wrapper is implemented as a singleton, as it may need to manage state
+    related to the master passphrase.
+    """
+
+    # Static members
+    __shared_instance: ClassVar[Optional[KeyringWrapper]] = None
+    __keys_root_path: ClassVar[Path] = DEFAULT_KEYS_ROOT_PATH
+
+    # Instance members
+    keys_root_path: Path
+    keyring: FileKeyring
+    cached_passphrase: Optional[str] = None
+    cached_passphrase_is_validated: bool = False
+
+    def __init__(self, keys_root_path: Path = DEFAULT_KEYS_ROOT_PATH):
+        """
+        Initializes the keyring backend.
+        """
+
+        self.keys_root_path = keys_root_path
+        self.keyring = self._configure_backend()
+
+        # Initialize the cached_passphrase
+        self.cached_passphrase = self._get_initial_cached_passphrase()
+
+    def _configure_backend(self) -> FileKeyring:
+        return FileKeyring.create(keys_root_path=self.keys_root_path)
+
+    def _get_initial_cached_passphrase(self) -> str:
+        """
+        Grab the saved passphrase from the OS credential store (if available), otherwise
+        use the default passphrase
+        """
+        from chia.util.keychain import supports_os_passphrase_storage
+
+        passphrase: Optional[str] = None
+
+        if supports_os_passphrase_storage():
+            passphrase = self.get_master_passphrase_from_credential_store()
+
+        if passphrase is None:
+            passphrase = DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE
+
+        return passphrase
+
+    @staticmethod
+    def set_keys_root_path(keys_root_path: Path) -> None:
+        """
+        Used to set the keys_root_path prior to instantiating the __shared_instance
+        """
+        KeyringWrapper.__keys_root_path = keys_root_path
+
+    @overload
+    @staticmethod
+    def get_shared_instance() -> KeyringWrapper: ...
+
+    @overload
+    @staticmethod
+    def get_shared_instance(create_if_necessary: Literal[True]) -> KeyringWrapper: ...
+
+    @overload
+    @staticmethod
+    def get_shared_instance(create_if_necessary: bool) -> Optional[KeyringWrapper]: ...
+
+    @staticmethod
+    def get_shared_instance(create_if_necessary: bool = True) -> Optional[KeyringWrapper]:
+        if not KeyringWrapper.__shared_instance and create_if_necessary:
+            KeyringWrapper.__shared_instance = KeyringWrapper(keys_root_path=KeyringWrapper.__keys_root_path)
+
+        return KeyringWrapper.__shared_instance
+
+    @staticmethod
+    def cleanup_shared_instance() -> None:
+        KeyringWrapper.__shared_instance = None
+
+    def get_keyring(self) -> FileKeyring:
+        """
+        Return the current keyring backend.
+        """
+        return self.keyring
+
+    # Master passphrase support
+
+    def get_cached_master_passphrase(self) -> tuple[Optional[str], bool]:
+        """
+        Returns a tuple including the currently cached passphrase and a bool
+        indicating whether the passphrase has been previously validated.
+        """
+        return self.cached_passphrase, self.cached_passphrase_is_validated
+
+    def set_cached_master_passphrase(self, passphrase: Optional[str], validated: bool = False) -> None:
+        """
+        Cache the provided passphrase and optionally indicate whether the passphrase
+        has been validated.
+        """
+        self.cached_passphrase = passphrase
+        self.cached_passphrase_is_validated = validated
+
+    def has_cached_master_passphrase(self) -> bool:
+        passphrase = self.get_cached_master_passphrase()
+        return passphrase is not None and len(passphrase) > 0
+
+    def has_master_passphrase(self) -> bool:
+        """
+        Returns a bool indicating whether the underlying keyring data
+        is secured by a master passphrase.
+        """
+        return self.keyring.has_content()
+
+    def master_passphrase_is_valid(self, passphrase: str, force_reload: bool = False) -> bool:
+        return self.keyring.check_passphrase(passphrase, force_reload=force_reload)
+
+    def set_master_passphrase(
+        self,
+        current_passphrase: Optional[str],
+        new_passphrase: str,
+        *,
+        write_to_keyring: bool = True,
+        passphrase_hint: Optional[str] = None,
+        save_passphrase: bool = False,
+    ) -> None:
+        """
+        Sets a new master passphrase for the keyring
+        """
+        from chia.util.errors import KeychainCurrentPassphraseIsInvalid
+        from chia.util.keychain import supports_os_passphrase_storage
+
+        # Require a valid current_passphrase
+        if (
+            self.has_master_passphrase()
+            and current_passphrase is not None
+            and not self.master_passphrase_is_valid(current_passphrase)
+        ):
+            raise KeychainCurrentPassphraseIsInvalid()
+
+        self.set_cached_master_passphrase(new_passphrase, validated=True)
+
+        self.keyring.set_passphrase_hint(passphrase_hint)
+
+        if write_to_keyring:
+            # We're reencrypting the keyring contents using the new passphrase. Ensure that the
+            # payload has been decrypted by calling load_keyring with the current passphrase.
+            self.keyring.load_keyring(passphrase=current_passphrase)
+            self.keyring.write_keyring(fresh_salt=True)  # Create a new salt since we're changing the passphrase
+
+        if supports_os_passphrase_storage():
+            if save_passphrase:
+                self.save_master_passphrase_to_credential_store(new_passphrase)
+            else:
+                self.remove_master_passphrase_from_credential_store()
+
+    def remove_master_passphrase(self, current_passphrase: Optional[str]) -> None:
+        """
+        Remove the user-specific master passphrase. We still keep the keyring contents encrypted
+        using the default passphrase.
+        """
+        self.set_master_passphrase(current_passphrase, DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE)
+
+    def save_master_passphrase_to_credential_store(self, passphrase: str) -> None:
+        passphrase_store: Optional[OSPassphraseStore] = get_os_passphrase_store()
+        if passphrase_store is not None:
+            try:
+                passphrase_store.set_password(
+                    MASTER_PASSPHRASE_SERVICE_NAME,
+                    MASTER_PASSPHRASE_USER_NAME,
+                    passphrase,
+                )
+            except KeyringError as e:
+                if not warn_if_macos_errSecInteractionNotAllowed(e):
+                    raise
+
+    def remove_master_passphrase_from_credential_store(self) -> None:
+        passphrase_store: Optional[OSPassphraseStore] = get_os_passphrase_store()
+        if passphrase_store is not None:
+            try:
+                passphrase_store.delete_password(
+                    MASTER_PASSPHRASE_SERVICE_NAME,
+                    MASTER_PASSPHRASE_USER_NAME,
+                )
+            except PasswordDeleteError:
+                if (
+                    passphrase_store.get_credential(MASTER_PASSPHRASE_SERVICE_NAME, MASTER_PASSPHRASE_USER_NAME)
+                    is not None
+                ):
+                    raise
+            except KeyringError as e:
+                if not warn_if_macos_errSecInteractionNotAllowed(e):
+                    raise
+
+    def get_master_passphrase_from_credential_store(self) -> Optional[str]:
+        passphrase_store: Optional[OSPassphraseStore] = get_os_passphrase_store()
+        if passphrase_store is not None:
+            try:
+                return passphrase_store.get_password(  # type: ignore[no-any-return]
+                    MASTER_PASSPHRASE_SERVICE_NAME,
+                    MASTER_PASSPHRASE_USER_NAME,
+                )
+            except KeyringError as e:
+                if not warn_if_macos_errSecInteractionNotAllowed(e):
+                    raise
+        return None
+
+    def get_master_passphrase_hint(self) -> Optional[str]:
+        return self.keyring.get_passphrase_hint()

chia/util/limited_semaphore.py

@@ -0,0 +1,41 @@
+# Package: utils
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+
+from typing_extensions import final
+
+
+class LimitedSemaphoreFullError(Exception):
+    def __init__(self) -> None:
+        super().__init__("no waiting slot available")
+
+
+@final
+@dataclass
+class LimitedSemaphore:
+    _semaphore: asyncio.Semaphore
+    _available_count: int
+
+    @classmethod
+    def create(cls, active_limit: int, waiting_limit: int) -> LimitedSemaphore:
+        return cls(
+            _semaphore=asyncio.Semaphore(active_limit),
+            _available_count=active_limit + waiting_limit,
+        )
+
+    @contextlib.asynccontextmanager
+    async def acquire(self) -> AsyncIterator[int]:
+        if self._available_count < 1:
+            raise LimitedSemaphoreFullError()
+
+        self._available_count -= 1
+        try:
+            async with self._semaphore:
+                yield self._available_count
+        finally:
+            self._available_count += 1

chia/util/lock.py

@@ -0,0 +1,49 @@
+# Package: utils
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from types import TracebackType
+from typing import Optional
+
+from filelock import BaseFileLock, FileLock, Timeout
+from typing_extensions import final
+
+
+class LockfileError(Exception):
+    pass
+
+
+@final
+@dataclass(frozen=True)
+class Lockfile:
+    _lock: BaseFileLock
+    timeout: float
+    poll_interval: float
+
+    @classmethod
+    def create(cls, path: Path, timeout: float = -1, poll_interval: float = 0.05) -> Lockfile:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return cls(_lock=FileLock(path.with_name(path.name + ".lock")), timeout=timeout, poll_interval=poll_interval)
+
+    def __enter__(self) -> Lockfile:
+        self.acquire(timeout=self.timeout, poll_interval=self.poll_interval)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        self.release()
+
+    def acquire(self, timeout: float, poll_interval: float) -> None:
+        try:
+            self._lock.acquire(timeout=timeout, poll_interval=poll_interval)
+        except Timeout as e:
+            raise LockfileError(e) from e
+
+    def release(self) -> None:
+        self._lock.release()

chia/util/log_exceptions.py

@@ -0,0 +1,32 @@
+# Package: utils
+
+from __future__ import annotations
+
+import logging
+import traceback
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Union
+
+
+@contextmanager
+def log_exceptions(
+    log: logging.Logger,
+    *,
+    consume: bool = False,
+    message: str = "Caught exception",
+    level: int = logging.ERROR,
+    show_traceback: bool = True,
+    exceptions_to_process: Union[type[BaseException], tuple[type[BaseException], ...]] = Exception,
+) -> Iterator[None]:
+    try:
+        yield
+    except exceptions_to_process as e:
+        message = f"{message}: {type(e).__name__}: {e}"
+        if show_traceback:
+            message += f"\n{traceback.format_exc()}"
+
+        log.log(level, message)
+
+        if not consume:
+            raise

chia/util/logging.py

@@ -0,0 +1,36 @@
+# Package: utils
+
+from __future__ import annotations
+
+import logging
+import re
+import time
+from re import Pattern
+
+
+class TimedDuplicateFilter(logging.Filter):
+    last_log_time: float
+    regex: Pattern[str]
+    min_time_wait_secs: int
+
+    def __init__(self, regex_str: str, min_time_wait_secs: int, name: str = ""):
+        super().__init__(name)
+        self.last_log_time = time.monotonic()
+        self.regex = re.compile(regex_str)
+        self.min_time_wait_secs = min_time_wait_secs
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        _ = super().filter(record)
+        if not _:
+            return False
+
+        msg = record.getMessage()
+
+        if self.regex.match(msg):
+            now = time.monotonic()
+            if now - self.last_log_time > self.min_time_wait_secs:
+                self.last_log_time = now
+                return True
+            return False
+        else:
+            return True

chia/util/lru_cache.py

@@ -0,0 +1,31 @@
+# Package: utils
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from typing import Generic, Optional, TypeVar
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class LRUCache(Generic[K, V]):
+    def __init__(self, capacity: int):
+        self.cache: OrderedDict[K, V] = OrderedDict()
+        self.capacity = capacity
+
+    def get(self, key: K) -> Optional[V]:
+        if key not in self.cache:
+            return None
+        else:
+            self.cache.move_to_end(key)
+            return self.cache[key]
+
+    def put(self, key: K, value: V) -> None:
+        self.cache[key] = value
+        self.cache.move_to_end(key)
+        if len(self.cache) > self.capacity:
+            self.cache.popitem(last=False)
+
+    def remove(self, key: K) -> None:
+        self.cache.pop(key)

chia/util/math.py

@@ -0,0 +1,20 @@
+# Package: utils
+
+from __future__ import annotations
+
+
+def clamp(n: int, smallest: int, largest: int) -> int:
+    return max(smallest, min(n, largest))
+
+
+def make_monotonically_decreasing(seq: list[float]) -> list[float]:
+    out: list[float] = []
+    if len(seq) > 0:
+        min = seq[0]
+        for n in seq:
+            if n <= min:
+                out.append(n)
+                min = n
+            else:
+                out.append(min)
+    return out