File manager - Edit - /var/www/payraty/helpdesk/public/storage/branding_media/images/keyring.tar
Back
usr/bin/keyring 0000755 00000001701 00000000000 0007463 0 ustar 00 #!/usr/bin/python3 # EASY-INSTALL-ENTRY-SCRIPT: 'keyring==23.5.0','console_scripts','keyring' import re import sys # for compatibility with easy_install; see #2198 __requires__ = 'keyring==23.5.0' try: from importlib.metadata import distribution except ImportError: try: from importlib_metadata import distribution except ImportError: from pkg_resources import load_entry_point def importlib_load_entry_point(spec, group, name): dist_name, _, _ = spec.partition('==') matches = ( entry_point for entry_point in distribution(dist_name).entry_points if entry_point.group == group and entry_point.name == name ) return next(matches).load() globals().setdefault('load_entry_point', importlib_load_entry_point) if __name__ == '__main__': sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) sys.exit(load_entry_point('keyring==23.5.0', 'console_scripts', 'keyring')()) backend.py 0000644 00000014350 00000000000 0006451 0 ustar 00 """ Keyring implementation support """ import os import abc import logging import operator from typing import Optional import importlib_metadata as metadata from . import credentials, errors, util from .util import properties log = logging.getLogger(__name__) by_priority = operator.attrgetter('priority') _limit = None class KeyringBackendMeta(abc.ABCMeta): """ A metaclass that's both an ABCMeta and a type that keeps a registry of all (non-abstract) types. """ def __init__(cls, name, bases, dict): super().__init__(name, bases, dict) if not hasattr(cls, '_classes'): cls._classes = set() classes = cls._classes if not cls.__abstractmethods__: classes.add(cls) class KeyringBackend(metaclass=KeyringBackendMeta): """The abstract base class of the keyring, every backend must implement this interface. """ def __init__(self): self.set_properties_from_env() # @abc.abstractproperty def priority(cls): """ Each backend class must supply a priority, a number (float or integer) indicating the priority of the backend relative to all other backends. The priority need not be static -- it may (and should) vary based attributes of the environment in which is runs (platform, available packages, etc.). A higher number indicates a higher priority. The priority should raise a RuntimeError with a message indicating the underlying cause if the backend is not suitable for the current environment. As a rule of thumb, a priority between zero but less than one is suitable, but a priority of one or greater is recommended. """ @properties.ClassProperty @classmethod def viable(cls): with errors.ExceptionRaisedContext() as exc: cls.priority return not exc @classmethod def get_viable_backends(cls): """ Return all subclasses deemed viable. """ return filter(operator.attrgetter('viable'), cls._classes) @properties.ClassProperty @classmethod def name(cls): """ The keyring name, suitable for display. The name is derived from module and class name. """ parent, sep, mod_name = cls.__module__.rpartition('.') mod_name = mod_name.replace('_', ' ') return ' '.join([mod_name, cls.__name__]) def __str__(self): keyring_class = type(self) return "{}.{} (priority: {:g})".format( keyring_class.__module__, keyring_class.__name__, keyring_class.priority ) @abc.abstractmethod def get_password(self, service: str, username: str) -> Optional[str]: """Get password of the username for the service""" return None @abc.abstractmethod def set_password(self, service: str, username: str, password: str) -> None: """Set password for the username of the service. If the backend cannot store passwords, raise PasswordSetError. """ raise errors.PasswordSetError("reason") # for backward-compatibility, don't require a backend to implement # delete_password # @abc.abstractmethod def delete_password(self, service: str, username: str) -> None: """Delete the password for the username of the service. If the backend cannot delete passwords, raise PasswordDeleteError. """ raise errors.PasswordDeleteError("reason") # for backward-compatibility, don't require a backend to implement # get_credential # @abc.abstractmethod def get_credential( self, service: str, username: Optional[str], ) -> Optional[credentials.Credential]: """Gets the username and password for the service. Returns a Credential instance. The *username* argument is optional and may be omitted by the caller or ignored by the backend. Callers must use the returned username. """ # The default implementation requires a username here. if username is not None: password = self.get_password(service, username) if password is not None: return credentials.SimpleCredential(username, password) return None def set_properties_from_env(self): """For all KEYRING_PROPERTY_* env var, set that property.""" def parse(item): key, value = item pre, sep, name = key.partition('KEYRING_PROPERTY_') return sep and (name.lower(), value) props = filter(None, map(parse, os.environ.items())) for name, value in props: setattr(self, name, value) class Crypter: """Base class providing encryption and decryption""" @abc.abstractmethod def encrypt(self, value): """Encrypt the value.""" pass @abc.abstractmethod def decrypt(self, value): """Decrypt the value.""" pass class NullCrypter(Crypter): """A crypter that does nothing""" def encrypt(self, value): return value def decrypt(self, value): return value def _load_plugins(): """ Locate all setuptools entry points by the name 'keyring backends' and initialize them. Any third-party library may register an entry point by adding the following to their setup.cfg:: [options.entry_points] keyring.backends = plugin_name = mylib.mymodule:initialize_func `plugin_name` can be anything, and is only used to display the name of the plugin at initialization time. `initialize_func` is optional, but will be invoked if callable. """ for ep in metadata.entry_points(group='keyring.backends'): try: log.debug('Loading %s', ep.name) init_func = ep.load() if callable(init_func): init_func() except Exception: log.exception(f"Error initializing plugin {ep}.") @util.once def get_all_keyring(): """ Return a list of all implemented keyrings that can be constructed without parameters. """ _load_plugins() viable_classes = KeyringBackend.get_viable_backends() rings = util.suppress_exceptions(viable_classes, exceptions=TypeError) return list(rings) devpi_client.py 0000644 00000000307 00000000000 0007524 0 ustar 00 from pluggy import HookimplMarker import keyring hookimpl = HookimplMarker("devpiclient") @hookimpl() def devpiclient_get_password(url, username): return keyring.get_password(url, username) backends/fail.py 0000644 00000001504 00000000000 0007544 0 ustar 00 from ..backend import KeyringBackend from ..errors import NoKeyringError class Keyring(KeyringBackend): """ Keyring that raises error on every operation. >>> kr = Keyring() >>> kr.get_password('svc', 'user') Traceback (most recent call last): ... keyring.errors.NoKeyringError: ...No recommended backend... """ priority = 0 def get_password(self, service, username, password=None): msg = ( "No recommended backend was available. Install a recommended 3rd " "party backend package; or, install the keyrings.alt package if " "you want to use the non-recommended backends. See " "https://pypi.org/project/keyring for details." ) raise NoKeyringError(msg) set_password = delete_password = get_password # type: ignore backends/SecretService.py 0000644 00000011203 00000000000 0011374 0 ustar 00 from contextlib import closing import logging from ..util import properties from ..backend import KeyringBackend from ..credentials import SimpleCredential from ..errors import ( InitError, PasswordDeleteError, ExceptionRaisedContext, KeyringLocked, ) try: import secretstorage import secretstorage.exceptions as exceptions except ImportError: pass except AttributeError: # See https://github.com/jaraco/keyring/issues/296 pass log = logging.getLogger(__name__) class Keyring(KeyringBackend): """Secret Service Keyring""" appid = 'Python keyring library' @properties.ClassProperty @classmethod def priority(cls): with ExceptionRaisedContext() as exc: secretstorage.__name__ if exc: raise RuntimeError("SecretStorage required") if secretstorage.__version_tuple__ < (3, 2): raise RuntimeError("SecretStorage 3.2 or newer required") try: with closing(secretstorage.dbus_init()) as connection: if not secretstorage.check_service_availability(connection): raise RuntimeError( "The Secret Service daemon is neither running nor " "activatable through D-Bus" ) except exceptions.SecretStorageException as e: raise RuntimeError("Unable to initialize SecretService: %s" % e) return 5 def get_preferred_collection(self): """If self.preferred_collection contains a D-Bus path, the collection at that address is returned. Otherwise, the default collection is returned. """ bus = secretstorage.dbus_init() try: if hasattr(self, 'preferred_collection'): collection = secretstorage.Collection(bus, self.preferred_collection) else: collection = secretstorage.get_default_collection(bus) except exceptions.SecretStorageException as e: raise InitError("Failed to create the collection: %s." % e) if collection.is_locked(): collection.unlock() if collection.is_locked(): # User dismissed the prompt raise KeyringLocked("Failed to unlock the collection!") return collection def unlock(self, item): if hasattr(item, 'unlock'): item.unlock() if item.is_locked(): # User dismissed the prompt raise KeyringLocked('Failed to unlock the item!') def get_password(self, service, username): """Get password of the username for the service""" collection = self.get_preferred_collection() with closing(collection.connection): items = collection.search_items({"username": username, "service": service}) for item in items: self.unlock(item) return item.get_secret().decode('utf-8') def set_password(self, service, username, password): """Set password for the username of the service""" collection = self.get_preferred_collection() attributes = { "application": self.appid, "service": service, "username": username, } label = "Password for '{}' on '{}'".format(username, service) with closing(collection.connection): collection.create_item(label, attributes, password, replace=True) def delete_password(self, service, username): """Delete the stored password (only the first one)""" collection = self.get_preferred_collection() with closing(collection.connection): items = collection.search_items({"username": username, "service": service}) for item in items: return item.delete() raise PasswordDeleteError("No such password!") def get_credential(self, service, username): """Gets the first username and password for a service. Returns a Credential instance The username can be omitted, but if there is one, it will use get_password and return a SimpleCredential containing the username and password Otherwise, it will return the first username and password combo that it finds. """ query = {"service": service} if username: query["username"] = username collection = self.get_preferred_collection() with closing(collection.connection): items = collection.search_items(query) for item in items: self.unlock(item) username = item.get_attributes().get("username") return SimpleCredential(username, item.get_secret().decode('utf-8')) backends/Windows.py 0000644 00000013275 00000000000 0010273 0 ustar 00 import logging from ..util import properties from ..backend import KeyringBackend from ..credentials import SimpleCredential from ..errors import PasswordDeleteError, ExceptionRaisedContext with ExceptionRaisedContext() as missing_deps: try: # prefer pywin32-ctypes from win32ctypes.pywin32 import pywintypes from win32ctypes.pywin32 import win32cred # force demand import to raise ImportError win32cred.__name__ except ImportError: # fallback to pywin32 import pywintypes import win32cred # force demand import to raise ImportError win32cred.__name__ log = logging.getLogger(__name__) class Persistence: def __get__(self, keyring, type=None): return getattr(keyring, '_persist', win32cred.CRED_PERSIST_ENTERPRISE) def __set__(self, keyring, value): """ Set the persistence value on the Keyring. Value may be one of the win32cred.CRED_PERSIST_* constants or a string representing one of those constants. For example, 'local machine' or 'session'. """ if isinstance(value, str): attr = 'CRED_PERSIST_' + value.replace(' ', '_').upper() value = getattr(win32cred, attr) setattr(keyring, '_persist', value) class DecodingCredential(dict): @property def value(self): """ Attempt to decode the credential blob as UTF-16 then UTF-8. """ cred = self['CredentialBlob'] try: return cred.decode('utf-16') except UnicodeDecodeError: decoded_cred_utf8 = cred.decode('utf-8') log.warning( "Retrieved an UTF-8 encoded credential. Please be aware that " "this library only writes credentials in UTF-16." ) return decoded_cred_utf8 class WinVaultKeyring(KeyringBackend): """ WinVaultKeyring stores encrypted passwords using the Windows Credential Manager. Requires pywin32 This backend does some gymnastics to simulate multi-user support, which WinVault doesn't support natively. See https://github.com/jaraco/keyring/issues/47#issuecomment-75763152 for details on the implementation, but here's the gist: Passwords are stored under the service name unless there is a collision (another password with the same service name but different user name), in which case the previous password is moved into a compound name: {username}@{service} """ persist = Persistence() @properties.ClassProperty @classmethod def priority(cls): """ If available, the preferred backend on Windows. """ if missing_deps: raise RuntimeError("Requires Windows and pywin32") return 5 @staticmethod def _compound_name(username, service): return f'{username}@{service}' def get_password(self, service, username): # first attempt to get the password under the service name res = self._get_password(service) if not res or res['UserName'] != username: # It wasn't found so attempt to get it with the compound name res = self._get_password(self._compound_name(username, service)) if not res: return None return res.value def _get_password(self, target): try: res = win32cred.CredRead( Type=win32cred.CRED_TYPE_GENERIC, TargetName=target ) except pywintypes.error as e: if e.winerror == 1168 and e.funcname == 'CredRead': # not found return None raise return DecodingCredential(res) def set_password(self, service, username, password): existing_pw = self._get_password(service) if existing_pw: # resave the existing password using a compound target existing_username = existing_pw['UserName'] target = self._compound_name(existing_username, service) self._set_password( target, existing_username, existing_pw.value, ) self._set_password(service, username, str(password)) def _set_password(self, target, username, password): credential = dict( Type=win32cred.CRED_TYPE_GENERIC, TargetName=target, UserName=username, CredentialBlob=password, Comment="Stored using python-keyring", Persist=self.persist, ) win32cred.CredWrite(credential, 0) def delete_password(self, service, username): compound = self._compound_name(username, service) deleted = False for target in service, compound: existing_pw = self._get_password(target) if existing_pw and existing_pw['UserName'] == username: deleted = True self._delete_password(target) if not deleted: raise PasswordDeleteError(service) def _delete_password(self, target): try: win32cred.CredDelete(Type=win32cred.CRED_TYPE_GENERIC, TargetName=target) except pywintypes.error as e: if e.winerror == 1168 and e.funcname == 'CredDelete': # not found return raise def get_credential(self, service, username): res = None # get the credentials associated with the provided username if username: res = self._get_password(self._compound_name(username, service)) # get any first password under the service name if not res: res = self._get_password(service) if not res: return None return SimpleCredential(res['UserName'], res.value) backends/chainer.py 0000644 00000004226 00000000000 0010246 0 ustar 00 """ Keyring Chainer - iterates over other viable backends to discover passwords in each. """ from .. import backend from ..util import properties from . import fail class ChainerBackend(backend.KeyringBackend): """ >>> ChainerBackend() <keyring.backends.chainer.ChainerBackend object at ...> """ # override viability as 'priority' cannot be determined # until other backends have been constructed viable = True @properties.ClassProperty @classmethod def priority(cls): """ If there are backends to chain, high priority Otherwise very low priority since our operation when empty is the same as null. """ return 10 if len(cls.backends) > 1 else (fail.Keyring.priority - 1) @properties.ClassProperty @classmethod def backends(cls): """ Discover all keyrings for chaining. """ def allow(keyring): limit = backend._limit or bool return ( not isinstance(keyring, ChainerBackend) and limit(keyring) and keyring.priority > 0 ) allowed = filter(allow, backend.get_all_keyring()) return sorted(allowed, key=backend.by_priority, reverse=True) def get_password(self, service, username): for keyring in self.backends: password = keyring.get_password(service, username) if password is not None: return password def set_password(self, service, username, password): for keyring in self.backends: try: return keyring.set_password(service, username, password) except NotImplementedError: pass def delete_password(self, service, username): for keyring in self.backends: try: return keyring.delete_password(service, username) except NotImplementedError: pass def get_credential(self, service, username): for keyring in self.backends: credential = keyring.get_credential(service, username) if credential is not None: return credential backends/libsecret.py 0000644 00000013457 00000000000 0010617 0 ustar 00 import logging from ..util import properties from ..backend import KeyringBackend from ..credentials import SimpleCredential from ..errors import ( PasswordDeleteError, PasswordSetError, ExceptionRaisedContext, KeyringLocked, ) available = False try: import gi from gi.repository import Gio from gi.repository import GLib gi.require_version('Secret', '1') from gi.repository import Secret available = True except (AttributeError, ImportError, ValueError): pass log = logging.getLogger(__name__) class Keyring(KeyringBackend): """libsecret Keyring""" appid = 'Python keyring library' if available: schema = Secret.Schema.new( "org.freedesktop.Secret.Generic", Secret.SchemaFlags.NONE, { "application": Secret.SchemaAttributeType.STRING, "service": Secret.SchemaAttributeType.STRING, "username": Secret.SchemaAttributeType.STRING, }, ) collection = Secret.COLLECTION_DEFAULT @properties.ClassProperty @classmethod def priority(cls): with ExceptionRaisedContext() as exc: Secret.__name__ if exc: raise RuntimeError("libsecret required") return 4.8 def get_password(self, service, username): """Get password of the username for the service""" attributes = { "application": self.appid, "service": service, "username": username, } try: items = Secret.password_search_sync( self.schema, attributes, Secret.SearchFlags.UNLOCK, None ) except GLib.Error as error: quark = GLib.quark_try_string('g-io-error-quark') if error.matches(quark, Gio.IOErrorEnum.FAILED): raise KeyringLocked('Failed to unlock the item!') from error raise for item in items: try: return item.retrieve_secret_sync().get_text() except GLib.Error as error: quark = GLib.quark_try_string('secret-error') if error.matches(quark, Secret.Error.IS_LOCKED): raise KeyringLocked('Failed to unlock the item!') from error raise def set_password(self, service, username, password): """Set password for the username of the service""" attributes = { "application": self.appid, "service": service, "username": username, } label = "Password for '{}' on '{}'".format(username, service) try: stored = Secret.password_store_sync( self.schema, attributes, self.collection, label, password, None ) except GLib.Error as error: quark = GLib.quark_try_string('secret-error') if error.matches(quark, Secret.Error.IS_LOCKED): raise KeyringLocked("Failed to unlock the collection!") from error quark = GLib.quark_try_string('g-io-error-quark') if error.matches(quark, Gio.IOErrorEnum.FAILED): raise KeyringLocked("Failed to unlock the collection!") from error raise if not stored: raise PasswordSetError("Failed to store password!") def delete_password(self, service, username): """Delete the stored password (only the first one)""" attributes = { "application": self.appid, "service": service, "username": username, } try: items = Secret.password_search_sync( self.schema, attributes, Secret.SearchFlags.UNLOCK, None ) except GLib.Error as error: quark = GLib.quark_try_string('g-io-error-quark') if error.matches(quark, Gio.IOErrorEnum.FAILED): raise KeyringLocked('Failed to unlock the item!') from error raise for item in items: try: removed = Secret.password_clear_sync( self.schema, item.get_attributes(), None ) except GLib.Error as error: quark = GLib.quark_try_string('secret-error') if error.matches(quark, Secret.Error.IS_LOCKED): raise KeyringLocked('Failed to unlock the item!') from error raise return removed raise PasswordDeleteError("No such password!") def get_credential(self, service, username): """Get the first username and password for a service. Return a Credential instance The username can be omitted, but if there is one, it will use get_password and return a SimpleCredential containing the username and password Otherwise, it will return the first username and password combo that it finds. """ query = {"service": service} if username: query["username"] = username try: items = Secret.password_search_sync( self.schema, query, Secret.SearchFlags.UNLOCK, None ) except GLib.Error as error: quark = GLib.quark_try_string('g-io-error-quark') if error.matches(quark, Gio.IOErrorEnum.FAILED): raise KeyringLocked('Failed to unlock the item!') from error raise for item in items: username = item.get_attributes().get("username") try: return SimpleCredential( username, item.retrieve_secret_sync().get_text() ) except GLib.Error as error: quark = GLib.quark_try_string('secret-error') if error.matches(quark, Secret.Error.IS_LOCKED): raise KeyringLocked('Failed to unlock the item!') from error raise backends/null.py 0000644 00000000550 00000000000 0007603 0 ustar 00 from ..backend import KeyringBackend class Keyring(KeyringBackend): """ Keyring that return None on every operation. >>> kr = Keyring() >>> kr.get_password('svc', 'user') """ priority = -1 def get_password(self, service, username, password=None): pass set_password = delete_password = get_password # type: ignore backends/__init__.py 0000644 00000000000 00000000000 0010356 0 ustar 00 backends/kwallet.py 0000644 00000013334 00000000000 0010300 0 ustar 00 import sys import os import contextlib from ..backend import KeyringBackend from ..credentials import SimpleCredential from ..errors import PasswordDeleteError from ..errors import PasswordSetError, InitError, KeyringLocked from ..util import properties try: import dbus from dbus.mainloop.glib import DBusGMainLoop except ImportError: pass except AttributeError: # See https://github.com/jaraco/keyring/issues/296 pass def _id_from_argv(): """ Safely infer an app id from sys.argv. """ allowed = AttributeError, IndexError, TypeError with contextlib.suppress(allowed): return sys.argv[0] class DBusKeyring(KeyringBackend): """ KDE KWallet 5 via D-Bus """ appid = _id_from_argv() or 'Python keyring library' wallet = None bus_name = 'org.kde.kwalletd5' object_path = '/modules/kwalletd5' @properties.ClassProperty @classmethod def priority(cls): if 'dbus' not in globals(): raise RuntimeError('python-dbus not installed') try: bus = dbus.SessionBus(mainloop=DBusGMainLoop()) except dbus.DBusException as exc: raise RuntimeError(exc.get_dbus_message()) if not ( bus.name_has_owner(cls.bus_name) or cls.bus_name in bus.list_activatable_names() ): raise RuntimeError( "The KWallet daemon is neither running nor activatable through D-Bus" ) if "KDE" in os.getenv("XDG_CURRENT_DESKTOP", "").split(":"): return 5.1 return 4.9 def __init__(self, *arg, **kw): super().__init__(*arg, **kw) self.handle = -1 def _migrate(self, service): old_folder = 'Python' entry_list = [] if self.iface.hasFolder(self.handle, old_folder, self.appid): entry_list = self.iface.readPasswordList( self.handle, old_folder, '*@*', self.appid ) for entry in entry_list.items(): key = entry[0] password = entry[1] username, service = key.rsplit('@', 1) ret = self.iface.writePassword( self.handle, service, username, password, self.appid ) if ret == 0: self.iface.removeEntry(self.handle, old_folder, key, self.appid) entry_list = self.iface.readPasswordList( self.handle, old_folder, '*', self.appid ) if not entry_list: self.iface.removeFolder(self.handle, old_folder, self.appid) def connected(self, service): if self.handle >= 0: if self.iface.isOpen(self.handle): return True bus = dbus.SessionBus(mainloop=DBusGMainLoop()) wId = 0 try: remote_obj = bus.get_object(self.bus_name, self.object_path) self.iface = dbus.Interface(remote_obj, 'org.kde.KWallet') self.handle = self.iface.open(self.iface.networkWallet(), wId, self.appid) except dbus.DBusException as e: raise InitError('Failed to open keyring: %s.' % e) if self.handle < 0: return False self._migrate(service) return True def get_password(self, service, username): """Get password of the username for the service""" if not self.connected(service): # the user pressed "cancel" when prompted to unlock their keyring. raise KeyringLocked("Failed to unlock the keyring!") if not self.iface.hasEntry(self.handle, service, username, self.appid): return None password = self.iface.readPassword(self.handle, service, username, self.appid) return str(password) def get_credential(self, service, username): """Gets the first username and password for a service. Returns a Credential instance The username can be omitted, but if there is one, it will forward to get_password. Otherwise, it will return the first username and password combo that it finds. """ if username is not None: return super().get_credential(service, username) if not self.connected(service): # the user pressed "cancel" when prompted to unlock their keyring. raise KeyringLocked("Failed to unlock the keyring!") for username in self.iface.entryList(self.handle, service, self.appid): password = self.iface.readPassword( self.handle, service, username, self.appid ) return SimpleCredential(str(username), str(password)) def set_password(self, service, username, password): """Set password for the username of the service""" if not self.connected(service): # the user pressed "cancel" when prompted to unlock their keyring. raise PasswordSetError("Cancelled by user") self.iface.writePassword(self.handle, service, username, password, self.appid) def delete_password(self, service, username): """Delete the password for the username of the service.""" if not self.connected(service): # the user pressed "cancel" when prompted to unlock their keyring. raise PasswordDeleteError("Cancelled by user") if not self.iface.hasEntry(self.handle, service, username, self.appid): raise PasswordDeleteError("Password not found") self.iface.removeEntry(self.handle, service, username, self.appid) class DBusKeyringKWallet4(DBusKeyring): """ KDE KWallet 4 via D-Bus """ bus_name = 'org.kde.kwalletd' object_path = '/modules/kwalletd' @properties.ClassProperty @classmethod def priority(cls): return super().priority - 1 backends/__pycache__/chainer.cpython-310.pyc 0000644 00000004617 00000000000 0014611 0 ustar 00 o ���a� � @ s> d Z ddlmZ ddlmZ ddlmZ G dd� dej�ZdS ) zV Keyring Chainer - iterates over other viable backends to discover passwords in each. � )�backend)� properties� )�failc @ sX e Zd ZdZdZejedd� ��Zejedd� ��Z dd� Z d d � Z d d � Z d d� Z dS )�ChainerBackendzZ >>> ChainerBackend() <keyring.backends.chainer.ChainerBackend object at ...> Tc C s t | j�dkr dS tjjd S )z� If there are backends to chain, high priority Otherwise very low priority since our operation when empty is the same as null. r � )�len�backendsr �Keyring�priority)�cls� r �:/usr/lib/python3/dist-packages/keyring/backends/chainer.pyr s zChainerBackend.priorityc C s& dd� }t |t�� �}t|tjdd�S )z5 Discover all keyrings for chaining. c S s( t jpt}t| t� o|| �o| jdkS )N� )r �_limit�bool� isinstancer r )�keyring�limitr r r �allow& s ��z&ChainerBackend.backends.<locals>.allowT)�key�reverse)�filterr �get_all_keyring�sorted� by_priority)r r �allowedr r r r s zChainerBackend.backendsc C �, | j D ]}|�||�}|d ur| S qd S �N)r � get_password)�self�service�usernamer �passwordr r r r 1 � ��zChainerBackend.get_passwordc C s6 | j D ]}z |�|||�W S ty Y qw d S r )r � set_password�NotImplementedError)r r! r" r# r r r r r% 7 s ��zChainerBackend.set_passwordc C s4 | j D ]}z |�||�W S ty Y qw d S r )r �delete_passwordr& )r r! r" r r r r r' > s ��z ChainerBackend.delete_passwordc C r r )r �get_credential)r r! r" r � credentialr r r r( E r$ z ChainerBackend.get_credentialN)�__name__� __module__� __qualname__�__doc__�viabler � ClassProperty� classmethodr r r r% r' r( r r r r r s r N)r- � r �utilr r �KeyringBackendr r r r r �<module> s backends/__pycache__/kwallet.cpython-310.pyc 0000644 00000012141 00000000000 0014632 0 ustar 00 o ���a� � @ s� d dl Z d dlZd dlZddlmZ ddlmZ ddlmZ ddlm Z m Z m Z ddl m Z z d dlZd dlmZ W n eyC Y n eyK Y nw d d � ZG d d � d e�ZG d d� de�ZdS )� N� )�KeyringBackend)�SimpleCredential)�PasswordDeleteError)�PasswordSetError� InitError� KeyringLocked)� properties)� DBusGMainLoopc C sB t ttf} t�| �� tjd W d � S 1 sw Y dS )z/ Safely infer an app id from sys.argv. r N)�AttributeError� IndexError� TypeError� contextlib�suppress�sys�argv)�allowed� r �:/usr/lib/python3/dist-packages/keyring/backends/kwallet.py� _id_from_argv s $�r c s| e Zd ZdZe� p dZdZdZdZe j e dd� ��Z � fdd �Z d d � Zd d � Zdd� Z� fdd�Zdd� Zdd� Z� ZS )� DBusKeyringz! KDE KWallet 5 via D-Bus zPython keyring libraryNzorg.kde.kwalletd5z/modules/kwalletd5c C s� dt � vr td��z tjt� d�}W n tjy% } zt|�� ��d }~ww |�| j�s7| j|� � v s7td��dt � dd�� d�v rDd S d S ) N�dbuszpython-dbus not installed��mainloopzCThe KWallet daemon is neither running nor activatable through D-Bus�KDE�XDG_CURRENT_DESKTOP� �:gffffff@g������@) �globals� RuntimeErrorr � SessionBusr � DBusException�get_dbus_message�name_has_owner�bus_name�list_activatable_names�os�getenv�split)�cls�bus�excr r r �priority( s" �� ��zDBusKeyring.priorityc s t � j|i |�� d| _d S )N���)�super�__init__�handle)�self�arg�kw�� __class__r r r/ < s zDBusKeyring.__init__c C s� d}g }| j �| j|| j�rd| j �| j|d| j�}|�� D ]-}|d }|d }|�dd�\}}| j �| j|||| j�}|dkrJ| j �| j||| j� q | j �| j|d| j�}|sf| j � | j|| j� d S d S d S )N�Pythonz*@*r � �@�*) �iface� hasFolderr0 �appid�readPasswordList�items�rsplit� writePassword� removeEntry� removeFolder) r1 �service� old_folder� entry_list�entry�key�password�username�retr r r �_migrate@ s. � �� ��zDBusKeyring._migratec C s� | j dkr| j�| j �rdS tjt� d�}d}z |�| j| j�}t� |d�| _| j� | j� � || j �| _ W n tj yH } ztd| ��d }~ww | j dk rPdS | �|� dS )Nr Tr zorg.kde.KWalletzFailed to open keyring: %s.F)r0 r: �isOpenr r r � get_objectr$ � object_path� Interface�open� networkWalletr< r! r rK )r1 rC r* �wId� remote_obj�er r r � connectedY s" �� zDBusKeyring.connectedc C sJ | � |�s td��| j�| j||| j�sdS | j�| j||| j�}t|�S )z,Get password of the username for the service� Failed to unlock the keyring!N)rU r r: �hasEntryr0 r< � readPassword�str�r1 rC rI rH r r r � get_passwordl s zDBusKeyring.get_passwordc sp |dur t � �||�S | �|�std��| j�| j|| j�D ]}| j�| j||| j�}t t |�t |�� S dS )a Gets the first username and password for a service. Returns a Credential instance The username can be omitted, but if there is one, it will forward to get_password. Otherwise, it will return the first username and password combo that it finds. NrV ) r. �get_credentialrU r r: � entryListr0 r< rX r rY rZ r4 r r r\ v s ��zDBusKeyring.get_credentialc C s. | � |�s td��| j�| j|||| j� dS )z,Set password for the username of the service�Cancelled by userN)rU r r: r@ r0 r< rZ r r r � set_password� s zDBusKeyring.set_passwordc C sJ | � |�s td��| j�| j||| j�std��| j�| j||| j� dS )z4Delete the password for the username of the service.r^ zPassword not foundN)rU r r: rW r0 r< rA )r1 rC rI r r r �delete_password� s zDBusKeyring.delete_password)�__name__� __module__� __qualname__�__doc__r r< �walletr$ rN r � ClassProperty� classmethodr, r/ rK rU r[ r\ r_ r` � __classcell__r r r4 r r s r c s2 e Zd ZdZdZdZeje� fdd���Z � Z S )�DBusKeyringKWallet4z! KDE KWallet 4 via D-Bus zorg.kde.kwalletdz/modules/kwalletdc s t � jd S )Nr7 )r. r, )r) r4 r r r, � s z DBusKeyringKWallet4.priority) ra rb rc rd r$ rN r rf rg r, rh r r r4 r ri � s ri )r r& r �backendr � credentialsr �errorsr r r r �utilr r �dbus.mainloop.glibr � ImportErrorr r r ri r r r r �<module> s& � ~ backends/__pycache__/libsecret.cpython-310.pyc 0000644 00000010450 00000000000 0015144 0 ustar 00 o ���a/ � @ s� d dl Z ddlmZ ddlmZ ddlmZ ddlmZm Z m Z m Z dZ z d dl Z d dlmZ d d lmZ e �d d � d d lmZ d Z W n eeefyP Y nw e �e�ZG dd� de�ZdS )� N� )� properties)�KeyringBackend)�SimpleCredential)�PasswordDeleteError�PasswordSetError�ExceptionRaisedContext� KeyringLockedF)�Gio)�GLib�Secret�1)r Tc @ sx e Zd ZdZdZer!ej�dej j ej j ej j ej j d��Z ejZejedd� ��Zdd� Zd d � Zd d � Zd d� ZdS )�Keyringzlibsecret KeyringzPython keyring libraryz org.freedesktop.Secret.Generic�� application�service�usernamec C s< t � � }tj W d � n1 sw Y |r td��dS )Nzlibsecret requiredg333333@)r r �__name__� RuntimeError)�cls�exc� r �</usr/lib/python3/dist-packages/keyring/backends/libsecret.py�priority- s �zKeyring.priorityc C s� | j ||d�}z t�| j|tjjd�}W n tjy4 } zt�d�}|� |t j j �r/t d�|�� d}~ww |D ]+}z |�� �� W S tjyb } zt�d�}|� |tjj�r]t d�|�� d}~ww dS )z,Get password of the username for the servicer N�g-io-error-quark�Failed to unlock the item!� secret-error)�appidr �password_search_sync�schema� SearchFlags�UNLOCKr �Error�quark_try_string�matchesr � IOErrorEnum�FAILEDr �retrieve_secret_sync�get_text� IS_LOCKED)�selfr r � attributes�items�error�quark�itemr r r � get_password6 s4 �� �� ���zKeyring.get_passwordc C s� | j ||d�}d�||�}zt�| j|| j||d�}W n2 tjyM } z%t�d�}|� |tjj �r6t d�|�t�d�}|� |t j j�rHt d�|�� d}~ww |sTtd��dS )z,Set password for the username of the servicer zPassword for '{}' on '{}'Nr z Failed to unlock the collection!r zFailed to store password!)r �formatr �password_store_syncr � collectionr r" r# r$ r) r r r% r& r ) r* r r �passwordr+ �label�storedr- r. r r r � set_passwordO s, � � ���zKeyring.set_passwordc C s� | j ||d�}z t�| j|tjjd�}W n tjy4 } zt�d�}|� |t j j �r/t d�|�� d}~ww |D ]1}zt�| j|�� d�}W | S tjyh } zt�d�}|� |tjj�rct d�|�� d}~ww td��)z/Delete the stored password (only the first one)r Nr r r zNo such password!)r r r r r r! r r" r# r$ r r% r& r �password_clear_sync�get_attributesr) r ) r* r r r+ r, r- r. r/ �removedr r r �delete_passwordf s: �� �� �� ��zKeyring.delete_passwordc C s� d|i}|r ||d< z t �| j|t jjd�}W n tjy7 } zt�d�}|�|t j j �r2t d�|�� d}~ww |D ]5}|� � �d�}z t||�� �� �W S tjyo } zt�d�}|�|t jj�rjt d�|�� d}~ww dS )aW Get the first username and password for a service. Return a Credential instance The username can be omitted, but if there is one, it will use get_password and return a SimpleCredential containing the username and password Otherwise, it will return the first username and password combo that it finds. r r Nr r r )r r r r r! r r" r# r$ r r% r& r r9 �getr r' r( r) )r* r r �queryr, r- r. r/ r r r �get_credential� s8 � �� � ���zKeyring.get_credentialN)r � __module__� __qualname__�__doc__r � availabler �Schema�new� SchemaFlags�NONE�SchemaAttributeType�STRINGr �COLLECTION_DEFAULTr3 r � ClassProperty� classmethodr r0 r7 r; r> r r r r r s( �� r )�logging�utilr �backendr � credentialsr �errorsr r r r rB �gi� gi.repositoryr r �require_versionr �AttributeError� ImportError� ValueError� getLoggerr �logr r r r r �<module> s$ � backends/__pycache__/__init__.cpython-310.pyc 0000644 00000000230 00000000000 0014722 0 ustar 00 o ���a � @ s d S )N� r r r �;/usr/lib/python3/dist-packages/keyring/backends/__init__.py�<module> s backends/__pycache__/Windows.cpython-310.pyc 0000644 00000012571 00000000000 0014630 0 ustar 00 o ���a� � @ s� d dl Z ddlmZ ddlmZ ddlmZ ddlmZm Z e � �.Z zd dl m Z d dl m Z e j W n eyG d dl Z d dl Z e j Y nw W d � n1 sRw Y e �e�ZG d d � d �ZG d d � d e�ZG d d� de�ZdS )� N� )� properties)�KeyringBackend)�SimpleCredential)�PasswordDeleteError�ExceptionRaisedContext)� pywintypes)� win32credc @ s e Zd Zddd�Zdd� ZdS )� PersistenceNc C s t |dtj�S )N�_persist)�getattrr �CRED_PERSIST_ENTERPRISE)�self�keyring�type� r �:/usr/lib/python3/dist-packages/keyring/backends/Windows.py�__get__ s zPersistence.__get__c C s8 t |t�rd|�dd��� }tt|�}t|d|� dS )z� Set the persistence value on the Keyring. Value may be one of the win32cred.CRED_PERSIST_* constants or a string representing one of those constants. For example, 'local machine' or 'session'. � CRED_PERSIST_� �_r N)� isinstance�str�replace�upperr r �setattr)r r �value�attrr r r �__set__ s zPersistence.__set__)N)�__name__� __module__� __qualname__r r r r r r r s r c @ s e Zd Zedd� �ZdS )�DecodingCredentialc C s@ | d }z|� d�W S ty |� d�}t�d� | Y S w )zM Attempt to decode the credential blob as UTF-16 then UTF-8. �CredentialBlobzutf-16zutf-8zkRetrieved an UTF-8 encoded credential. Please be aware that this library only writes credentials in UTF-16.)�decode�UnicodeDecodeError�log�warning)r �cred�decoded_cred_utf8r r r r . s ��zDecodingCredential.valueN)r r r! �propertyr r r r r r" - s r" c @ sl e Zd ZdZe� Zejedd� ��Z e dd� �Z dd� Z dd � Z d d � Zd d � Zdd� Zdd� Zdd� ZdS )�WinVaultKeyringaf WinVaultKeyring stores encrypted passwords using the Windows Credential Manager. Requires pywin32 This backend does some gymnastics to simulate multi-user support, which WinVault doesn't support natively. See https://github.com/jaraco/keyring/issues/47#issuecomment-75763152 for details on the implementation, but here's the gist: Passwords are stored under the service name unless there is a collision (another password with the same service name but different user name), in which case the previous password is moved into a compound name: {username}@{service} c C s t rtd��dS )zA If available, the preferred backend on Windows. z Requires Windows and pywin32� )� missing_deps� RuntimeError)�clsr r r �priorityS s zWinVaultKeyring.priorityc C s | � d|� �S )N�@r )�username�servicer r r �_compound_name] s z WinVaultKeyring._compound_namec C s: | � |�}|r |d |kr| � | �||��}|sd S |jS �N�UserName)� _get_passwordr4 r �r r3 r2 �resr r r � get_passworda s z WinVaultKeyring.get_passwordc C sZ z t jt j|d�}W t|�S tjy, } z|jdkr'|jdkr'W Y d }~d S � d }~ww )N��Type� TargetName� �CredRead)r r? �CRED_TYPE_GENERICr �error�winerror�funcnamer" )r �targetr9 �er r r r7 k s ����z WinVaultKeyring._get_passwordc C sH | � |�}|r|d }| �||�}| �|||j� | �||t|�� d S r5 )r7 r4 � _set_passwordr r )r r3 r2 �password� existing_pw�existing_usernamerD r r r � set_passwordv s �z WinVaultKeyring.set_passwordc C s( t tj|||d| jd�}t�|d� d S )NzStored using python-keyring)r< r= r6 r# �Comment�Persistr )�dictr r@ �persist� CredWrite)r rD r2 rG � credentialr r r rF � s �z WinVaultKeyring._set_passwordc C sV | � ||�}d}||fD ]}| �|�}|r"|d |kr"d}| �|� q |s)t|��d S )NFr6 T)r4 r7 �_delete_passwordr )r r3 r2 �compound�deletedrD rH r r r �delete_password� s ��z WinVaultKeyring.delete_passwordc C sV z t jt j|d� W d S tjy* } z|jdkr%|jdkr%W Y d }~d S � d }~ww )Nr; r> � CredDelete)r rU r@ r rA rB rC )r rD rE r r r rQ � s ��z WinVaultKeyring._delete_passwordc C s@ d }|r | � | �||��}|s| � |�}|sd S t|d |j�S r5 )r7 r4 r r r8 r r r �get_credential� s z WinVaultKeyring.get_credentialN)r r r! �__doc__r rN r � ClassProperty� classmethodr0 � staticmethodr4 r: r7 rJ rF rT rQ rV r r r r r+ ? s r+ )�logging�utilr �backendr � credentialsr �errorsr r r- �win32ctypes.pywin32r r r � ImportError� getLoggerr& r rM r" r+ r r r r �<module> s* �� � backends/__pycache__/null.cpython-310.pyc 0000644 00000001305 00000000000 0014141 0 ustar 00 o ���ah � @ s d dl mZ G dd� de�ZdS )� )�KeyringBackendc @ s& e Zd ZdZdZddd�Ze ZZdS )�Keyringzu Keyring that return None on every operation. >>> kr = Keyring() >>> kr.get_password('svc', 'user') ���Nc C s d S �N� )�self�service�username�passwordr r �7/usr/lib/python3/dist-packages/keyring/backends/null.py� get_password s zKeyring.get_passwordr )�__name__� __module__� __qualname__�__doc__�priorityr � set_password�delete_passwordr r r r r s r N)�backendr r r r r r �<module> s backends/__pycache__/SecretService.cpython-310.pyc 0000644 00000010606 00000000000 0015741 0 ustar 00 o ���a� � @ s� d dl mZ d dlZddlmZ ddlmZ ddlmZ ddl m Z m Z m Z m Z z d dlZd dlmZ W n ey= Y n eyE Y nw e�e�ZG dd � d e�ZdS ) � )�closingN� )� properties)�KeyringBackend)�SimpleCredential)� InitError�PasswordDeleteError�ExceptionRaisedContext� KeyringLockedc @ sV e Zd ZdZdZejedd� ��Zdd� Z dd� Z d d � Z d d � Z d d� Z dd� ZdS )�KeyringzSecret Service KeyringzPython keyring libraryc C s� t � � }tj W d � n1 sw Y |r td��tjdk r%td��z$tt�� ��}t�|�s6td��W d � W dS 1 sBw Y W dS tj y\ } ztd| ��d }~ww )NzSecretStorage required)� r z#SecretStorage 3.2 or newer requiredzJThe Secret Service daemon is neither running nor activatable through D-Busz&Unable to initialize SecretService: %s� ) r � secretstorage�__name__� RuntimeError�__version_tuple__r � dbus_init�check_service_availability� exceptions�SecretStorageException)�cls�exc� connection�e� r �@/usr/lib/python3/dist-packages/keyring/backends/SecretService.py�priority s, � �� ��� ��zKeyring.priorityc C s| t �� }zt| d�rt �|| j�}nt �|�}W n tjy+ } ztd| ��d}~ww |� � r<|� � |� � r<t d��|S )z�If self.preferred_collection contains a D-Bus path, the collection at that address is returned. Otherwise, the default collection is returned. �preferred_collectionz$Failed to create the collection: %s.Nz Failed to unlock the collection!) r r �hasattr� Collectionr �get_default_collectionr r r � is_locked�unlockr )�self�bus� collectionr r r r �get_preferred_collection3 s � ��z Keyring.get_preferred_collectionc C s& t |d�r |�� |�� rtd��d S )Nr" zFailed to unlock the item!)r r" r! r )r# �itemr r r r" F s �zKeyring.unlockc C sz | � � }t|j��* |�||d��}|D ]}| �|� |�� �d� W d � S W d � dS 1 s6w Y dS )z,Get password of the username for the service��username�service�utf-8N)r& r r � search_itemsr" � get_secret�decode�r# r* r) r% �itemsr' r r r � get_passwordL s �"�zKeyring.get_passwordc C sd | � � }| j||d�}d�||�}t|j�� |j|||dd� W d � dS 1 s+w Y dS )z,Set password for the username of the service)� applicationr* r) zPassword for '{}' on '{}'T)�replaceN)r& �appid�formatr r � create_item)r# r* r) �passwordr% � attributes�labelr r r � set_passwordU s � "�zKeyring.set_passwordc C sr | � � }t|j��$ |�||d��}|D ]}|�� W d � S W d � td��1 s0w Y td��)z/Delete the stored password (only the first one)r( NzNo such password!)r& r r r, �deleter r/ r r r �delete_passworda s � ��zKeyring.delete_passwordc C s� d|i}|r ||d< | � � }t|j��1 |�|�}|D ] }| �|� |�� �d�}t||�� � d�� W d � S W d � dS 1 sGw Y dS )aY Gets the first username and password for a service. Returns a Credential instance The username can be omitted, but if there is one, it will use get_password and return a SimpleCredential containing the username and password Otherwise, it will return the first username and password combo that it finds. r* r) r+ N) r& r r r, r" �get_attributes�getr r- r. )r# r* r) �queryr% r0 r' r r r �get_credentialj s �"�zKeyring.get_credentialN)r � __module__� __qualname__�__doc__r4 r � ClassProperty� classmethodr r& r" r1 r: r< r@ r r r r r s r )� contextlibr �logging�utilr �backendr � credentialsr �errorsr r r r r �secretstorage.exceptionsr � ImportError�AttributeError� getLoggerr �logr r r r r �<module> s � backends/__pycache__/fail.cpython-310.pyc 0000644 00000002121 00000000000 0014077 0 ustar 00 o ���aD � @ s, d dl mZ d dlmZ G dd� de�ZdS )� )�KeyringBackend��NoKeyringErrorc @ s& e Zd ZdZdZddd�Ze ZZdS )�Keyringz� Keyring that raises error on every operation. >>> kr = Keyring() >>> kr.get_password('svc', 'user') Traceback (most recent call last): ... keyring.errors.NoKeyringError: ...No recommended backend... � Nc C s d}t |��)Nz�No recommended backend was available. Install a recommended 3rd party backend package; or, install the keyrings.alt package if you want to use the non-recommended backends. See https://pypi.org/project/keyring for details.r )�self�service�username�password�msg� r �7/usr/lib/python3/dist-packages/keyring/backends/fail.py� get_password s �zKeyring.get_password)N)�__name__� __module__� __qualname__�__doc__�priorityr � set_password�delete_passwordr r r r r s r N)�backendr �errorsr r r r r r �<module> s backends/__pycache__/OS_X.cpython-310.pyc 0000644 00000000616 00000000000 0014003 0 ustar 00 o ���a� � @ s. d Z ddlZddlmZ dgZe�de� dS )zQ Backward-compatibility shim for users referencing the module by name. Ref #487. � N� )�Keyringr zOS_X module is deprecated.)�__doc__�warnings�macOSr �__all__�warn�DeprecationWarning� r r �7/usr/lib/python3/dist-packages/keyring/backends/OS_X.py�<module> s backends/macOS/api.py 0000644 00000010405 00000000000 0010404 0 ustar 00 import ctypes from ctypes import ( c_void_p, c_uint32, c_int32, byref, ) from ctypes.util import find_library OS_status = c_int32 class error: item_not_found = -25300 keychain_denied = -128 sec_auth_failed = -25293 plist_missing = -67030 sec_interaction_not_allowed = -25308 _sec = ctypes.CDLL(find_library('Security')) _core = ctypes.CDLL(find_library('CoreServices')) _found = ctypes.CDLL(find_library('Foundation')) CFDictionaryCreate = _found.CFDictionaryCreate CFDictionaryCreate.restype = c_void_p CFDictionaryCreate.argtypes = ( c_void_p, c_void_p, c_void_p, c_int32, c_void_p, c_void_p, ) CFStringCreateWithCString = _found.CFStringCreateWithCString CFStringCreateWithCString.restype = c_void_p CFStringCreateWithCString.argtypes = [c_void_p, c_void_p, c_uint32] CFNumberCreate = _found.CFNumberCreate CFNumberCreate.restype = c_void_p CFNumberCreate.argtypes = [c_void_p, c_uint32, ctypes.c_void_p] SecItemAdd = _sec.SecItemAdd SecItemAdd.restype = OS_status SecItemAdd.argtypes = (c_void_p, c_void_p) SecItemCopyMatching = _sec.SecItemCopyMatching SecItemCopyMatching.restype = OS_status SecItemCopyMatching.argtypes = (c_void_p, c_void_p) SecItemDelete = _sec.SecItemDelete SecItemDelete.restype = OS_status SecItemDelete.argtypes = (c_void_p,) CFDataGetBytePtr = _found.CFDataGetBytePtr CFDataGetBytePtr.restype = c_void_p CFDataGetBytePtr.argtypes = (c_void_p,) CFDataGetLength = _found.CFDataGetLength CFDataGetLength.restype = c_int32 CFDataGetLength.argtypes = (c_void_p,) def k_(s): return c_void_p.in_dll(_sec, s) def create_cfbool(b): return CFNumberCreate(None, 0x9, ctypes.byref(c_int32(1 if b else 0))) # int32 def create_cfstr(s): return CFStringCreateWithCString( None, s.encode('utf8'), 0x08000100 ) # kCFStringEncodingUTF8 def create_query(**kwargs): return CFDictionaryCreate( None, (c_void_p * len(kwargs))(*[k_(k) for k in kwargs.keys()]), (c_void_p * len(kwargs))( *[create_cfstr(v) if isinstance(v, str) else v for v in kwargs.values()] ), len(kwargs), _found.kCFTypeDictionaryKeyCallBacks, _found.kCFTypeDictionaryValueCallBacks, ) def cfstr_to_str(data): return ctypes.string_at(CFDataGetBytePtr(data), CFDataGetLength(data)).decode( 'utf-8' ) class Error(Exception): @classmethod def raise_for_status(cls, status): if status == 0: return if status == error.item_not_found: raise NotFound(status, "Item not found") if status == error.keychain_denied: raise KeychainDenied(status, "Keychain Access Denied") if status == error.sec_auth_failed or status == error.plist_missing: raise SecAuthFailure( status, "Security Auth Failure: make sure " "python is signed with codesign util", ) raise cls(status, "Unknown Error") class NotFound(Error): pass class KeychainDenied(Error): pass class SecAuthFailure(Error): pass def find_generic_password(kc_name, service, username, not_found_ok=False): q = create_query( kSecClass=k_('kSecClassGenericPassword'), kSecMatchLimit=k_('kSecMatchLimitOne'), kSecAttrService=service, kSecAttrAccount=username, kSecReturnData=create_cfbool(True), ) data = c_void_p() status = SecItemCopyMatching(q, byref(data)) if status == error.item_not_found and not_found_ok: return Error.raise_for_status(status) return cfstr_to_str(data) def set_generic_password(name, service, username, password): if find_generic_password(name, service, username, not_found_ok=True): delete_generic_password(name, service, username) q = create_query( kSecClass=k_('kSecClassGenericPassword'), kSecAttrService=service, kSecAttrAccount=username, kSecValueData=password, ) status = SecItemAdd(q, None) Error.raise_for_status(status) def delete_generic_password(name, service, username): q = create_query( kSecClass=k_('kSecClassGenericPassword'), kSecAttrService=service, kSecAttrAccount=username, ) status = SecItemDelete(q) Error.raise_for_status(status) backends/macOS/__init__.py 0000644 00000004050 00000000000 0011371 0 ustar 00 import platform import os from ...backend import KeyringBackend from ...errors import PasswordSetError from ...errors import PasswordDeleteError from ...errors import KeyringLocked from ...errors import KeyringError from ...util import properties try: from . import api except Exception: pass class Keyring(KeyringBackend): """macOS Keychain""" keychain = os.environ.get('KEYCHAIN_PATH') "Path to keychain file, overriding default" @properties.ClassProperty @classmethod def priority(cls): """ Preferred for all macOS environments. """ if platform.system() != 'Darwin': raise RuntimeError("macOS required") if 'api' not in globals(): raise RuntimeError("Security API unavailable") return 5 def set_password(self, service, username, password): if username is None: username = '' try: api.set_generic_password(self.keychain, service, username, password) except api.KeychainDenied as e: raise KeyringLocked("Can't store password on keychain: " "{}".format(e)) except api.Error as e: raise PasswordSetError("Can't store password on keychain: " "{}".format(e)) def get_password(self, service, username): if username is None: username = '' try: return api.find_generic_password(self.keychain, service, username) except api.NotFound: pass except api.KeychainDenied as e: raise KeyringLocked("Can't get password from keychain: " "{}".format(e)) except api.Error as e: raise KeyringError("Can't get password from keychain: " "{}".format(e)) def delete_password(self, service, username): if username is None: username = '' try: return api.delete_generic_password(self.keychain, service, username) except api.Error as e: raise PasswordDeleteError( "Can't delete password in keychain: " "{}".format(e) ) backends/macOS/__pycache__/__init__.cpython-310.pyc 0000644 00000004275 00000000000 0015741 0 ustar 00 o ���a( � @ s� d dl Z d dlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z zd d l m Z W n e y= Y nw G d d � d e�ZdS ) � N� )�KeyringBackend)�PasswordSetError)�PasswordDeleteError)� KeyringLocked)� KeyringError)� properties� )�apic @ sH e Zd ZdZej�d�Z ej e dd� ��Z dd� Z dd� Z d d � Zd S ) �KeyringzmacOS Keychain� KEYCHAIN_PATHc C s* t �� dkr td��dt� vrtd��dS )z7 Preferred for all macOS environments. �DarwinzmacOS requiredr zSecurity API unavailable� )�platform�system� RuntimeError�globals)�cls� r �A/usr/lib/python3/dist-packages/keyring/backends/macOS/__init__.py�priority s zKeyring.priorityc C st |d u rd}z t �| j|||� W d S t jy& } ztd�|���d }~w t jy9 } ztd�|���d }~ww )N� z$Can't store password on keychain: {})r �set_generic_password�keychain�KeychainDeniedr �format�Errorr )�self�service�username�password�er r r � set_password# s ���zKeyring.set_passwordc C s� |d u rd}z t �| j||�W S t jy Y d S t jy- } ztd�|���d }~w t jy@ } ztd�|���d }~ww )Nr z$Can't get password from keychain: {}) r �find_generic_passwordr �NotFoundr r r r r �r r r r! r r r � get_password. s ���zKeyring.get_passwordc C sH |d u rd}z t �| j||�W S t jy# } ztd�|���d }~ww )Nr z%Can't delete password in keychain: {})r �delete_generic_passwordr r r r r% r r r �delete_password; s ���zKeyring.delete_passwordN)�__name__� __module__� __qualname__�__doc__�os�environ�getr r � ClassProperty� classmethodr r" r& r( r r r r r s r )r r- �backendr �errorsr r r r �utilr r r � Exceptionr r r r r �<module> s � backends/macOS/__pycache__/api.cpython-310.pyc 0000644 00000010267 00000000000 0014751 0 ustar 00 o ���a � @ s� d dl Z d dl mZmZmZmZ d dlmZ eZG dd� d�Ze � ed��Z e � ed��Z e � ed��Z e j Z ee _eeeeeefe _e jZee_eeege_e jZee_eee jge_e jZee_eefe_e jZee_eefe_e jZee_efe_e jZee_efe_e jZee_efe_d d � Zd d � Zd d� Zdd� Zdd� ZG dd� de �Z G dd� de �Z G dd� de �Z G dd� de �Z d"d d �Z!d d � Z"d d!� Z#dS )#� N)�c_void_p�c_uint32�c_int32�byref)� find_libraryc @ s e Zd ZdZdZdZdZdZdS )�errori,���i����i3���i*���i$���N)�__name__� __module__� __qualname__�item_not_found�keychain_denied�sec_auth_failed� plist_missing�sec_interaction_not_allowed� r r �</usr/lib/python3/dist-packages/keyring/backends/macOS/api.pyr s r �Security� CoreServices� Foundationc C s t �t| �S )N)r �in_dll�_sec��sr r r �k_B s r c C s$ t d dt�t| r d���S d���S )N� � r )�CFNumberCreate�ctypesr r )�br r r � create_cfboolF s $r c C s t d | �d�d�S )N�utf8i )�CFStringCreateWithCString�encoder r r r � create_cfstrJ s �r# c K sN t d tt| � dd� | �� D �� tt| � dd� | �� D �� t| �tjtj�S )Nc S s g | ]}t |��qS r )r )�.0�kr r r � <listcomp>S s z create_query.<locals>.<listcomp>c S s" g | ] }t |t�r t|�n|�qS r )� isinstance�strr# )r$ �vr r r r& U s " )�CFDictionaryCreater �len�keys�values�_found� kCFTypeDictionaryKeyCallBacks� kCFTypeDictionaryValueCallBacks)�kwargsr r r � create_queryP s ��r2 c C s t �t| �t| ���d�S )Nzutf-8)r � string_at�CFDataGetBytePtr�CFDataGetLength�decode)�datar r r � cfstr_to_str] s �r8 c @ s e Zd Zedd� �ZdS )�Errorc C s\ |dkrd S |t jkrt|d��|t jkrt|d��|t jks$|t jkr)t|d��| |d��)Nr zItem not foundzKeychain Access DeniedzDSecurity Auth Failure: make sure python is signed with codesign utilz Unknown Error)r r �NotFoundr �KeychainDeniedr r �SecAuthFailure)�cls�statusr r r �raise_for_statusd s � zError.raise_for_statusN)r r r � classmethodr? r r r r r9 c s r9 c @ � e Zd ZdS )r: N�r r r r r r r r: u � r: c @ rA )r; NrB r r r r r; y rC r; c @ rA )r< NrB r r r r r< } rC r< Fc C sV t td�td�||td�d�}t� }t|t|��}|tjkr"|r"d S t� |� t |�S )N�kSecClassGenericPassword�kSecMatchLimitOneT)� kSecClass�kSecMatchLimit�kSecAttrService�kSecAttrAccount�kSecReturnData) r2 r r r �SecItemCopyMatchingr r r r9 r? r8 )�kc_name�service�username� not_found_ok�qr7 r> r r r �find_generic_password� s � rQ c C sH t | ||dd�rt| ||� ttd�|||d�}t|d �}t�|� d S )NT)rO rD )rF rH rI � kSecValueData)rQ �delete_generic_passwordr2 r � SecItemAddr9 r? )�namerM rN �passwordrP r> r r r �set_generic_password� s � rW c C s( t td�||d�}t|�}t�|� d S )NrD )rF rH rI )r2 r � SecItemDeleter9 r? )rU rM rN rP r> r r r rS � s �rS )F)$r r r r r � ctypes.utilr � OS_statusr �CDLLr �_corer. r* �restype�argtypesr! r rT rK rX r4 r5 r r r# r2 r8 � Exceptionr9 r: r; r< rQ rW rS r r r r �<module> sd � backends/OS_X.py 0000644 00000000336 00000000000 0007443 0 ustar 00 """ Backward-compatibility shim for users referencing the module by name. Ref #487. """ import warnings from .macOS import Keyring __all__ = ['Keyring'] warnings.warn("OS_X module is deprecated.", DeprecationWarning) cli.py 0000644 00000007524 00000000000 0005636 0 ustar 00 #!/usr/bin/env python """Simple command line interface to get/set password from a keyring""" import getpass import argparse import sys from . import core from . import backend from . import set_keyring, get_password, set_password, delete_password class CommandLineTool: def __init__(self): self.parser = argparse.ArgumentParser() self.parser.add_argument( "-p", "--keyring-path", dest="keyring_path", default=None, help="Path to the keyring backend", ) self.parser.add_argument( "-b", "--keyring-backend", dest="keyring_backend", default=None, help="Name of the keyring backend", ) self.parser.add_argument( "--list-backends", action="store_true", help="List keyring backends and exit", ) self.parser.add_argument( "--disable", action="store_true", help="Disable keyring and exit" ) self.parser.add_argument( 'operation', help="get|set|del", nargs="?", ) self.parser.add_argument( 'service', nargs="?", ) self.parser.add_argument( 'username', nargs="?", ) def run(self, argv): args = self.parser.parse_args(argv) vars(self).update(vars(args)) if args.list_backends: for k in backend.get_all_keyring(): print(k) return if args.disable: core.disable() return self._check_args() self._load_spec_backend() method = getattr(self, f'do_{self.operation}', self.invalid_op) return method() def _check_args(self): if self.operation: if self.service is None or self.username is None: self.parser.error(f"{self.operation} requires service and username") def do_get(self): password = get_password(self.service, self.username) if password is None: raise SystemExit(1) print(password) def do_set(self): password = self.input_password( f"Password for '{self.username}' in '{self.service}': " ) set_password(self.service, self.username, password) def do_del(self): delete_password(self.service, self.username) def invalid_op(self): self.parser.error("Specify operation 'get', 'del', or 'set'.") def _load_spec_backend(self): if self.keyring_backend is None: return try: if self.keyring_path: sys.path.insert(0, self.keyring_path) set_keyring(core.load_keyring(self.keyring_backend)) except (Exception,) as exc: # Tons of things can go wrong here: # ImportError when using "fjkljfljkl" # AttributeError when using "os.path.bar" # TypeError when using "__builtins__.str" # So, we play on the safe side, and catch everything. self.parser.error(f"Unable to load specified keyring: {exc}") def input_password(self, prompt): """Retrieve password from input.""" return self.pass_from_pipe() or getpass.getpass(prompt) @classmethod def pass_from_pipe(cls): """Return password from pipe if not on TTY, else False.""" is_pipe = not sys.stdin.isatty() return is_pipe and cls.strip_last_newline(sys.stdin.read()) @staticmethod def strip_last_newline(str): """Strip one last newline, if present.""" return str[: -str.endswith('\n')] def main(argv=None): """Main command line interface.""" if argv is None: argv = sys.argv[1:] cli = CommandLineTool() return cli.run(argv) if __name__ == '__main__': sys.exit(main()) credentials.py 0000644 00000003071 00000000000 0007355 0 ustar 00 import os import abc class Credential(metaclass=abc.ABCMeta): """Abstract class to manage credentials""" @abc.abstractproperty def username(self): return None @abc.abstractproperty def password(self): return None class SimpleCredential(Credential): """Simple credentials implementation""" def __init__(self, username, password): self._username = username self._password = password @property def username(self): return self._username @property def password(self): return self._password class EnvironCredential(Credential): """ Source credentials from environment variables. Actual sourcing is deferred until requested. Supports comparison by equality. >>> e1 = EnvironCredential('a', 'b') >>> e2 = EnvironCredential('a', 'b') >>> e3 = EnvironCredential('a', 'c') >>> e1 == e2 True >>> e2 == e3 False """ def __init__(self, user_env_var, pwd_env_var): self.user_env_var = user_env_var self.pwd_env_var = pwd_env_var def __eq__(self, other: object) -> bool: return vars(self) == vars(other) def _get_env(self, env_var): """Helper to read an environment variable""" value = os.environ.get(env_var) if not value: raise ValueError('Missing environment variable:%s' % env_var) return value @property def username(self): return self._get_env(self.user_env_var) @property def password(self): return self._get_env(self.pwd_env_var) errors.py 0000644 00000002626 00000000000 0006401 0 ustar 00 import sys class KeyringError(Exception): """Base class for exceptions in keyring""" class PasswordSetError(KeyringError): """Raised when the password can't be set.""" class PasswordDeleteError(KeyringError): """Raised when the password can't be deleted.""" class InitError(KeyringError): """Raised when the keyring could not be initialised""" class KeyringLocked(KeyringError): """Raised when the keyring failed unlocking""" class NoKeyringError(KeyringError, RuntimeError): """Raised when there is no keyring backend""" class ExceptionRaisedContext: """ An exception-trapping context that indicates whether an exception was raised. """ def __init__(self, ExpectedException=Exception): self.ExpectedException = ExpectedException self.exc_info = None def __enter__(self): self.exc_info = object.__new__(ExceptionInfo) return self.exc_info def __exit__(self, *exc_info): self.exc_info.__init__(*exc_info) return self.exc_info.type and issubclass( self.exc_info.type, self.ExpectedException ) class ExceptionInfo: def __init__(self, *info): if not info: info = sys.exc_info() self.type, self.value, _ = info def __bool__(self): """ Return True if an exception occurred """ return bool(self.type) __nonzero__ = __bool__ http.py 0000644 00000002317 00000000000 0006041 0 ustar 00 """ urllib2.HTTPPasswordMgr object using the keyring, for use with the urllib2.HTTPBasicAuthHandler. usage: import urllib2 handlers = [urllib2.HTTPBasicAuthHandler(PasswordMgr())] urllib2.install_opener(handlers) urllib2.urlopen(...) This will prompt for a password if one is required and isn't already in the keyring. Then, it adds it to the keyring for subsequent use. """ import getpass from . import get_password, delete_password, set_password class PasswordMgr: def get_username(self, realm, authuri): return getpass.getuser() def add_password(self, realm, authuri, password): user = self.get_username(realm, authuri) set_password(realm, user, password) def find_user_password(self, realm, authuri): user = self.get_username(realm, authuri) password = get_password(realm, user) if password is None: prompt = 'password for %(user)s@%(realm)s for ' '%(authuri)s: ' % vars() password = getpass.getpass(prompt) set_password(realm, user, password) return user, password def clear_password(self, realm, authuri): user = self.get_username(realm, authuri) delete_password(realm, user) __main__.py 0000644 00000000107 00000000000 0006575 0 ustar 00 if __name__ == '__main__': from keyring import cli cli.main() __init__.py 0000644 00000000417 00000000000 0006620 0 ustar 00 from .core import ( set_keyring, get_keyring, set_password, get_password, delete_password, get_credential, ) __all__ = ( 'set_keyring', 'get_keyring', 'set_password', 'get_password', 'delete_password', 'get_credential', ) testing/backend.py 0000644 00000013752 00000000000 0010133 0 ustar 00 # coding: utf-8 """ Common test functionality for backends. """ import os import string import pytest from .util import random_string from keyring import errors # unicode only characters # Sourced from The Quick Brown Fox... Pangrams # http://www.columbia.edu/~fdc/utf8/ UNICODE_CHARS = ( "זהכיףסתםלשמועאיךתנצחקרפדעץטובבגן" "ξεσκεπάζωτηνψυχοφθόραβδελυγμία" "Съешьжеещёэтихмягкихфранцузскихбулокдавыпейчаю" "Жълтатадюлябешещастливачепухъткойтоцъфназамръзнакатогьон" ) # ensure no-ascii chars slip by - watch your editor! assert min(ord(char) for char in UNICODE_CHARS) > 127 def is_ascii_printable(s): return all(32 <= ord(c) < 127 for c in s) class BackendBasicTests: """Test for the keyring's basic functions. password_set and password_get""" DIFFICULT_CHARS = string.whitespace + string.punctuation @pytest.fixture(autouse=True) def _init_properties(self, request): self.keyring = self.init_keyring() self.credentials_created = set() request.addfinalizer(self.cleanup) def cleanup(self): for item in self.credentials_created: self.keyring.delete_password(*item) def set_password(self, service, username, password): # set the password and save the result so the test runner can clean # up after if necessary. self.keyring.set_password(service, username, password) self.credentials_created.add((service, username)) def check_set_get(self, service, username, password): keyring = self.keyring # for the non-existent password assert keyring.get_password(service, username) is None # common usage self.set_password(service, username, password) assert keyring.get_password(service, username) == password # for the empty password self.set_password(service, username, "") assert keyring.get_password(service, username) == "" def test_password_set_get(self): password = random_string(20) username = random_string(20) service = random_string(20) self.check_set_get(service, username, password) def test_difficult_chars(self): password = random_string(20, self.DIFFICULT_CHARS) username = random_string(20, self.DIFFICULT_CHARS) service = random_string(20, self.DIFFICULT_CHARS) self.check_set_get(service, username, password) def test_delete_present(self): password = random_string(20, self.DIFFICULT_CHARS) username = random_string(20, self.DIFFICULT_CHARS) service = random_string(20, self.DIFFICULT_CHARS) self.keyring.set_password(service, username, password) self.keyring.delete_password(service, username) assert self.keyring.get_password(service, username) is None def test_delete_not_present(self): username = random_string(20, self.DIFFICULT_CHARS) service = random_string(20, self.DIFFICULT_CHARS) with pytest.raises(errors.PasswordDeleteError): self.keyring.delete_password(service, username) def test_delete_one_in_group(self): username1 = random_string(20, self.DIFFICULT_CHARS) username2 = random_string(20, self.DIFFICULT_CHARS) password = random_string(20, self.DIFFICULT_CHARS) service = random_string(20, self.DIFFICULT_CHARS) self.keyring.set_password(service, username1, password) self.set_password(service, username2, password) self.keyring.delete_password(service, username1) assert self.keyring.get_password(service, username2) == password def test_name_property(self): assert is_ascii_printable(self.keyring.name) def test_unicode_chars(self): password = random_string(20, UNICODE_CHARS) username = random_string(20, UNICODE_CHARS) service = random_string(20, UNICODE_CHARS) self.check_set_get(service, username, password) def test_unicode_and_ascii_chars(self): source = ( random_string(10, UNICODE_CHARS) + random_string(10) + random_string(10, self.DIFFICULT_CHARS) ) password = random_string(20, source) username = random_string(20, source) service = random_string(20, source) self.check_set_get(service, username, password) def test_different_user(self): """ Issue #47 reports that WinVault isn't storing passwords for multiple users. This test exercises that test for each of the backends. """ keyring = self.keyring self.set_password('service1', 'user1', 'password1') self.set_password('service1', 'user2', 'password2') assert keyring.get_password('service1', 'user1') == 'password1' assert keyring.get_password('service1', 'user2') == 'password2' self.set_password('service2', 'user3', 'password3') assert keyring.get_password('service1', 'user1') == 'password1' def test_credential(self): keyring = self.keyring cred = keyring.get_credential('service', None) assert cred is None self.set_password('service1', 'user1', 'password1') self.set_password('service1', 'user2', 'password2') cred = keyring.get_credential('service1', None) assert cred is None or (cred.username, cred.password) in ( ('user1', 'password1'), ('user2', 'password2'), ) cred = keyring.get_credential('service1', 'user2') assert cred is not None assert (cred.username, cred.password) in ( ('user1', 'password1'), ('user2', 'password2'), ) def test_set_properties(self, monkeypatch): env = dict(KEYRING_PROPERTY_FOO_BAR='fizz buzz', OTHER_SETTING='ignore me') monkeypatch.setattr(os, 'environ', env) self.keyring.set_properties_from_env() assert self.keyring.foo_bar == 'fizz buzz' testing/util.py 0000644 00000003576 00000000000 0007524 0 ustar 00 import contextlib import os import sys import random import string class ImportKiller: "Context manager to make an import of a given name or names fail." def __init__(self, *names): self.names = names def find_module(self, fullname, path=None): if fullname in self.names: return self def load_module(self, fullname): assert fullname in self.names raise ImportError(fullname) def __enter__(self): self.original = {} for name in self.names: self.original[name] = sys.modules.pop(name, None) sys.meta_path.insert(0, self) def __exit__(self, *args): sys.meta_path.remove(self) for key, value in self.original.items(): if value is not None: sys.modules[key] = value @contextlib.contextmanager def NoNoneDictMutator(destination, **changes): """Helper context manager to make and unmake changes to a dict. A None is not a valid value for the destination, and so means that the associated name should be removed.""" original = {} for key, value in changes.items(): original[key] = destination.get(key) if value is None: if key in destination: del destination[key] else: destination[key] = value yield for key, value in original.items(): if value is None: if key in destination: del destination[key] else: destination[key] = value def Environ(**changes): """A context manager to temporarily change the os.environ""" return NoNoneDictMutator(os.environ, **changes) ALPHABET = string.ascii_letters + string.digits def random_string(k, source=ALPHABET): """Generate a random string with length <i>k</i>""" result = '' for i in range(0, k): result += random.choice(source) return result testing/__init__.py 0000644 00000000000 00000000000 0010261 0 ustar 00 testing/__pycache__/backend.cpython-310.pyc 0000644 00000013240 00000000000 0014462 0 ustar 00 o ���a� � @ sl d Z ddlZddlZddlZddlmZ ddlmZ dZe dd� eD ��d ks)J �d d � Z G d d � d �Z dS )z) Common test functionality for backends. � N� )� random_string)�errorsuH זהכיףסתםלשמועאיךתנצחקרפדעץטובבגןξεσκεπάζωτηνψυχοφθόραβδελυγμίαСъешьжеещёэтихмягкихфранцузскихбулокдавыпейчаюЖълтатадюлябешещастливачепухъткойтоцъфназамръзнакатогьонc c s � | ]}t |�V qd S �N��ord)�.0�char� r �9/usr/lib/python3/dist-packages/keyring/testing/backend.py� <genexpr> s � r � c C s t dd� | D ��S )Nc s s, � | ]}d t |� kodk n V qdS )� r Nr )r �cr r r r s �* z%is_ascii_printable.<locals>.<genexpr>)�all)�sr r r �is_ascii_printable s r c @ s� e Zd ZdZejej Zej dd�dd� �Z dd� Z dd � Z d d � Z d d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�BackendBasicTestszETest for the keyring's basic functions. password_set and password_getT)�autousec C s" | � � | _t� | _|�| j� d S r )� init_keyring�keyring�set�credentials_created� addfinalizer�cleanup)�self�requestr r r �_init_properties& s z"BackendBasicTests._init_propertiesc C s | j D ]}| jj|� qd S r )r r �delete_password)r �itemr r r r , s �zBackendBasicTests.cleanupc C s$ | j �|||� | j�||f� d S r )r � set_passwordr �add)r �service�username�passwordr r r r 0 s z BackendBasicTests.set_passwordc C sb | j }|�||�d u s J �| �|||� |�||�|ks J �| �||d� |�||�dks/J �d S )N� )r � get_passwordr )r r" r# r$ r r r r � check_set_get6 s z BackendBasicTests.check_set_getc C s* t d�}t d�}t d�}| �|||� d S �N� )r r' �r r$ r# r" r r r �test_password_set_getD s z'BackendBasicTests.test_password_set_getc C s6 t d| j�}t d| j�}t d| j�}| �|||� d S r( )r �DIFFICULT_CHARSr' r* r r r �test_difficult_charsJ s z&BackendBasicTests.test_difficult_charsc C s\ t d| j�}t d| j�}t d| j�}| j�|||� | j�||� | j�||�d u s,J �d S r( �r r, r r r r& r* r r r �test_delete_presentP s z%BackendBasicTests.test_delete_presentc C sX t d| j�}t d| j�}t�tj�� | j�||� W d � d S 1 s%w Y d S r( )r r, �pytest�raisesr �PasswordDeleteErrorr r )r r# r" r r r �test_delete_not_presentX s "�z)BackendBasicTests.test_delete_not_presentc C sv t d| j�}t d| j�}t d| j�}t d| j�}| j�|||� | �|||� | j�||� | j�||�|ks9J �d S r( r. )r � username1� username2r$ r" r r r �test_delete_one_in_group^ s z*BackendBasicTests.test_delete_one_in_groupc C s t | jj�sJ �d S r )r r �name)r r r r �test_name_propertyh s z$BackendBasicTests.test_name_propertyc C s0 t dt�}t dt�}t dt�}| �|||� d S r( )r � UNICODE_CHARSr' r* r r r �test_unicode_charsk s z$BackendBasicTests.test_unicode_charsc C sN t dt�t d� t d| j� }t d|�}t d|�}t d|�}| �|||� d S )N� r) )r r9 r, r' )r �sourcer$ r# r" r r r � test_unicode_and_ascii_charsq s � �� z.BackendBasicTests.test_unicode_and_ascii_charsc C sp | j }| �ddd� | �ddd� |�dd�dksJ �|�dd�dks%J �| �ddd� |�dd�dks6J �d S ) z� Issue #47 reports that WinVault isn't storing passwords for multiple users. This test exercises that test for each of the backends. �service1�user1� password1�user2� password2�service2�user3� password3N)r r r& )r r r r r �test_different_user| s z%BackendBasicTests.test_different_userc C s� | j }|�dd �}|d u sJ �| �ddd� | �ddd� |�dd �}|d u s1|j|jfdv s1J �|�dd�}|d us=J �|j|jfdv sGJ �d S )Nr" r> r? r@ rA rB ))r? r@ )rA rB )r �get_credentialr r# r$ )r r �credr r r �test_credential� s z!BackendBasicTests.test_credentialc C s8 t ddd�}|�td|� | j�� | jjdksJ �d S )Nz fizz buzzz ignore me)�KEYRING_PROPERTY_FOO_BAR� OTHER_SETTING�environ)�dict�setattr�osr �set_properties_from_env�foo_bar)r � monkeypatch�envr r r �test_set_properties� s z%BackendBasicTests.test_set_propertiesN)�__name__� __module__� __qualname__�__doc__�string� whitespace� punctuationr, r0 �fixturer r r r' r+ r- r/ r3 r6 r8 r: r= rF rI rT r r r r r ! s& r ) rX rO rY r0 �utilr r r r9 �minr r r r r r �<module> s � testing/__pycache__/__init__.cpython-310.pyc 0000644 00000000227 00000000000 0014633 0 ustar 00 o ���a � @ s d S )N� r r r �:/usr/lib/python3/dist-packages/keyring/testing/__init__.py�<module> s testing/__pycache__/util.cpython-310.pyc 0000644 00000004570 00000000000 0014056 0 ustar 00 o ���a~ � @ sh d dl Z d dlZd dlZd dlZd dlZG dd� d�Ze jdd� �Zdd� Zej ej Z e fdd �Z dS ) � Nc @ s: e Zd ZdZdd� Zd dd�Zdd� Zd d � Zd d � ZdS )� ImportKillerz@Context manager to make an import of a given name or names fail.c G s || _ d S �N��names)�selfr � r �6/usr/lib/python3/dist-packages/keyring/testing/util.py�__init__ s zImportKiller.__init__Nc C s || j v r| S d S r r )r �fullname�pathr r r � find_module s �zImportKiller.find_modulec C s || j v sJ �t|��r )r � ImportError)r r r r r � load_module s zImportKiller.load_modulec C s8 i | _ | jD ] }tj�|d �| j |< qtj�d| � d S )Nr )�originalr �sys�modules�pop� meta_path�insert)r �namer r r � __enter__ s zImportKiller.__enter__c G s6 t j�| � | j�� D ] \}}|d ur|t j|< q d S r )r r �remover �itemsr )r �args�key�valuer r r �__exit__ s ��zImportKiller.__exit__r ) �__name__� __module__� __qualname__�__doc__r r r r r r r r r r s r c k s� � i }|� � D ]\}}| �|�||< |du r || v r | |= q|| |< qdV |� � D ]\}}|du r:|| v r9| |= q*|| |< q*dS )z�Helper context manager to make and unmake changes to a dict. A None is not a valid value for the destination, and so means that the associated name should be removed.N)r �get)� destination�changesr r r r r r �NoNoneDictMutator# s" �� � �r$ c K s t tjfi | ��S )z6A context manager to temporarily change the os.environ)r$ �os�environ)r# r r r �Environ: s r' c C s& d}t d| �D ] }|t�|�7 }q|S )z-Generate a random string with length <i>k</i>� r )�range�random�choice)�k�source�result�ir r r � random_stringB s r0 ) � contextlibr% r r* �stringr �contextmanagerr$ r' � ascii_letters�digits�ALPHABETr0 r r r r �<module> s __pycache__/credentials.cpython-310.pyc 0000644 00000005206 00000000000 0013716 0 ustar 00 o ���a9 � @ sH d dl Z d dlZG dd� dejd�ZG dd� de�ZG dd� de�ZdS ) � Nc @ s, e Zd ZdZejdd� �Zejdd� �ZdS )� Credentialz$Abstract class to manage credentialsc C � d S �N� ��selfr r �5/usr/lib/python3/dist-packages/keyring/credentials.py�username � zCredential.usernamec C r r r r r r r �password r zCredential.passwordN)�__name__� __module__� __qualname__�__doc__�abc�abstractpropertyr r r r r r r s r )� metaclassc @ s0 e Zd ZdZdd� Zedd� �Zedd� �ZdS ) �SimpleCredentialz!Simple credentials implementationc C � || _ || _d S r )� _username� _password)r r r r r r �__init__ � zSimpleCredential.__init__c C � | j S r )r r r r r r � zSimpleCredential.usernamec C r r )r r r r r r r zSimpleCredential.passwordN)r r r r r �propertyr r r r r r r s r c @ sJ e Zd ZdZdd� Zdedefdd�Zdd � Ze d d � �Z e d d � �Z dS )�EnvironCredentialaA Source credentials from environment variables. Actual sourcing is deferred until requested. Supports comparison by equality. >>> e1 = EnvironCredential('a', 'b') >>> e2 = EnvironCredential('a', 'b') >>> e3 = EnvironCredential('a', 'c') >>> e1 == e2 True >>> e2 == e3 False c C r r )� user_env_var� pwd_env_var)r r r r r r r 2 r zEnvironCredential.__init__�other�returnc C s t | �t |�kS r )�vars)r r r r r �__eq__6 s zEnvironCredential.__eq__c C s t j�|�}|std| ��|S )z&Helper to read an environment variablez Missing environment variable:%s)�os�environ�get� ValueError)r �env_var�valuer r r �_get_env9 s zEnvironCredential._get_envc C � | � | j�S r )r) r r r r r r @ � zEnvironCredential.usernamec C r* r )r) r r r r r r D r+ zEnvironCredential.passwordN) r r r r r �object�boolr" r) r r r r r r r r ! s r )r# r �ABCMetar r r r r r r �<module> s __pycache__/backend.cpython-310.pyc 0000644 00000016720 00000000000 0013013 0 ustar 00 o ���a� � @ s� d Z ddlZddlZddlZddlZddlmZ ddlZddl m Z m Z m Z ddl m Z e�e�Ze�d�ZdZG dd � d ej�ZG d d � d ed �ZG d d� d�ZG dd� de�Zdd� Ze jdd� �ZdS )z Keyring implementation support � N)�Optional� )� credentials�errors�util)� properties�priorityc s e Zd ZdZ� fdd�Z� ZS )�KeyringBackendMetazn A metaclass that's both an ABCMeta and a type that keeps a registry of all (non-abstract) types. c s@ t � �|||� t| d�st� | _| j}| js |�| � d S d S )N�_classes)�super�__init__�hasattr�setr �__abstractmethods__�add)�cls�name�bases�dict�classes�� __class__� �1/usr/lib/python3/dist-packages/keyring/backend.pyr s �zKeyringBackendMeta.__init__)�__name__� __module__� __qualname__�__doc__r � __classcell__r r r r r s r c @ s� e Zd ZdZdd� Zdd� Zejedd� ��Z edd � �Z ejed d � ��Z d d � Z e jdededee fdd��Ze jdedededdfdd��Zdededdfdd�Zdedee deej fdd�Zdd � ZdS ) �KeyringBackendz]The abstract base class of the keyring, every backend must implement this interface. c C s | � � d S �N)�set_properties_from_env)�selfr r r r , s zKeyringBackend.__init__c C � dS )a� Each backend class must supply a priority, a number (float or integer) indicating the priority of the backend relative to all other backends. The priority need not be static -- it may (and should) vary based attributes of the environment in which is runs (platform, available packages, etc.). A higher number indicates a higher priority. The priority should raise a RuntimeError with a message indicating the underlying cause if the backend is not suitable for the current environment. As a rule of thumb, a priority between zero but less than one is suitable, but a priority of one or greater is recommended. Nr �r r r r r 0 s zKeyringBackend.priorityc C s8 t �� � }| j W d � | S 1 sw Y | S r )r �ExceptionRaisedContextr )r �excr r r �viable@ s ��zKeyringBackend.viablec C s t t�d�| j�S )z6 Return all subclasses deemed viable. r' )�filter�operator� attrgetterr r$ r r r �get_viable_backendsG s z"KeyringBackend.get_viable_backendsc C s. | j �d�\}}}|�dd�}d�|| jg�S )zr The keyring name, suitable for display. The name is derived from module and class name. �.�_� )r � rpartition�replace�joinr )r �parent�sep�mod_namer r r r N s zKeyringBackend.namec C s t | �}d�|j|j|j�S )Nz{}.{} (priority: {:g}))�type�formatr r r )r" � keyring_classr r r �__str__Z s �zKeyringBackend.__str__�service�username�returnc C r# )z,Get password of the username for the serviceNr �r" r9 r: r r r � get_password` � zKeyringBackend.get_password�passwordNc C � t �d��)z�Set password for the username of the service. If the backend cannot store passwords, raise PasswordSetError. �reason)r �PasswordSetError�r" r9 r: r? r r r � set_passworde s zKeyringBackend.set_passwordc C r@ )z�Delete the password for the username of the service. If the backend cannot delete passwords, raise PasswordDeleteError. rA )r �PasswordDeleteErrorr< r r r �delete_passwordq s z KeyringBackend.delete_passwordc C s, |dur| � ||�}|durt�||�S dS )a Gets the username and password for the service. Returns a Credential instance. The *username* argument is optional and may be omitted by the caller or ignored by the backend. Callers must use the returned username. N)r= r �SimpleCredentialrC r r r �get_credential| s z KeyringBackend.get_credentialc C s< dd� }t dt|tj�� ��}|D ] \}}t| ||� qdS )z6For all KEYRING_PROPERTY_* env var, set that property.c S s( | \}}|� d�\}}}|o|�� |fS )N�KEYRING_PROPERTY_)� partition�lower)�item�key�value�prer3 r r r r �parse� s z5KeyringBackend.set_properties_from_env.<locals>.parseN)r( �map�os�environ�items�setattr)r" rP �propsr rN r r r r! � s �z&KeyringBackend.set_properties_from_env)r r r r r r r � ClassProperty� classmethodr' r+ r r8 �abc�abstractmethod�strr r= rD rF r � CredentialrH r! r r r r r ' s4 �� � r )� metaclassc @ s, e Zd ZdZejdd� �Zejdd� �ZdS )�Crypterz.Base class providing encryption and decryptionc C r# )zEncrypt the value.Nr �r" rN r r r �encrypt� r> zCrypter.encryptc C r# )zDecrypt the value.Nr r_ r r r �decrypt� r> zCrypter.decryptN)r r r r rY rZ r` ra r r r r r^ � s r^ c @ s e Zd ZdZdd� Zdd� ZdS )� NullCrypterzA crypter that does nothingc C � |S r r r_ r r r r` � � zNullCrypter.encryptc C rc r r r_ r r r ra � rd zNullCrypter.decryptN)r r r r r` ra r r r r rb � s rb c C sb t jdd�D ](} zt�d| j� | �� }t|�r|� W q ty. t�d| � d�� Y qw dS )a� Locate all setuptools entry points by the name 'keyring backends' and initialize them. Any third-party library may register an entry point by adding the following to their setup.cfg:: [options.entry_points] keyring.backends = plugin_name = mylib.mymodule:initialize_func `plugin_name` can be anything, and is only used to display the name of the plugin at initialization time. `initialize_func` is optional, but will be invoked if callable. zkeyring.backends)�groupz Loading %szError initializing plugin r, N) �metadata� entry_points�log�debugr �load�callable� Exception� exception)�ep� init_funcr r r � _load_plugins� s � ��rp c C s$ t � t�� } tj| td�}t|�S )zc Return a list of all implemented keyrings that can be constructed without parameters. )� exceptions)rp r r+ r �suppress_exceptions� TypeError�list)�viable_classes�ringsr r r �get_all_keyring� s rw ) r rR rY �loggingr) �typingr �importlib_metadatarf � r r r r � getLoggerr rh r* � by_priority�_limit�ABCMetar r r^ rb rp �oncerw r r r r �<module> s& u __pycache__/__main__.cpython-310.pyc 0000644 00000000346 00000000000 0013141 0 ustar 00 o ���aG � @ s$ e d krddlmZ e�� dS dS )�__main__� )�cliN)�__name__�keyringr �main� r r �2/usr/lib/python3/dist-packages/keyring/__main__.py�<module> s � __pycache__/errors.cpython-310.pyc 0000644 00000004764 00000000000 0012745 0 ustar 00 o ���a� � @ s� d dl Z G dd� de�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d d � d e�ZG d d � d ee�ZG dd� d�Z G dd� d�Z dS )� Nc @ � e Zd ZdZdS )� KeyringErrorz$Base class for exceptions in keyringN��__name__� __module__� __qualname__�__doc__� r r �0/usr/lib/python3/dist-packages/keyring/errors.pyr � r c @ r )�PasswordSetErrorz&Raised when the password can't be set.Nr r r r r r r r c @ r )�PasswordDeleteErrorz*Raised when the password can't be deleted.Nr r r r r r r r c @ r )� InitErrorz0Raised when the keyring could not be initialisedNr r r r r r r r c @ r )� KeyringLockedz(Raised when the keyring failed unlockingNr r r r r r r r c @ r )�NoKeyringErrorz'Raised when there is no keyring backendNr r r r r r r r c @ s, e Zd ZdZefdd�Zdd� Zdd� ZdS ) �ExceptionRaisedContextz[ An exception-trapping context that indicates whether an exception was raised. c C s || _ d | _d S �N)�ExpectedException�exc_info)�selfr r r r �__init__" s z ExceptionRaisedContext.__init__c C s t �t�| _| jS r )�object�__new__� ExceptionInfor �r r r r � __enter__& s z ExceptionRaisedContext.__enter__c G s$ | j j|� | j jot| j j| j�S r )r r �type� issubclassr )r r r r r �__exit__* s �z ExceptionRaisedContext.__exit__N)r r r r � Exceptionr r r r r r r r s r c @ s e Zd Zdd� Zdd� ZeZdS )r c G s |st �� }|\| _| _}d S r )�sysr r �value)r �info�_r r r r 2 s zExceptionInfo.__init__c C s t | j�S )z6 Return True if an exception occurred )�boolr r r r r �__bool__7 s zExceptionInfo.__bool__N)r r r r r% � __nonzero__r r r r r 1 s r ) r r r r r r r � RuntimeErrorr r r r r r r �<module> s __pycache__/devpi_client.cpython-310.pyc 0000644 00000000627 00000000000 0014070 0 ustar 00 o ���a� � @ s. d dl mZ d dlZed�Ze� dd� �ZdS )� )�HookimplMarkerN� devpiclientc C s t �| |�S )N)�keyring� get_password)�url�username� r �6/usr/lib/python3/dist-packages/keyring/devpi_client.py�devpiclient_get_password s r )�pluggyr r �hookimplr r r r r �<module> s __pycache__/__init__.cpython-310.pyc 0000644 00000000475 00000000000 0013163 0 ustar 00 o ���a � @ s( d dl mZmZmZmZmZmZ dZdS )� )� set_keyring� get_keyring� set_password� get_password�delete_password�get_credentialN)�corer r r r r r �__all__� r r �2/usr/lib/python3/dist-packages/keyring/__init__.py�<module> s __pycache__/http.cpython-310.pyc 0000644 00000003206 00000000000 0012376 0 ustar 00 o ���a� � @ s2 d Z ddlZddlmZmZmZ G dd� d�ZdS )a� urllib2.HTTPPasswordMgr object using the keyring, for use with the urllib2.HTTPBasicAuthHandler. usage: import urllib2 handlers = [urllib2.HTTPBasicAuthHandler(PasswordMgr())] urllib2.install_opener(handlers) urllib2.urlopen(...) This will prompt for a password if one is required and isn't already in the keyring. Then, it adds it to the keyring for subsequent use. � N� )� get_password�delete_password� set_passwordc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) � PasswordMgrc C s t �� S �N)�getpass�getuser)�self�realm�authuri� r �./usr/lib/python3/dist-packages/keyring/http.py� get_username s zPasswordMgr.get_usernamec C s | � ||�}t|||� d S r )r r )r r r �password�userr r r � add_password s zPasswordMgr.add_passwordc C sF | � ||�}t||�}|d u r dt� }t�|�}t|||� ||fS )Nz1password for %(user)s@%(realm)s for %(authuri)s: )r r �varsr r )r r r r r �promptr r r �find_user_password s z PasswordMgr.find_user_passwordc C s | � ||�}t||� d S r )r r )r r r r r r r �clear_password% s zPasswordMgr.clear_passwordN)�__name__� __module__� __qualname__r r r r r r r r r s r )�__doc__r � r r r r r r r r �<module> s __pycache__/cli.cpython-310.pyc 0000644 00000007764 00000000000 0012203 0 ustar 00 o ���aT � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlmZmZm Z m Z G dd� d�Z d d d �Z e d kr>e�e � � dS dS ) z@Simple command line interface to get/set password from a keyring� N� )�core)�backend)� set_keyring� get_password� set_password�delete_passwordc @ sl e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z e dd� �Z edd� �ZdS )�CommandLineToolc C s� t �� | _| jjdddd dd� | jjdddd d d� | jjd d d d � | jjdd dd � | jjdddd� | jjddd� | jjddd� d S )Nz-pz--keyring-path� keyring_pathzPath to the keyring backend)�dest�default�helpz-bz--keyring-backend�keyring_backendzName of the keyring backendz--list-backends� store_truez List keyring backends and exit)�actionr z --disablezDisable keyring and exit� operationz get|set|del�?)r �nargs�service)r �username)�argparse�ArgumentParser�parser� add_argument��self� r �-/usr/lib/python3/dist-packages/keyring/cli.py�__init__ sH ������ �zCommandLineTool.__init__c C s| | j �|�}t| ��t|�� |jr t�� D ]}t|� qd S |jr(t �� d S | � � | � � t | d| j � �| j�}|� S )N�do_)r � parse_args�vars�update� list_backendsr �get_all_keyring�print�disabler � _check_args�_load_spec_backend�getattrr � invalid_op)r �argv�args�k�methodr r r �run4 s zCommandLineTool.runc C s: | j r| jd u s | jd u r| j�| j � d�� d S d S d S )Nz requires service and username)r r r r �errorr r r r r' F s �zCommandLineTool._check_argsc C s* t | j| j�}|d u rtd��t|� d S )Nr )r r r � SystemExitr% �r �passwordr r r �do_getK s zCommandLineTool.do_getc C s0 | � d| j� d| j� d��}t| j| j|� d S )NzPassword for 'z' in 'z': )�input_passwordr r r r2 r r r �do_setQ s �zCommandLineTool.do_setc C s t | j| j� d S �N)r r r r r r r �do_delW s zCommandLineTool.do_delc C s | j �d� d S )Nz)Specify operation 'get', 'del', or 'set'.)r r0 r r r r r* Z s zCommandLineTool.invalid_opc C sv | j d u rd S z| jrtj�d| j� tt�| j �� W d S tfy: } z| j � d|� �� W Y d }~d S d }~ww )Nr z"Unable to load specified keyring: ) r r �sys�path�insertr r � load_keyring� Exceptionr r0 )r �excr r r r( ] s ��z"CommandLineTool._load_spec_backendc C s | � � pt�|�S )z Retrieve password from input.)�pass_from_pipe�getpass)r �promptr r r r5 m s z CommandLineTool.input_passwordc C s t j�� }|o| �t j�� �S )z4Return password from pipe if not on TTY, else False.)r9 �stdin�isatty�strip_last_newline�read)�cls�is_piper r r r? q s z CommandLineTool.pass_from_pipec C s | d| � d� � S )z#Strip one last newline, if present.N� )�endswith)�strr r r rD w s z"CommandLineTool.strip_last_newlineN)�__name__� __module__� __qualname__r r/ r' r4 r6 r8 r* r( r5 � classmethodr? � staticmethodrD r r r r r s & r c C s& | du r t jdd� } t� }|�| �S )z Main command line interface.Nr )r9 r+ r r/ )r+ �clir r r �main} s rQ �__main__r7 )�__doc__r@ r r9 � r r r r r r r rQ rK �exitr r r r �<module> s p � __pycache__/core.cpython-310.pyc 0000644 00000012334 00000000000 0012351 0 ustar 00 o ���a_ � @ s: d Z ddlZddlZddlZddlZddlZddlmZmZ ddl m Z ddl m Z e�e�Zdadd� Zd ejfd d �Zd d � Zdeded eje fdd�Zdededed dfdd�Zdeded dfdd�Zdedeje d ejej fdd�Z dd� Z d)dd �Z d)d d �Z d d � Z d!d"� Z!d#d$� Z"d%d&� Z#d'd(� Z$dS )*z1 Core API functions and initialization routines. � N� )�backend� credentials)� platform_)�failc C s t | tj�s td��| adS )z Set current keyring backend.z1The keyring must be an instance of KeyringBackendN)� isinstancer �KeyringBackend� TypeError�_keyring_backend)�keyring� r �./usr/lib/python3/dist-packages/keyring/core.py� set_keyring s r �returnc C s t du rt� t�tjt �S )z Get current keyring backend.N)r � init_backend�typing�castr r r r r r � get_keyring s r c C s� t �� } zt�| � W n ty Y nw tj�| d�}tj�|�r+d|� �}t|��t |d��}|� d� W d � dS 1 sAw Y dS )z4 Configure the null keyring as the default. � keyringrc.cfgzRefusing to overwrite �wz7[backend] default-keyring=keyring.backends.null.KeyringN) �platform� config_root�os�makedirs�OSError�path�join�exists� RuntimeError�open�write)�root�filename�msg�filer r r �disable$ s � "�r% � service_name�usernamec C � t � �| |�S )z(Get password from the specified service.)r � get_password�r& r' r r r r) 5 s r) �passwordc C s t � �| ||� dS )z3Set password for the user in the specified service.N)r � set_password)r& r' r+ r r r r, : s r, c C s t � �| |� dS )z:Delete the password for the user in the specified service.N)r �delete_passwordr* r r r r- ? s r- c C r( )z+Get a Credential for the specified service.)r �get_credentialr* r r r r. D s r. c C s | j dkS )Nr )�priority)r r r r � recommendedK s r0 c C s t t| �� dS )z" Load a detected backend. N)r �_detect_backend��limitr r r r O s r c C s0 | t _t� pt� ptt| t �� �t�� t j d�S )z� 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. )�default�key) r �_limit�load_env� load_config�max�filter�get_all_keyringr �Keyring� by_priorityr2 r r r r1 V s � ��r1 c C s, | � d�\}}}t|� tj| }t||�S )a� 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)) [...] �.)� rpartition� __import__�sys�modules�getattr)� keyring_name� module_name�sep� class_name�moduler r r �_load_keyring_classl s rI c C s t | �}|j |� S )z� Load the specified keyring by name (a fully-qualified name to the keyring, such as 'keyring.backends.file.PlaintextKeyring') )rI r/ )rD �class_r r r � load_keyring� s rK c C s& zt tjd �W S ty Y dS w )z6Load a keyring configured in the environment variable.�PYTHON_KEYRING_BACKENDN)rK r �environ�KeyErrorr r r r r7 � s �r7 c C s� d} t j�t�� | �}t j�|�sdS t�� }|�|� t |� z|� d�r/|� dd�� � }nt� dd��W t|�S tj tfyT t�d�}|�dd| � Y dS w )z8Load a keyring using the config file in the config root.r Nr zdefault-keyringr z/Keyring config file contains incorrect values. zConfig file: %s)r r r r r r � configparser�RawConfigParser�read�_load_keyring_path� has_section�get�strip� NoOptionError� ImportError�logging� getLogger�warningrK )r" � keyring_cfg�configrD �loggerr r r r8 � s, � � ���r8 c C sB z| � dd��� }tj�d|� W dS tjtjfy Y dS w )z)load the keyring-path option (if present)r z keyring-pathr N)rT rU rA r �insertrO rV �NoSectionError)r\ r r r r rR � s �rR )N)%�__doc__rO r rA rX r � r r �utilr r �backendsr rY �__name__�logr r r r r% �str�Optionalr) r, r- � Credentialr. r0 r r1 rI rK r7 r8 rR r r r r �<module> s@ �� � core.py 0000644 00000012137 00000000000 0006013 0 ustar 00 """ Core API functions and initialization routines. """ import configparser import os import sys import logging import typing from . import backend, credentials from .util import platform_ as platform from .backends import fail log = logging.getLogger(__name__) _keyring_backend = None def set_keyring(keyring): """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(): """ Configure the null keyring as the default. """ 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') 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): return backend.priority >= 1 def init_backend(limit=None): """ Load a detected backend. """ set_keyring(_detect_backend(limit)) def _detect_backend(limit=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()), default=fail.Keyring(), key=backend.by_priority, ) ) def _load_keyring_class(keyring_name): """ 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): """ 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 return class_() def load_env(): """Load a keyring configured in the environment variable.""" try: return load_keyring(os.environ['PYTHON_KEYRING_BACKEND']) except KeyError: pass def load_config(): """Load a keyring using the config file in the config root.""" filename = 'keyringrc.cfg' keyring_cfg = os.path.join(platform.config_root(), filename) if not os.path.exists(keyring_cfg): return config = configparser.RawConfigParser() config.read(keyring_cfg) _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" + "Config file: %s" % keyring_cfg ) return return load_keyring(keyring_name) def _load_keyring_path(config): "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 util/properties.py 0000644 00000002455 00000000000 0010236 0 ustar 00 from collections import abc class ClassProperty(property): """ An implementation of a property callable on a class. Used to decorate a classmethod but to then treat it like a property. Example: >>> class MyClass: ... @ClassProperty ... @classmethod ... def skillz(cls): ... return cls.__name__.startswith('My') >>> MyClass.skillz True >>> class YourClass(MyClass): pass >>> YourClass.skillz False """ def __get__(self, cls, owner): return self.fget.__get__(None, owner)() # borrowed from jaraco.util.dictlib class NonDataProperty: """Much like the property builtin, but only implements __get__, making it a non-data property, and can be subsequently reset. See http://users.rcn.com/python/download/Descriptor.htm for more information. >>> class X: ... @NonDataProperty ... def foo(self): ... return 3 >>> x = X() >>> x.foo 3 >>> x.foo = 4 >>> x.foo 4 """ def __init__(self, fget): assert fget is not None, "fget cannot be none" assert isinstance(fget, abc.Callable), "fget must be callable" self.fget = fget def __get__(self, obj, objtype=None): if obj is None: return self return self.fget(obj) util/__init__.py 0000644 00000001544 00000000000 0007577 0 ustar 00 import functools def once(func): """ Decorate func so it's only ever called the first time. This decorator can ensure that an expensive or non-idempotent function will not be expensive on subsequent calls and is idempotent. >>> func = once(lambda a: a+3) >>> func(3) 6 >>> func(9) 6 >>> func('12') 6 """ def wrapper(*args, **kwargs): if not hasattr(func, 'always_returns'): func.always_returns = func(*args, **kwargs) return func.always_returns return functools.wraps(func)(wrapper) def suppress_exceptions(callables, exceptions=Exception): """ yield the results of calling each element of callables, suppressing any indicated exceptions. """ for callable in callables: try: yield callable() except exceptions: pass util/__pycache__/__init__.cpython-310.pyc 0000644 00000002144 00000000000 0014133 0 ustar 00 o ���ad � @ s d dl Z dd� Zefdd�ZdS )� Nc s � fdd�}t �� �|�S )a6 Decorate func so it's only ever called the first time. This decorator can ensure that an expensive or non-idempotent function will not be expensive on subsequent calls and is idempotent. >>> func = once(lambda a: a+3) >>> func(3) 6 >>> func(9) 6 >>> func('12') 6 c s t � d�s � | i |��� _� jS )N�always_returns)�hasattrr )�args�kwargs��func� �7/usr/lib/python3/dist-packages/keyring/util/__init__.py�wrapper s zonce.<locals>.wrapper)� functools�wraps)r r r r r �once s r c c s. � | D ]}z|� V W q |y Y qw dS )zk yield the results of calling each element of callables, suppressing any indicated exceptions. Nr )� callables� exceptions�callabler r r �suppress_exceptions s � ��r )r r � Exceptionr r r r r �<module> s util/__pycache__/properties.cpython-310.pyc 0000644 00000003556 00000000000 0014600 0 ustar 00 o ���a- � @ s. d dl mZ G dd� de�ZG dd� d�ZdS )� )�abcc @ s e Zd ZdZdd� ZdS )� ClassPropertya� An implementation of a property callable on a class. Used to decorate a classmethod but to then treat it like a property. Example: >>> class MyClass: ... @ClassProperty ... @classmethod ... def skillz(cls): ... return cls.__name__.startswith('My') >>> MyClass.skillz True >>> class YourClass(MyClass): pass >>> YourClass.skillz False c C s | j �d |�� S �N)�fget�__get__)�self�cls�owner� r �9/usr/lib/python3/dist-packages/keyring/util/properties.pyr s zClassProperty.__get__N)�__name__� __module__� __qualname__�__doc__r r r r r r s r c @ s" e Zd ZdZdd� Zddd�ZdS )�NonDataPropertya Much like the property builtin, but only implements __get__, making it a non-data property, and can be subsequently reset. See http://users.rcn.com/python/download/Descriptor.htm for more information. >>> class X: ... @NonDataProperty ... def foo(self): ... return 3 >>> x = X() >>> x.foo 3 >>> x.foo = 4 >>> x.foo 4 c C s. |d usJ d��t |tj�sJ d��|| _d S )Nzfget cannot be nonezfget must be callable)� isinstancer �Callabler )r r r r r �__init__1 s zNonDataProperty.__init__Nc C s |d u r| S | � |�S r )r )r �obj�objtyper r r r 6 s zNonDataProperty.__get__r )r r r r r r r r r r r s r N)� collectionsr �propertyr r r r r r �<module> s util/__pycache__/platform_.cpython-310.pyc 0000644 00000004713 00000000000 0014363 0 ustar 00 o ���a� � @ s| d dl Z d dlZd dlZdd� Zdd� Zdd� Zdd � ZeZd d � Zd d � Z e � � de� � e�Z e � � de� � e �ZdS )� Nc C s t j�t jd d�S )N� USERPROFILEzLocal Settings)�os�path�join�environ� r r �8/usr/lib/python3/dist-packages/keyring/util/platform_.py�_settings_root_XP s r c C s t j�dt j�dd��S )N� LOCALAPPDATA� ProgramData�.)r r �getr r r r �_settings_root_Vista s r c C s2 t �� \} }}}| dkrt� nt� }tj�|d�S )N�XPzPython Keyring)�platform� win32_verr r r r r )�release�version�csd�ptype�rootr r r �_data_root_Windows s r c C s. t j�� d } tj�dd�p| }tj�|d�S )zW Use freedesktop.org Base Dir Specification to determine storage location. z .local/share� XDG_DATA_HOMEN�python_keyring)�pathlib�Path�homer r r r r )�fallbackr r r r �_data_root_Linux s r c C sh dd� t � d< tj�t� d�} tj�t� d�}tj�|�r0tj�| �s2d|� d| � d�}t|��dS dS ) a Prior versions of keyring would search for the config in XDG_DATA_HOME, but should probably have been searching for config in XDG_CONFIG_HOME. If the config exists in the former but not in the latter, raise a RuntimeError to force the change. c S s d S )Nr r r r r �<lambda>* s z(_check_old_config_root.<locals>.<lambda>�_check_old_config_rootz keyringrc.cfgz/Keyring config exists only in the old location z and should be moved to z& to work with this version of keyring.N)�globalsr r r �_config_root_Linuxr �isfile� RuntimeError)�config_file_new�config_file_old�msgr r r r ! s ����r c C s8 t � tj�� d } d}tj�|d�p| }tj�|d�S )zV Use freedesktop.org Base Dir Specification to determine config location. z.config�XDG_CONFIG_HOMENr ) r r r r r r r r r )r �keyr r r r r" 6 s r" � _data_root_� _config_root)r r r r r r r �_config_root_Windowsr r" r! r �system� data_root� config_rootr r r r �<module> s util/platform_.py 0000644 00000004246 00000000000 0010025 0 ustar 00 import os import platform import pathlib def _settings_root_XP(): return os.path.join(os.environ['USERPROFILE'], 'Local Settings') def _settings_root_Vista(): return os.environ.get('LOCALAPPDATA', os.environ.get('ProgramData', '.')) def _data_root_Windows(): release, version, csd, ptype = platform.win32_ver() root = _settings_root_XP() if release == 'XP' else _settings_root_Vista() return os.path.join(root, 'Python Keyring') def _data_root_Linux(): """ Use freedesktop.org Base Dir Specification to determine storage location. """ fallback = pathlib.Path.home() / '.local/share' root = os.environ.get('XDG_DATA_HOME', None) or fallback return os.path.join(root, 'python_keyring') _config_root_Windows = _data_root_Windows def _check_old_config_root(): """ Prior versions of keyring would search for the config in XDG_DATA_HOME, but should probably have been searching for config in XDG_CONFIG_HOME. If the config exists in the former but not in the latter, raise a RuntimeError to force the change. """ # disable the check - once is enough and avoids infinite loop globals()['_check_old_config_root'] = lambda: None config_file_new = os.path.join(_config_root_Linux(), 'keyringrc.cfg') config_file_old = os.path.join(_data_root_Linux(), 'keyringrc.cfg') if os.path.isfile(config_file_old) and not os.path.isfile(config_file_new): msg = ( "Keyring config exists only in the old location " f"{config_file_old} and should be moved to {config_file_new} " "to work with this version of keyring." ) raise RuntimeError(msg) def _config_root_Linux(): """ Use freedesktop.org Base Dir Specification to determine config location. """ _check_old_config_root() fallback = pathlib.Path.home() / '.config' key = 'XDG_CONFIG_HOME' root = os.environ.get(key, None) or fallback return os.path.join(root, 'python_keyring') # by default, use Unix convention data_root = globals().get('_data_root_' + platform.system(), _data_root_Linux) config_root = globals().get('_config_root' + platform.system(), _config_root_Linux)
| ver. 1.4 |
Github
|
.
| PHP 8.3.30 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings