File size: 5,943 Bytes
065fee7 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 |
"""
Core API functions and initialization routines.
"""
import configparser
import logging
import os
import sys
import typing
from . import backend, credentials
from .backends import fail
from .util import platform_ as platform
LimitCallable = typing.Callable[[backend.KeyringBackend], bool]
log = logging.getLogger(__name__)
_keyring_backend = None
def set_keyring(keyring: backend.KeyringBackend) -> None:
"""Set current keyring backend."""
global _keyring_backend
if not isinstance(keyring, backend.KeyringBackend):
raise TypeError("The keyring must be an instance of KeyringBackend")
_keyring_backend = keyring
def get_keyring() -> backend.KeyringBackend:
"""Get current keyring backend."""
if _keyring_backend is None:
init_backend()
return typing.cast(backend.KeyringBackend, _keyring_backend)
def disable() -> None:
"""
Configure the null keyring as the default.
>>> fs = getfixture('fs')
>>> disable()
>>> disable()
Traceback (most recent call last):
...
RuntimeError: Refusing to overwrite...
"""
root = platform.config_root()
try:
os.makedirs(root)
except OSError:
pass
filename = os.path.join(root, 'keyringrc.cfg')
if os.path.exists(filename):
msg = f"Refusing to overwrite {filename}"
raise RuntimeError(msg)
with open(filename, 'w', encoding='utf-8') as file:
file.write('[backend]\ndefault-keyring=keyring.backends.null.Keyring')
def get_password(service_name: str, username: str) -> typing.Optional[str]:
"""Get password from the specified service."""
return get_keyring().get_password(service_name, username)
def set_password(service_name: str, username: str, password: str) -> None:
"""Set password for the user in the specified service."""
get_keyring().set_password(service_name, username, password)
def delete_password(service_name: str, username: str) -> None:
"""Delete the password for the user in the specified service."""
get_keyring().delete_password(service_name, username)
def get_credential(
service_name: str, username: typing.Optional[str]
) -> typing.Optional[credentials.Credential]:
"""Get a Credential for the specified service."""
return get_keyring().get_credential(service_name, username)
def recommended(backend) -> bool:
return backend.priority >= 1
def init_backend(limit: typing.Optional[LimitCallable] = None):
"""
Load a detected backend.
"""
set_keyring(_detect_backend(limit))
def _detect_backend(limit: typing.Optional[LimitCallable] = None):
"""
Return a keyring specified in the config file or infer the best available.
Limit, if supplied, should be a callable taking a backend and returning
True if that backend should be included for consideration.
"""
# save the limit for the chainer to honor
backend._limit = limit
return (
load_env()
or load_config()
or max(
# all keyrings passing the limit filter
filter(limit, backend.get_all_keyring()), # type: ignore # 659
default=fail.Keyring(),
key=backend.by_priority,
)
)
def _load_keyring_class(keyring_name: str) -> typing.Type[backend.KeyringBackend]:
"""
Load the keyring class indicated by name.
These popular names are tested to ensure their presence.
>>> popular_names = [
... 'keyring.backends.Windows.WinVaultKeyring',
... 'keyring.backends.macOS.Keyring',
... 'keyring.backends.kwallet.DBusKeyring',
... 'keyring.backends.SecretService.Keyring',
... ]
>>> list(map(_load_keyring_class, popular_names))
[...]
"""
module_name, sep, class_name = keyring_name.rpartition('.')
__import__(module_name)
module = sys.modules[module_name]
return getattr(module, class_name)
def load_keyring(keyring_name: str) -> backend.KeyringBackend:
"""
Load the specified keyring by name (a fully-qualified name to the
keyring, such as 'keyring.backends.file.PlaintextKeyring')
"""
class_ = _load_keyring_class(keyring_name)
# invoke the priority to ensure it is viable, or raise a RuntimeError
class_.priority # noqa: B018
return class_()
def load_env() -> typing.Optional[backend.KeyringBackend]:
"""Load a keyring configured in the environment variable."""
try:
return load_keyring(os.environ['PYTHON_KEYRING_BACKEND'])
except KeyError:
return None
def _config_path():
return platform.config_root() / 'keyringrc.cfg'
def _ensure_path(path):
if not path.exists():
raise FileNotFoundError(path)
return path
def load_config() -> typing.Optional[backend.KeyringBackend]:
"""Load a keyring using the config file in the config root."""
config = configparser.RawConfigParser()
try:
config.read(_ensure_path(_config_path()), encoding='utf-8')
except FileNotFoundError:
return None
_load_keyring_path(config)
# load the keyring class name, and then load this keyring
try:
if config.has_section("backend"):
keyring_name = config.get("backend", "default-keyring").strip()
else:
raise configparser.NoOptionError('backend', 'default-keyring')
except (configparser.NoOptionError, ImportError):
logger = logging.getLogger('keyring')
logger.warning(
"Keyring config file contains incorrect values.\n"
+ f"Config file: {_config_path()}"
)
return None
return load_keyring(keyring_name)
def _load_keyring_path(config: configparser.RawConfigParser) -> None:
"load the keyring-path option (if present)"
try:
path = config.get("backend", "keyring-path").strip()
sys.path.insert(0, path)
except (configparser.NoOptionError, configparser.NoSectionError):
pass
|