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 _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