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]',
