chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/cmds/passphrase_funcs.py

@@ -0,0 +1,292 @@
+from __future__ import annotations
+
+import os
+import sys
+from getpass import getpass
+from io import TextIOWrapper
+from pathlib import Path
+from typing import Any, Optional
+
+import click
+import colorama
+
+from chia.daemon.client import acquire_connection_to_daemon
+from chia.util.keychain import Keychain, supports_os_passphrase_storage
+from chia.util.keyring_wrapper import DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE, obtain_current_passphrase
+
+SAVE_MASTER_PASSPHRASE_WARNING = (
+    colorama.Fore.YELLOW
+    + colorama.Style.BRIGHT
+    + "\n!!! SECURITY WARNING !!!\n"
+    + colorama.Style.RESET_ALL
+    + "Other processes may be able to access your saved passphrase, possibly exposing your private keys.\n"
+    + "You should not save your passphrase unless you fully trust your environment.\n"
+)
+
+
+def verify_passphrase_meets_requirements(
+    new_passphrase: str, confirmation_passphrase: str
+) -> tuple[bool, Optional[str]]:
+    match = new_passphrase == confirmation_passphrase
+    min_length = Keychain.minimum_passphrase_length()
+    meets_len_requirement = len(new_passphrase) >= min_length
+
+    if match and meets_len_requirement:
+        return True, None
+    elif not match:
+        return False, "Passphrases do not match"
+    elif not meets_len_requirement:
+        return False, f"Minimum passphrase length is {min_length}"
+    else:
+        raise Exception("Unexpected passphrase verification case")
+
+
+def prompt_to_save_passphrase() -> bool:
+    save: bool = False
+
+    try:
+        if supports_os_passphrase_storage():
+            location: Optional[str] = None
+            warning: Optional[str] = None
+
+            if sys.platform == "darwin":
+                location = "macOS Keychain"
+                warning = SAVE_MASTER_PASSPHRASE_WARNING
+            elif sys.platform == "win32" or sys.platform == "cygwin":
+                location = "Windows Credential Manager"
+                warning = SAVE_MASTER_PASSPHRASE_WARNING
+
+            if location is None:
+                raise ValueError("OS-specific credential store not specified")
+
+            print(
+                "\n"
+                "Your passphrase can be stored in your system's secure credential store. "
+                "Other Chia processes will be able to access your keys without prompting for your passphrase."
+            )
+            if warning is not None:
+                colorama.init()
+
+                print(warning)
+            save = click.confirm(f"Would you like to save your passphrase to the {location}?", default=None)
+
+    except Exception as e:
+        print(f"Caught exception: {e}")
+        return False
+
+    return save
+
+
+def prompt_for_new_passphrase() -> tuple[str, bool]:
+    min_length: int = Keychain.minimum_passphrase_length()
+    if min_length > 0:
+        n = min_length
+        print(f"\nPassphrases must be {n} or more characters in length")  # lgtm [py/clear-text-logging-sensitive-data]
+    while True:
+        passphrase: str = getpass("New Passphrase: ")
+        confirmation: str = getpass("Confirm Passphrase: ")
+        save_passphrase: bool = False
+
+        valid_passphrase, error_msg = verify_passphrase_meets_requirements(passphrase, confirmation)
+
+        if valid_passphrase:
+            if supports_os_passphrase_storage():
+                save_passphrase = prompt_to_save_passphrase()
+
+            return passphrase, save_passphrase
+        elif error_msg:
+            print(f"{error_msg}\n")  # lgtm [py/clear-text-logging-sensitive-data]
+
+
+def read_passphrase_from_file(passphrase_file: TextIOWrapper) -> str:
+    passphrase = passphrase_file.read().rstrip(os.environ.get("CHIA_PASSPHRASE_STRIP_TRAILING_CHARS", "\r\n"))
+    passphrase_file.close()
+    return passphrase
+
+
+def initialize_passphrase() -> None:
+    if Keychain.has_master_passphrase():
+        print("Keyring is already protected by a passphrase")
+        print("\nUse 'chia passphrase set' or 'chia passphrase remove' to update or remove your passphrase")
+        sys.exit(1)
+
+    # We'll rely on Keyring initialization to leverage the cached passphrase for
+    # bootstrapping the keyring encryption process
+    print("Setting keyring passphrase")
+    passphrase: Optional[str] = None
+    # save_passphrase indicates whether the passphrase should be saved in the
+    # macOS Keychain or Windows Credential Manager
+    save_passphrase: bool = False
+
+    if Keychain.has_cached_passphrase():
+        passphrase = Keychain.get_cached_master_passphrase()
+
+    if not passphrase or passphrase == default_passphrase():
+        passphrase, save_passphrase = prompt_for_new_passphrase()
+
+    Keychain.set_master_passphrase(current_passphrase=None, new_passphrase=passphrase, save_passphrase=save_passphrase)
+
+
+def set_or_update_passphrase(passphrase: Optional[str], current_passphrase: Optional[str], hint: Optional[str]) -> bool:
+    # Prompt for the current passphrase, if necessary
+    if Keychain.has_master_passphrase():
+        # Try the default passphrase first
+        if using_default_passphrase():
+            current_passphrase = default_passphrase()
+
+        if not current_passphrase:
+            try:
+                current_passphrase = obtain_current_passphrase("Current Passphrase: ")
+            except Exception as e:
+                print(f"Unable to confirm current passphrase: {e}")
+                sys.exit(1)
+
+    success: bool = False
+    new_passphrase: Optional[str] = passphrase
+    save_passphrase: bool = False
+
+    try:
+        # Prompt for the new passphrase, if necessary
+        if new_passphrase is None:
+            new_passphrase, save_passphrase = prompt_for_new_passphrase()
+
+        if new_passphrase == current_passphrase:
+            raise ValueError("passphrase is unchanged")
+
+        Keychain.set_master_passphrase(
+            current_passphrase=current_passphrase,
+            new_passphrase=new_passphrase,
+            passphrase_hint=hint,
+            save_passphrase=save_passphrase,
+        )
+        success = True
+    except Exception as e:
+        print(f"Unable to set or update passphrase: {e}")
+        success = False
+
+    return success
+
+
+def remove_passphrase(current_passphrase: Optional[str]) -> bool:
+    """
+    Removes the user's keyring passphrase. The keyring will be re-encrypted to the default passphrase.
+    """
+    success = False
+
+    if not Keychain.has_master_passphrase() or using_default_passphrase():
+        print("Passphrase is not currently set")
+        success = False
+    else:
+        # Try the default passphrase first
+        if using_default_passphrase():
+            current_passphrase = default_passphrase()
+
+        # Prompt for the current passphrase, if necessary
+        if not current_passphrase:
+            try:
+                current_passphrase = obtain_current_passphrase("Current Passphrase: ")
+            except Exception as e:
+                print(f"Unable to confirm current passphrase: {e}")
+                success = False
+
+        if current_passphrase:
+            try:
+                Keychain.remove_master_passphrase(current_passphrase)
+                success = True
+            except Exception as e:
+                print(f"Unable to remove passphrase: {e}")
+                success = False
+
+    return success
+
+
+def cache_passphrase(passphrase: str) -> None:
+    Keychain.set_cached_master_passphrase(passphrase)
+
+
+def get_current_passphrase() -> Optional[str]:
+    if not Keychain.has_master_passphrase():
+        return None
+
+    current_passphrase = None
+    if using_default_passphrase():
+        current_passphrase = default_passphrase()
+    else:
+        try:
+            current_passphrase = obtain_current_passphrase()
+        except Exception as e:
+            print(f"Unable to confirm current passphrase: {e}")
+            raise
+
+    return current_passphrase
+
+
+def default_passphrase() -> str:
+    return DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE
+
+
+def using_default_passphrase() -> bool:
+    if not Keychain.has_master_passphrase():
+        return False
+
+    return Keychain.master_passphrase_is_valid(default_passphrase())
+
+
+def display_passphrase_hint() -> None:
+    passphrase_hint = Keychain.get_master_passphrase_hint()
+    if passphrase_hint is not None:
+        print(f"Passphrase hint: {passphrase_hint}")  # lgtm [py/clear-text-logging-sensitive-data]
+    else:
+        print("Passphrase hint is not set")
+
+
+def update_passphrase_hint(hint: Optional[str] = None) -> bool:
+    updated: bool = False
+    if Keychain.has_master_passphrase() is False or using_default_passphrase():
+        print("Updating the passphrase hint requires that a passphrase has been set")
+    else:
+        current_passphrase: Optional[str] = get_current_passphrase()
+        if current_passphrase is None:
+            print("Keyring is not passphrase-protected")
+        else:
+            # Set or remove the passphrase hint
+            Keychain.set_master_passphrase_hint(current_passphrase, hint)
+            updated = True
+
+    return updated
+
+
+def set_passphrase_hint(hint: str) -> None:
+    if update_passphrase_hint(hint):
+        print("Passphrase hint set")
+    else:
+        print("Passphrase hint was not updated")
+
+
+def remove_passphrase_hint() -> None:
+    if update_passphrase_hint(None):
+        print("Passphrase hint removed")
+    else:
+        print("Passphrase hint was not removed")
+
+
+async def async_update_daemon_passphrase_cache_if_running(root_path: Path, config: dict[str, Any]) -> None:
+    """
+    Attempt to connect to the daemon and update the cached passphrase
+    """
+    new_passphrase = Keychain.get_cached_master_passphrase()
+    assert new_passphrase is not None
+
+    try:
+        async with acquire_connection_to_daemon(root_path, config, quiet=True) as daemon:
+            if daemon is not None:
+                response = await daemon.unlock_keyring(new_passphrase)
+                if response is None:
+                    raise Exception("daemon didn't respond")
+
+                success: bool = response.get("data", {}).get("success", False)
+                if success is False:
+                    error = response.get("data", {}).get("error", "unknown error")
+                    raise Exception(error)
+    except Exception as e:
+        print(f"Failed to notify daemon of updated keyring passphrase: {e}")

