def add_dummy_key_to_cryptfilekeyring(crypt_file_keyring: CryptFileKeyring): """ Add a fake key to the CryptFileKeyring """ crypt_file_keyring.keyring_key = "your keyring password" user: str = get_private_key_user(default_keychain_user(), 0) crypt_file_keyring.set_password(default_keychain_service(), user, "abc123")
def set_password(service, key, cryptfile_pw=None): kr = CryptFileKeyring() if cryptfile_pw is None: config = read_config() cryptfile_pw = config["cryptfile"]["password"] kr.keyring_key = base64_decode(cryptfile_pw) kr.set_password(service, key, getpass.getpass("Secret: "))
def get_password(system, username, lib='keyrings.cryptfile', env='KEYRING_CRYPTFILE_PASSWORD', ask=True): """ Restores a password. By default, uses :epkg:`keyring`. :param system: system :param username: username :param lib: which lib to use to store the password :param env: see below :param ask: ask for password if missing :return: password If `lib == 'keyrings.cryptfile'`, the function used the environment variable *env*, if present, no password is asked. """ if lib == 'keyring': from keyring import get_password as lib_get_password pwd = lib_get_password(system, username) if pwd in (None, '', b''): raise RuntimeError( # pragma: no cover "Unable to restore a password with keyring for '{}', '{}'.".format( system, username)) return pwd if lib == 'keyrings.cryptfile': from keyrings.cryptfile.cryptfile import CryptFileKeyring # pylint: disable=E0401 kr = CryptFileKeyring() kr.keyring_key = getenv("KEYRING_CRYPTFILE_PASSWORD") if kr.keyring_key is None and ask: kr.keyring_key = getpass() return kr.get_password(system, username) raise RuntimeError( "Unknown library '{}'.".format(lib))
def _configure_legacy_backend(self) -> CryptFileKeyring: # If keyring.yaml isn't found or is empty, check if we're using CryptFileKeyring filekeyring = self.keyring if type(self.keyring) == FileKeyring else None if filekeyring and not filekeyring.has_content(): old_keyring = CryptFileKeyring() if Path(old_keyring.file_path).is_file(): # After migrating content from legacy_keyring, we'll prompt to clear those keys old_keyring.keyring_key = "your keyring password" # type: ignore return old_keyring return None
def __init__(self): self.settings_obj = {} self.descriptions = { 'default':'Determines whether the passwords are set to default', 'use_stored_credentials':'If value is "email" or "minerva", then use stored credentials regularly. Default: "false"' } self.defaults_obj = { 'default':'true', 'use_stored_credentials':'false' } self.kr = CryptFileKeyring()
def getKr(self): if os.name != 'nt': #logging.getLogger().exception("getlogger "+self.configfile) config = configparser.ConfigParser() config.read(self.configfile) sd = config.get("other", "startdate") pc = config.get("other", "postcode") kr = CryptFileKeyring() kr.keyring_key = pc + platform.node() + os.name + sd + "!djl!" keyring.set_keyring(kr)
class Crypt(object): def __init__(self): self.path = "/root/.local/share/webtentacle_keyring" self.mother_service = '?' self.kr = CryptFileKeyring() self.kr.keyring_key = '?' parser = argparse.ArgumentParser( description="Decrypt the system file", usage='''crypt decrypt --username <username> crypt encrypt --username <username> --password <password> The most commonly used decrypt commands are: crypt decrypt --username admin, returns password ''') parser.add_argument('command', help='Subcommand to run') args = parser.parse_args(sys.argv[1:2]) if not hasattr(self, args.command): print('Unrecognized command') parser.print_help() exit(1) getattr(self, args.command)() def decrypt(self): try: parser = argparse.ArgumentParser( description="decrypt service usernames's password") parser.add_argument('--username', '-u') args = parser.parse_args(sys.argv[2:]) # invoke the keyring print(self.kr.get_password(self.mother_service, args.username), end='') except Exception as msg: print("Error in keyring decryption, {}".format(str(msg))) sys.exit(2) def encrypt(self): try: parser = argparse.ArgumentParser( description="encrypt service username's passowrd") parser.add_argument('--username', '-u') parser.add_argument('--password', '-p') args = parser.parse_args(sys.argv[2:]) self.kr.set_password(self.mother_service, args.username, args.password) return 0 except Exception as msg: print("Error in keyring encryption, {}".format(str(msg))) sys.exit(2)
def _configure_backend(self) -> Union[Any, FileKeyring]: from chia.util.keychain import supports_keyring_passphrase if self.keyring: raise Exception("KeyringWrapper has already been instantiated") if platform == "win32" or platform == "cygwin": import keyring.backends.Windows keyring.set_keyring(keyring.backends.Windows.WinVaultKeyring()) elif platform == "darwin": import keyring.backends.macOS keyring.set_keyring(keyring.backends.macOS.Keyring()) # TODO: New keyring + passphrase support can be enabled for macOS by updating # supports_keyring_passphrase() and uncommenting the lines below. Leaving the # lines below in place for testing. # # if supports_keyring_passphrase(): # keyring = FileKeyring(keys_root_path=self.keys_root_path) # type: ignore # else: # keyring.set_keyring(keyring.backends.macOS.Keyring()) elif platform == "linux": if supports_keyring_passphrase(): keyring = FileKeyring( keys_root_path=self.keys_root_path) # type: ignore else: keyring = CryptFileKeyring() keyring.keyring_key = "your keyring password" # type: ignore else: keyring = keyring_main return keyring
def create_empty_cryptfilekeyring() -> CryptFileKeyring: """ Create an empty legacy keyring """ crypt_file_keyring = CryptFileKeyring() fd = os.open(crypt_file_keyring.file_path, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o600) os.close(fd) assert Path(crypt_file_keyring.file_path).exists() return crypt_file_keyring
def get_legacy_keyring_instance() -> Optional[LegacyKeyring]: if platform == "darwin": return MacKeyring() elif platform == "win32" or platform == "cygwin": return WinKeyring() elif platform == "linux": keyring: CryptFileKeyring = CryptFileKeyring() keyring.keyring_key = "your keyring password" return keyring return None
def __init__(self): self.path = "/root/.local/share/webtentacle_keyring" self.mother_service = '?' self.kr = CryptFileKeyring() self.kr.keyring_key = '?' parser = argparse.ArgumentParser( description="Decrypt the system file", usage='''crypt decrypt --username <username> crypt encrypt --username <username> --password <password> The most commonly used decrypt commands are: crypt decrypt --username admin, returns password ''') parser.add_argument('command', help='Subcommand to run') args = parser.parse_args(sys.argv[1:2]) if not hasattr(self, args.command): print('Unrecognized command') parser.print_help() exit(1) getattr(self, args.command)()
def __init__(self): self.DEBUG = False self.DEVELOPMENT = False self.TESTING = False # Mail server config self.MAIL_SERVER = 'smtp.gmail.com' self.MAIL_PORT = 465 self.MAIL_USE_TLS = False self.MAIL_USE_SSL = True # Mail credentials and recipient try: kr = CryptFileKeyring() kr.file_path = os.path.join(os.getcwd(), 'keyring') self.MAIL_USERNAME = kr.get_password("scheduled_mail", "MAIL_USER") self.MAIL_PASSWORD = kr.get_password("scheduled_mail", "MAIL_PASSWORD") self.RECIPIENT = kr.get_password("scheduled_mail", "RECIPIENT") except ValueError as e: raise KeyringError("Error while accessing the keyring.") from e # Scheduler settings self.SCHEDULER_INTERVAL = 1 # Config file for instances self.INSTANCE_PATH = "instances.json" self.INSTANCE_START_DATE = datetime(2018, 6, 19, 0, 0, 0)
def get_password(key: str, service: str): config = read_config() try: cryptfile_pw = config.get("cryptfile", "password") except configparser.NoSectionError: cryptfile_pw = None if cryptfile_pw is not None: # See https://github.com/frispete/keyrings.cryptfile#example-session # on how to set pws. kr = CryptFileKeyring() kr.keyring_key = base64_decode(cryptfile_pw) pw = kr.get_password(service, key) if not pw: code = f"import net_worth_tracker as nwt; nwt.utils.set_password('{service}', '{key}')" raise Exception(f'Use:\npython -c "{code}"') else: pw = keyring.get_password(service, key) if not pw: raise Exception(f"python -m keyring set {service} {key}") return pw
def __init__(self): self.aesmodes = CryptFileKeyring._get_mode() self.parser = argparse.ArgumentParser( usage = '%(prog)s [-hvk] aesmode [infile] [outfile]', epilog = NOTE, formatter_class=argparse.RawDescriptionHelpFormatter) self.parser.add_argument('aesmode', help = 'new AES mode [one of: %s]' % ', '.join(self.aesmodes)) self.parser.add_argument('infile', help = 'Keyring file to convert', nargs = '?') self.parser.add_argument('outfile', help = 'New keyring file [default: infile.pid]', nargs = '?') self.parser.add_argument('-v', '--verbose', help = 'verbose mode (cumulative)', action = 'count') self.parser.add_argument('-k', '--keep', help = 'keep old password', action = 'store_true')
def make_app() -> Application: """Application object factory. :param env: environment name, defaults to None :type env: Optional[str], optional :return: application object :rtype: Application """ flask_environment = os.environ.get('FLASK_ENV', '') if flask_environment == 'production': sentry_dsn = os.getenv('SENTRY_DSN') if sentry_dsn: version = get_version() sentry_sdk.init( dsn=sentry_dsn, release=f'bip@{version}', integrations=[FlaskIntegration()], ) configure_logging() extra = {} instance_path = os.environ.get('INSTANCE_PATH') if instance_path: extra['instance_path'] = instance_path app = Application(__name__.split('.')[0], **extra) if flask_environment != 'dev': app.logger.info(f'BIP application running in mode {flask_environment}') configure_app(app) # setup keyring for headless environments if flask_environment in ('production', 'test'): keyring.set_keyring(CryptFileKeyring()) with app.app_context(): configure_logging_handler(app) configure_database(app) configure_extensions(app) configure_templating(app) configure_hooks(app) configure_blueprints(app) configure_error_handlers(app) return app
class MinervaConfig(object): def __init__(self): self.settings_obj = {} self.descriptions = { 'default':'Determines whether the passwords are set to default', 'use_stored_credentials':'If value is "email" or "minerva", then use stored credentials regularly. Default: "false"' } self.defaults_obj = { 'default':'true', 'use_stored_credentials':'false' } self.kr = CryptFileKeyring() def __getitem__(self,key): return self.settings_obj[key] def __setitem__(self,key,value): self.settings_obj[key] = value def get_settings(self, keyring_pass='', inConsole=False): """Loads the settings from the computer's keyring""" if keyring_pass == '' and inConsole: self.kr.keyring_key = getpass.getpass() # only when in the console and no argument already given self.kr.keyring_key = keyring_pass # check if it's the first time for keys if self.kr.get_password('minervaclient_default','minerva') is None: self.default_settings() for key in self.descriptions.keys(): self[key] = self.kr.get_password('minervaclient_'+key,'minerva') def set_settings(self): """Takes the current settings and persists the changes to computer storage""" for key, item in self.settings_obj.items(): self.kr.set_password('minervaclient_'+key,'minerva',item) def default_settings(self, inConsole=False): """Resets the current settings to original""" for key, item in self.defaults_obj.items(): self.kr.set_password('minervaclient_'+key,'minerva',item) def list_settings(self): result = [ i for i in self.settings_obj.keys() ] result.sort() return result
from os import getenv from keyrings.cryptfile.cryptfile import CryptFileKeyring kr = CryptFileKeyring() kr.keyring_key = getenv("KEYRING_CRYPTFILE_PASSWORD") print(kr.get_password("web", "pyquickhelper,user"))
def secure_keyring_access(keyring_name=None): "Encrypted Keyring file access." kr = CryptFileKeyring() kr._unlock() return (kr)
from blspy import AugSchemeMPL, G1Element, PrivateKey from keyrings.cryptfile.cryptfile import CryptFileKeyring from src.util.hash import std_hash MAX_KEYS = 100 if platform == "win32" or platform == "cygwin": import keyring.backends.Windows keyring.set_keyring(keyring.backends.Windows.WinVaultKeyring()) elif platform == "darwin": import keyring.backends.OS_X keyring.set_keyring(keyring.backends.OS_X.Keyring()) elif platform == "linux": keyring = CryptFileKeyring() keyring.keyring_key = "your keyring password" else: keyring = keyring_main def bip39_word_list() -> str: return pkg_resources.resource_string(__name__, "english.txt").decode() def generate_mnemonic() -> str: mnemonic_bytes = token_bytes(32) mnemonic = bytes_to_mnemonic(mnemonic_bytes) return mnemonic
from pathlib import Path from keyrings.cryptfile.cryptfile import CryptFileKeyring from PyQt5 import QtWidgets from audio_app import VkAudioApp def ui(): app = QtWidgets.QApplication(sys.argv) window = VkAudioApp(info, cookie, keyring) window.show() app.exec_() if __name__ == "__main__": keyring = CryptFileKeyring() keyring.keyring_key = os.getlogin() home = Path.home() / ".vk_downloader" try: home.mkdir(exist_ok=True) except (PermissionError, FileNotFoundError): home = tempfile.TemporaryDirectory() cookie = home / "vk_cookies.json" data = keyring.get_password("vk_music_downloader", os.getlogin()) if isinstance(data, str): info = data.split("|") else: info = None ui()
HASPA = which('pasuspender') is not None aplay = "aplay -q -D %s -f %s --disable-resample --disable-channels --disable-channels --disable-softvol final.wav" % ( AUDIODEV, MySource.SampleFormat) if HASPA is True: print("Using pasuspender to bypass pulseaudio.") aplay = pasuspender + aplay HASMQA = (which('mqadec') is not None) and (which('mqarender') is not None) session = tidalapi.Session() login_attempts = 0 allowed_attempts = 3 while login_attempts < allowed_attempts: kr = CryptFileKeyring() username = input('TIDAL username: '******'TIDAL password: '******'TIDAL username: '******'\N{EIGHTH NOTE} Successfully logged in! \N{EIGHTH NOTE}') except UnicodeEncodeError: print('Successfully logged in!') break
def set_keyring(): kr = CryptFileKeyring() kr.keyring_key = os.environ["KEYRING_CRYPTFILE_PSSWRD"] keyring.set_keyring(kr)
from keyrings.cryptfile.cryptfile import CryptFileKeyring from chia.util.hash import std_hash MAX_KEYS = 100 if platform == "win32" or platform == "cygwin": import keyring.backends.Windows keyring.set_keyring(keyring.backends.Windows.WinVaultKeyring()) elif platform == "darwin": import keyring.backends.macOS keyring.set_keyring(keyring.backends.macOS.Keyring()) elif platform == "linux": keyring = CryptFileKeyring() keyring.keyring_key = "your keyring password" # type: ignore else: keyring = keyring_main def bip39_word_list() -> str: return pkg_resources.resource_string(__name__, "english.txt").decode() def generate_mnemonic() -> str: mnemonic_bytes = token_bytes(32) mnemonic = bytes_to_mnemonic(mnemonic_bytes) return mnemonic
raise NotImplementedError def schedule(self): """Retrieves student's schedule information from Minerva.""" raise NotImplementedError def register(self): """Attempts to register the user into a course through Minerva, given a CRN or Course Code.""" raise NotImplementedError class MinervaState(object): register,wait,closed,possible,unknown,wait_places_remaining,full,full_places_remaining,only_waitlist_known = list(range(9)) class MinervaError(object): reg_ok,reg_fail,reg_wait,course_none,course_not_found,user_error,net_error,require_unsatisfiable = list(range(8)) from keyrings.cryptfile.cryptfile import CryptFileKeyring kr = CryptFileKeyring() class MinervaConfig(object): def __init__(self): self.settings_obj = {} self.descriptions = { 'default':'Determines whether the passwords are set to default', 'use_stored_credentials':'If value is "email" or "minerva", then use stored credentials regularly. Default: "false"' } self.defaults_obj = { 'default':'true', 'use_stored_credentials':'false' } self.kr = CryptFileKeyring() def __getitem__(self,key): return self.settings_obj[key]
def run(self, argv): # parse args, setup logging and prepare keyrings args = self.parser.parse_args(argv) self.setup_logging(args.verbose) inkr = CryptFileKeyring() outkr = CryptFileKeyring() outkr.aesmode = args.aesmode # prepare infile infile = args.infile if not infile: infile = inkr.file_path else: inkr.file_path = infile inkr.filename = os.path.basename(infile) if not os.path.exists(infile): self.errexit('%s not found' % infile) if not inkr._check_file(): self.errexit('Failed to parse %s' % infile) log.info('infile %s: %s', infile, inkr.scheme) # prepare outfile outfile = args.outfile if not outfile: outfile = infile + '.%d' % os.getpid() if os.path.exists(outfile): if os.path.samefile(infile, outfile): self.errexit('infile and outfile must NOT be the same file') # outfile exists: rename os.rename(outfile, outfile + '~') log.info('%s renamed to %s~', outfile, outfile) outkr.file_path = outfile outkr.filename = os.path.basename(outfile) log.info('outfile %s: %s', outfile, outkr.scheme) # unlock the infile keyring try: inkr.keyring_key except ValueError as e: self.errexit('Unlock %s: %s' % (infile, e)) # keep old password or request password for new keyring if args.keep: outkr._get_new_password = lambda: inkr.keyring_key else: outkr.keyring_key # process infile config = configparser.RawConfigParser() config.read(infile) for section in config.sections(): log.debug('process section: [%s]', section) if section != escape('keyring-setting'): for username in config.options(section): username = unescape(username) section = unescape(section) log.info('process: [%s] %s', section, username) password = inkr.get_password(section, username) if password: outkr.set_password(section, username, password) log.debug('[%s] %s: %s', section, username, password) else: log.error('invalid entry: [%s]%s', section, username) return 0
log = logging.getLogger('convert') import configparser from keyrings.cryptfile.cryptfile import CryptFileKeyring from keyrings.cryptfile._escape import escape, unescape NOTE = """\ Note: no effort has been made to replace the original keyring file. Please check the new keyring file, and rename it manually. If outfile exists already, it is preserved as outfile~. Default infile: %s """ % CryptFileKeyring().file_path class CommandLineTool(object): def __init__(self): self.aesmodes = CryptFileKeyring._get_mode() self.parser = argparse.ArgumentParser( usage = '%(prog)s [-hvk] aesmode [infile] [outfile]', epilog = NOTE, formatter_class=argparse.RawDescriptionHelpFormatter) self.parser.add_argument('aesmode', help = 'new AES mode [one of: %s]' % ', '.join(self.aesmodes)) self.parser.add_argument('infile', help = 'Keyring file to convert', nargs = '?') self.parser.add_argument('outfile', help = 'New keyring file [default: infile.pid]',