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(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))
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
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 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
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"))
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()
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
else:
print(
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