chia/cmds/peer.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import click
+
+from chia.cmds.cmd_classes import ChiaCliContext
+from chia.cmds.cmds_util import NODE_TYPES
+from chia.cmds.peer_funcs import peer_async
+
+
+@click.command("peer", help="Show, or modify peering connections", no_args_is_help=True)
+@click.option(
+    "-p",
+    "--rpc-port",
+    help=(
+        "Set the port where the farmer, wallet, full node or harvester "
+        "is hosting the RPC interface. See the rpc_port in config.yaml"
+    ),
+    type=int,
+    default=None,
+)
+@click.option(
+    "-c", "--connections", help="List connections to the specified service", is_flag=True, type=bool, default=False
+)
+@click.option("-a", "--add-connection", help="Connect specified Chia service to ip:port", type=str, default="")
+@click.option(
+    "-r", "--remove-connection", help="Remove a Node by the first 8 characters of NodeID", type=str, default=""
+)
+@click.argument("node_type", type=click.Choice(list(NODE_TYPES.keys())), nargs=1, required=True)
+@click.pass_context
+def peer_cmd(
+    ctx: click.Context,
+    rpc_port: Optional[int],
+    connections: bool,
+    add_connection: str,
+    remove_connection: str,
+    node_type: str,
+) -> None:
+    import asyncio
+
+    asyncio.run(
+        peer_async(
+            node_type,
+            rpc_port,
+            ChiaCliContext.set_default(ctx).root_path,
+            connections,
+            add_connection,
+            remove_connection,
+        )
+    )

