def _gen_key(self):
"""
Generates the key pair if needed, uploads it to the webapp and
nickserver
"""
leap_assert(self._provider_config is not None, "We need a provider configuration!")
leap_assert(self._soledad is not None, "We need a non-null soledad to generate keys")
address = make_address(self._user, self._provider_config.get_domain())
logger.debug("Retrieving key for %s" % (address,))
try:
self._keymanager.get_key(address, openpgp.OpenPGPKey, private=True, fetch_remote=False)
return
except KeyNotFound:
logger.debug("Key not found. Generating key for %s" % (address,))
# generate key
try:
self._keymanager.gen_key(openpgp.OpenPGPKey)
except Exception as exc:
logger.error("Error while generating key!")
logger.exception(exc)
raise
# send key
try:
self._keymanager.send_key(openpgp.OpenPGPKey)
except Exception as exc:
logger.error("Error while sending key!")
logger.exception(exc)
raise
logger.debug("Key generated successfully.")
def _save_credentials(self):
"""
If the user asked to remember the credentials, we save them into the
keyring.
"""
provider = self._provider
username = self.get_user()
password = self.get_password()
self._settings.set_provider(provider)
if self.get_remember() and has_keyring():
# in the keyring and in the settings
# we store the value 'usename@provider'
full_user_id = make_address(username, provider).encode("utf8")
try:
keyring = get_keyring()
keyring.set_password(self.KEYRING_KEY, full_user_id,
password.encode("utf8"))
# Only save the username if it was saved correctly in
# the keyring
self._settings.set_user(full_user_id)
except KeyringInitError as e:
logger.error("Failed to unlock keyring, maybe the user "
"cancelled the operation {0!r}".format(e))
except Exception as e:
logger.exception("Problem saving data to keyring. %r" % (e, ))
def _save_credentials(self):
"""
If the user asked to remember the credentials, we save them into the
keyring.
"""
provider = self._provider
username = self.get_user()
password = self.get_password()
self._settings.set_provider(provider)
if self.get_remember() and has_keyring():
# in the keyring and in the settings
# we store the value 'usename@provider'
full_user_id = make_address(username, provider).encode("utf8")
try:
keyring = get_keyring()
keyring.set_password(self.KEYRING_KEY,
full_user_id, password.encode("utf8"))
# Only save the username if it was saved correctly in
# the keyring
self._settings.set_user(full_user_id)
except KeyringInitError as e:
logger.error("Failed to unlock keyring, maybe the user "
"cancelled the operation {0!r}".format(e))
except Exception as e:
logger.exception("Problem saving data to keyring. %r" % (e,))
def __init__(self, username, domain):
self._settings = LeapSettings()
self.username = username
self.domain = domain
if self.username is not None:
self.address = make_address(self.username, self.domain)
else:
self.address = self.domain
def __init__(self, username, domain):
self._settings = LeapSettings()
self.username = username
self.domain = domain
if self.username is not None:
self.address = make_address(self.username, self.domain)
else:
self.address = self.domain
def _set_logged_in(self):
"""
Set the widgets to the logged in state.
"""
fullname = make_address(self.get_user(), self._provider)
self._state.full_logged_username = fullname
self.ui.login_widget.hide()
self.ui.logged_widget.show()
self.ui.lblUser.setText(fullname)
def _set_logged_in(self):
"""
Set the widgets to the logged in state.
"""
fullname = make_address(self.get_user(), self._provider)
self._state.full_logged_username = fullname
self.ui.login_widget.hide()
self.ui.logged_widget.show()
self.ui.lblUser.setText(fullname)
def logged_in(self):
"""
Sets the widgets to the logged in state
"""
self.ui.login_widget.hide()
self.ui.logged_widget.show()
self.ui.lblUser.setText(make_address(
self.get_user(), self.get_selected_provider()))
if flags.OFFLINE is False:
self.logged_in_signal.emit()
def logged_in(self, provider):
"""
Sets the widgets to the logged in state
:param provider: the domain of the current provider
:type provider: unicode str
"""
self.ui.login_widget.hide()
self.ui.logged_widget.show()
self.ui.lblUser.setText(make_address(self.get_user(), provider))
if flags.OFFLINE is False:
self.logged_in_signal.emit()
def start_login(self):
"""
Setups the login widgets for actually performing the login and
performs some basic checks.
:returns: True if everything's good to go, False otherwise
:rtype: bool
"""
username = self.get_user()
password = self.get_password()
provider = self.get_selected_provider()
self._enabled_services = self._settings.get_enabled_services(
self.get_selected_provider())
if len(provider) == 0:
self.set_status(
self.tr("Please select a valid provider"))
return False
if len(username) == 0:
self.set_status(
self.tr("Please provide a valid username"))
return False
if len(password) == 0:
self.set_status(
self.tr("Please provide a valid password"))
return False
self.set_status(self.tr("Logging in..."), error=False)
self.set_enabled(False)
self.ui.clblErrorMsg.hide()
self._settings.set_provider(provider)
if self.get_remember() and has_keyring():
# in the keyring and in the settings
# we store the value 'usename@provider'
full_user_id = make_address(username, provider).encode("utf8")
try:
keyring = get_keyring()
keyring.set_password(self.KEYRING_KEY,
full_user_id,
password.encode("utf8"))
# Only save the username if it was saved correctly in
# the keyring
self._settings.set_user(full_user_id)
except Exception as e:
logger.exception("Problem saving data to keyring. %r"
% (e,))
return True
def load_and_sync_soledad(self, uuid=None, offline=False):
"""
Once everthing is in the right place, we instantiate and sync
Soledad
:param uuid: the uuid of the user, used in offline mode.
:type uuid: unicode, or None.
:param offline: whether to instantiate soledad for offline use.
:type offline: bool
"""
local_param = self._get_soledad_local_params(uuid, offline)
remote_param = self._get_soledad_server_params(uuid, offline)
secrets_path, local_db_path, token = local_param
server_url, cert_file = remote_param
try:
self._try_soledad_init(
uuid, secrets_path, local_db_path,
server_url, cert_file, token)
except Exception:
# re-raise the exceptions from try_init,
# we're currently handling the retries from the
# soledad-launcher in the gui.
raise
leap_assert(not sameProxiedObjects(self._soledad, None),
"Null soledad, error while initializing")
if flags.OFFLINE is True:
self._init_keymanager(self._address, token)
self.local_only_ready.emit({self.PASSED_KEY: True})
else:
try:
address = make_address(
self._user, self._provider_config.get_domain())
self._init_keymanager(address, token)
self._keymanager.get_key(
address, openpgp.OpenPGPKey,
private=True, fetch_remote=False)
d = threads.deferToThread(self._do_soledad_sync)
d.addErrback(self._soledad_sync_errback)
except KeyNotFound:
logger.debug("Key not found. Generating key for %s" %
(address,))
self._do_soledad_sync()
def load_and_sync_soledad(self, uuid=None, offline=False):
"""
Once everthing is in the right place, we instantiate and sync
Soledad
:param uuid: the uuid of the user, used in offline mode.
:type uuid: unicode, or None.
:param offline: whether to instantiate soledad for offline use.
:type offline: bool
"""
local_param = self._get_soledad_local_params(uuid, offline)
remote_param = self._get_soledad_server_params(uuid, offline)
secrets_path, local_db_path, token = local_param
server_url, cert_file = remote_param
try:
self._do_soledad_init(uuid, secrets_path, local_db_path,
server_url, cert_file, token)
except SoledadInitError:
# re-raise the exceptions from try_init,
# we're currently handling the retries from the
# soledad-launcher in the gui.
raise
leap_assert(not sameProxiedObjects(self._soledad, None),
"Null soledad, error while initializing")
if flags.OFFLINE:
self._init_keymanager(self._address, token)
else:
try:
address = make_address(self._user,
self._provider_config.get_domain())
self._init_keymanager(address, token)
self._keymanager.get_key(address,
openpgp.OpenPGPKey,
private=True,
fetch_remote=False)
d = threads.deferToThread(self._do_soledad_sync)
d.addErrback(self._soledad_sync_errback)
except KeyNotFound:
logger.debug("Key not found. Generating key for %s" %
(address, ))
self._do_soledad_sync()
def _gen_key(self):
"""
Generates the key pair if needed, uploads it to the webapp and
nickserver
:rtype: Deferred
"""
leap_assert(self._provider_config is not None,
"We need a provider configuration!")
leap_assert(self._soledad is not None,
"We need a non-null soledad to generate keys")
address = make_address(self._user, self._provider_config.get_domain())
logger.debug("Retrieving key for %s" % (address, ))
def if_not_found_generate(failure):
failure.trap(KeyNotFound)
logger.debug("Key not found. Generating key for %s" % (address, ))
d = self._keymanager.gen_key(openpgp.OpenPGPKey)
d.addCallbacks(send_key, log_key_error("generating"))
return d
def send_key(_):
d = self._keymanager.send_key(openpgp.OpenPGPKey)
d.addCallbacks(
lambda _: logger.debug("Key generated successfully."),
log_key_error("sending"))
def log_key_error(step):
def log_err(failure):
logger.error("Error while %s key!", (step, ))
logger.exception(failure.value)
return failure
return log_err
d = self._keymanager.get_key(address,
openpgp.OpenPGPKey,
private=True,
fetch_remote=False)
d.addErrback(if_not_found_generate)
return d
def _gen_key(self):
"""
Generates the key pair if needed, uploads it to the webapp and
nickserver
:rtype: Deferred
"""
leap_assert(self._provider_config is not None,
"We need a provider configuration!")
leap_assert(self._soledad is not None,
"We need a non-null soledad to generate keys")
address = make_address(
self._user, self._provider_config.get_domain())
logger.debug("Retrieving key for %s" % (address,))
def if_not_found_generate(failure):
failure.trap(KeyNotFound)
logger.debug("Key not found. Generating key for %s"
% (address,))
d = self._keymanager.gen_key(openpgp.OpenPGPKey)
d.addCallbacks(send_key, log_key_error("generating"))
return d
def send_key(_):
d = self._keymanager.send_key(openpgp.OpenPGPKey)
d.addCallbacks(
lambda _: logger.debug("Key generated successfully."),
log_key_error("sending"))
def log_key_error(step):
def log_err(failure):
logger.error("Error while %s key!", (step,))
logger.exception(failure.value)
return failure
return log_err
d = self._keymanager.get_key(
address, openpgp.OpenPGPKey, private=True, fetch_remote=False)
d.addErrback(if_not_found_generate)
return d
def _load_soledad_online(self, uuid, secrets_path, local_db_path,
server_url, cert_file, token):
syncable = True
try:
self._do_soledad_init(uuid, secrets_path, local_db_path,
server_url, cert_file, token, syncable)
except SoledadInitError as e:
# re-raise the exceptions from try_init,
# we're currently handling the retries from the
# soledad-launcher in the gui.
return defer.fail(e)
leap_assert(not sameProxiedObjects(self._soledad, None),
"Null soledad, error while initializing")
address = make_address(self._user, self._provider_config.get_domain())
syncer = Syncer(self._soledad, self._signaler)
d = self._init_keymanager(address, token)
d.addCallback(lambda _: syncer.sync())
d.addErrback(self._soledad_sync_errback)
return d
def _gen_key(self):
"""
Generates the key pair if needed, uploads it to the webapp and
nickserver
"""
leap_assert(self._provider_config is not None,
"We need a provider configuration!")
leap_assert(self._soledad is not None,
"We need a non-null soledad to generate keys")
address = make_address(self._user, self._provider_config.get_domain())
logger.debug("Retrieving key for %s" % (address, ))
try:
self._keymanager.get_key(address,
openpgp.OpenPGPKey,
private=True,
fetch_remote=False)
return
except KeyNotFound:
logger.debug("Key not found. Generating key for %s" % (address, ))
# generate key
try:
self._keymanager.gen_key(openpgp.OpenPGPKey)
except Exception as exc:
logger.error("Error while generating key!")
logger.exception(exc)
raise
# send key
try:
self._keymanager.send_key(openpgp.OpenPGPKey)
except Exception as exc:
logger.error("Error while sending key!")
logger.exception(exc)
raise
logger.debug("Key generated successfully.")
def _load_soledad_online(self, uuid, secrets_path, local_db_path,
server_url, cert_file, token):
syncable = True
try:
self._do_soledad_init(uuid, secrets_path, local_db_path,
server_url, cert_file, token, syncable)
except SoledadInitError as e:
# re-raise the exceptions from try_init,
# we're currently handling the retries from the
# soledad-launcher in the gui.
return defer.fail(e)
leap_assert(not sameProxiedObjects(self._soledad, None),
"Null soledad, error while initializing")
address = make_address(
self._user, self._provider_config.get_domain())
syncer = Syncer(self._soledad, self._signaler)
d = self._init_keymanager(address, token)
d.addCallback(lambda _: syncer.sync())
d.addErrback(self._soledad_sync_errback)
return d