chia/cmds/peer_funcs.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional
+
+from chia.cmds.cmds_util import NODE_TYPES, get_any_service_client
+from chia.rpc.rpc_client import RpcClient
+
+
+async def add_node_connection(rpc_client: RpcClient, add_connection: str) -> None:
+    if ":" not in add_connection:
+        print("Enter a valid IP and port in the following format: 10.5.4.3:8000")
+    else:
+        ip, port = (
+            ":".join(add_connection.split(":")[:-1]),
+            add_connection.split(":")[-1],
+        )
+        print(f"Connecting to {ip}, {port}")
+        try:
+            result = await rpc_client.open_connection(ip, int(port))
+            err = result.get("error")
+            if result["success"] is False or err is not None:
+                print(err)
+        except Exception:
+            print(f"Failed to connect to {ip}:{port}")
+
+
+async def remove_node_connection(rpc_client: RpcClient, remove_connection: str) -> None:
+    from chia.server.outbound_message import NodeType
+
+    result_txt = ""
+    if len(remove_connection) != 8:
+        result_txt = "Invalid NodeID. Do not include '.'"
+    else:
+        connections = await rpc_client.get_connections()
+        for con in connections:
+            if remove_connection == con["node_id"].hex()[:8]:
+                print("Attempting to disconnect", "NodeID", remove_connection)
+                try:
+                    await rpc_client.close_connection(con["node_id"])
+                except Exception:
+                    result_txt = f"Failed to disconnect NodeID {remove_connection}"
+                else:
+                    result_txt = (
+                        f"NodeID {remove_connection}... {NodeType(con['type']).name} {con['peer_host']} disconnected"
+                    )
+            elif result_txt == "":
+                result_txt = f"NodeID {remove_connection}... not found"
+    print(result_txt)
+
+
+async def print_connections(rpc_client: RpcClient, trusted_peers: dict[str, Any], trusted_cidrs: list[str]) -> None:
+    import time
+
+    from chia.server.outbound_message import NodeType
+    from chia.util.network import is_trusted_peer
+
+    connections = await rpc_client.get_connections()
+    print("Connections:")
+    print("Type      IP                                      Ports       NodeID      Last Connect" + "      MiB Up|Dwn")
+    for con in connections:
+        last_connect_tuple = time.struct_time(time.localtime(con["last_message_time"]))
+        last_connect = time.strftime("%b %d %T", last_connect_tuple)
+        mb_down = con["bytes_read"] / (1024 * 1024)
+        mb_up = con["bytes_written"] / (1024 * 1024)
+
+        host = con["peer_host"]
+        # Strip IPv6 brackets
+        host = host.strip("[]")
+
+        trusted: bool = is_trusted_peer(host, con["node_id"], trusted_peers, trusted_cidrs, False)
+        # Nodetype length is 9 because INTRODUCER will be deprecated
+        if NodeType(con["type"]) is NodeType.FULL_NODE:
+            peak_height = con.get("peak_height", None)
+            connection_peak_hash = con.get("peak_hash", None)
+            if connection_peak_hash is None:
+                connection_peak_hash = "No Info"
+            else:
+                if connection_peak_hash.startswith(("0x", "0X")):
+                    connection_peak_hash = connection_peak_hash[2:]
+                connection_peak_hash = f"{connection_peak_hash[:8]}..."
+            con_str = (
+                f"{NodeType(con['type']).name:9} {host:39} "
+                f"{con['peer_port']:5}/{con['peer_server_port']:<5}"
+                f" {con['node_id'].hex()[:8]}... "
+                f"{last_connect}  "
+                f"{mb_up:7.1f}|{mb_down:<7.1f}"
+                f"\n                                                  "
+            )
+            if peak_height is not None:
+                con_str += f"-Height: {peak_height:8.0f}    -Hash: {connection_peak_hash}"
+            else:
+                con_str += f"-Height: No Info    -Hash: {connection_peak_hash}"
+            # Only show when Trusted is True
+            if trusted:
+                con_str += f"    -Trusted: {trusted}"
+        else:
+            con_str = (
+                f"{NodeType(con['type']).name:9} {host:39} "
+                f"{con['peer_port']:5}/{con['peer_server_port']:<5}"
+                f" {con['node_id'].hex()[:8]}... "
+                f"{last_connect}  "
+                f"{mb_up:7.1f}|{mb_down:<7.1f}"
+            )
+            if trusted:
+                con_str += f"    -Trusted: {trusted}"
+        print(con_str)
+
+
+async def peer_async(
+    node_type: str,
+    rpc_port: Optional[int],
+    root_path: Path,
+    show_connections: bool,
+    add_connection: str,
+    remove_connection: str,
+) -> None:
+    client_type = NODE_TYPES[node_type]
+    async with get_any_service_client(client_type, root_path, rpc_port) as (rpc_client, config):
+        # Check or edit node connections
+        if show_connections:
+            trusted_peers: dict[str, Any] = config[node_type].get("trusted_peers", {})
+            trusted_cidrs: list[str] = config[node_type].get("trusted_cidrs", [])
+            await print_connections(rpc_client, trusted_peers, trusted_cidrs)
+            # if called together with state, leave a blank line
+        if add_connection:
+            await add_node_connection(rpc_client, add_connection)
+        if remove_connection:
+            await remove_node_connection(rpc_client, remove_connection)