def has_credentials(self): try: if self._key == gkey.ITEM_NETWORK_PASSWORD: attrs = {"server": self._server, "protocol": self._protocol} items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) return len(items) > 0 if self._key == gkey.ITEM_GENERIC_SECRET: attrs = {"name": self._name} items = gkey.find_items_sync(gkey.ITEM_GENERIC_SECRET, attrs) return len(items) > 0 except gkey.DeniedError: return False
def store_password(self, datasource): """Update password. If the gnomekeyring bindings are available, the password is stored in the keyring. Otherwise it's stored in datasources.cfg. It's assumed, that the data source has an ID. So, this method *must* be called after the data source has been saved once. :param datasource: A data source. """ if not USE_KEYRING: return item_type = gnomekeyring.ITEM_GENERIC_SECRET attrs = {"crunchyfrog": datasource.id} try: entry = gnomekeyring.find_items_sync(item_type, attrs) entry = entry[0] except gnomekeyring.NoMatchError: entry = None if datasource.url.password is not None: gnomekeyring.item_create_sync(None, item_type, 'crunchyfrog/%s' % datasource.id, attrs, datasource.url.password, True) elif entry is not None: gnomekeyring.item_delete_sync(None, entry.item_id)
def has_credentials(self): try: attrs = {"server": self._server, "protocol": self._protocol} items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) return len(items) > 0 except gkey.DeniedError: return False
def __init__(self, account=None, dialog=None): """Creates the account pane for configuring Twitter accounts""" gtk.VBox.__init__( self, False, 20 ) self.ui = gtk.Builder() self.ui.set_translation_domain ("gwibber") self.ui.add_from_file (gwibber.resources.get_ui_asset("gwibber-accounts-twitter.ui")) self.ui.connect_signals(self) self.vbox_settings = self.ui.get_object("vbox_settings") self.pack_start(self.vbox_settings, False, False) self.show_all() self.account = account or {} self.dialog = dialog has_secret_key = True if self.account.has_key("id"): try: value = gnomekeyring.find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET, {"id": str("%s/%s" % (self.account["id"], "secret_token"))})[0].secret except gnomekeyring.NoMatchError: has_secret_key = False try: if self.account.has_key("access_token") and self.account.has_key("secret_token") and self.account.has_key("username") and has_secret_key: self.ui.get_object("hbox_twitter_auth").hide() self.ui.get_object("fb_auth_done_label").set_label(_("%s has been authorized by Twitter") % self.account["username"]) self.ui.get_object("hbox_twitter_auth_done").show() else: self.ui.get_object("hbox_twitter_auth_done").hide() self.ui.get_object("twitter_auth_button").modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("red")) if self.dialog: self.dialog.get_object('vbox_create').hide() except: self.ui.get_object("hbox_twitter_auth_done").hide() if self.dialog: self.dialog.get_object("vbox_create").hide()
def find(self, attrs, single=False): """Search for secret with $attrs in all of the keyrings. """ self.check_attributes(attrs) results = [] try: for k in gk.find_items_sync(self.type, attrs): x = {"keyring": k.keyring, "id": k.item_id, "attributes": k.attributes, "secret": k.secret} try: x["display_name"] = gk.item_get_info_sync(k.keyring, k.item_id).get_display_name() except gk.DeniedError: raise # should not happen. logging.info(" x = %s" % str(x)) results.append(x) if single: return results except gk.NoMatchError: pass except: raise return results
def get_credentials(self, scheme, host, port=None, user=None, path=None, realm=None): if gnomekeyring is None: return None attrs = { "protocol": scheme.encode("utf-8"), "server": host.encode("utf-8"), } # TODO: realm ? if port is not None: attrs["port"] = port if user is not None: attrs["user"] = user.encode("utf-8") credentials = { "scheme": scheme, "host": host, "port": port, "realm": realm, "user": user} try: items = gnomekeyring.find_items_sync( gnomekeyring.ITEM_NETWORK_PASSWORD, attrs) credentials["user"] = items[0].attributes["user"] credentials["password"] = items[0].secret return credentials except (gnomekeyring.NoMatchError, gnomekeyring.DeniedError, gnomekeyring.NoKeyringDaemonError, gnomekeyring.IOError), e: from bzrlib import trace trace.mutter('Unable to obtain credentials for %r from GNOME keyring: %r', attrs, e) return None
def __get_credentials(self, key_name): try: items = gnomekeyring.find_items_sync( gnomekeyring.ITEM_GENERIC_SECRET, {"key_name": key_name}) return items[0].attributes["user"], items[0].secret except (gnomekeyring.DeniedError, gnomekeyring.NoMatchError): return None, None
def _GetNameAndPassword(self): """Display a modal dialog asking for a name and password. This info is used for login when deploying the applications; it is saved in GNOME keyring. Returns: wx.ID_OK or wx.ID_CANCEL """ self._ConfigureDialog() rtn = self.dialog.ShowModal() if rtn == wx.ID_OK: self._authname = str(self.dialog.name_text_ctrl.GetValue()) self._password = self.dialog.password_text_ctrl.GetValue() # Store information in keyring try: items = gk.find_items_sync(gk.ITEM_NETWORK_PASSWORD, self._gkAttr) for item in items: if item.attributes["user"] != self._authname: gk.item_delete_sync('login', item.item_id) except gk.NoMatchError: pass self._gkAttr["user"] = self._authname gk.item_create_sync('login', gk.ITEM_NETWORK_PASSWORD, 'Google App Engine Credentials', self._gkAttr, self._password, True) return rtn
def test_keyring_populate(self): attr = { 'token' : 'the-token', 'consumer-key' : 'the-consumer-key', 'usage' : 'software-center-agent-token', } secret = 'consumer_secret=xxx&token=xxx&consumer_key=xxx&token_secret=xxx&name=s-c' keyring_names = gk.list_keyring_names_sync() print keyring_names self.assertFalse(self.KEYRING_NAME in keyring_names) gk.create_sync(self.KEYRING_NAME, "") keyring_names = gk.list_keyring_names_sync() self.assertTrue(self.KEYRING_NAME in keyring_names) res = gk.item_create_sync(self.KEYRING_NAME, gk.ITEM_GENERIC_SECRET, "Software Center Agent token", attr, secret, True) # update if exists self.assertTrue(res) # get the token from the keyring using the 'usage' field # in the attr search_attr = { 'usage' : 'software-center-agent-token', } found = gk.find_items_sync(gk.ITEM_GENERIC_SECRET, search_attr) self.assertEqual(len(found), 1) for item in found: self.assertEqual(item.keyring, self.KEYRING_NAME) #print item.item_id, item.attributes self.assertEqual(item.secret, secret)
def get_credentials(self): """ Get a key. """ attrs = {"server": self._server, "protocol": self._protocol} items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) return (items[0].attributes["user"], items[0].secret)
def ask_password(self, method, key, message, first): """Query for a password.""" display_name = "submit password %s.%s" % (method, key) attrs = dict(submit=1, method=method, key=key) try: # first try: perhaps the correct password is in the keyring if first: try: items = gnomekeyring.find_items_sync( gnomekeyring.ITEM_GENERIC_SECRET, attrs) return items[0].secret except gnomekeyring.NoMatchError: pass # no, it isn’t; show a dialog to get the password password, store = self.password_dialog( method, key, message, first, True) if password is None: return None if store: gnomekeyring.item_create_sync( self.keyring, gnomekeyring.ITEM_GENERIC_SECRET, display_name, attrs, password, True) return password except gnomekeyring.DeniedError: raise AuthenticationFailedError( n_("Unable to access GNOME keyring."))
def __init__(self, account=None, dialog=None): """Creates the account pane for configuring facebook accounts""" gtk.VBox.__init__( self, False, 20 ) self.ui = gtk.Builder() self.ui.set_translation_domain ("gwibber") self.ui.add_from_file (resources.get_ui_asset("gwibber-accounts-facebook.ui")) self.ui.connect_signals(self) self.vbox_settings = self.ui.get_object("vbox_settings") self.pack_start(self.vbox_settings, False, False) self.show_all() if account: self.account = account else: self.account = {} self.dialog = dialog has_access_token = True if self.account.has_key("id"): try: value = gnomekeyring.find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET, {"id": str("%s/%s" % (self.account["id"], "access_token"))})[0].secret except gnomekeyring.NoMatchError: has_access_token = False try: if self.account["access_token"] and self.account["username"] and has_access_token and not self.dialog.condition: self.ui.get_object("hbox_facebook_auth").hide() self.ui.get_object("fb_auth_done_label").set_label(_("%s has been authorized by Facebook") % str(self.account["username"])) self.ui.get_object("hbox_facebook_auth_done").show() else: self.ui.get_object("hbox_facebook_auth_done").hide() if self.dialog.ui: self.dialog.ui.get_object('vbox_create').hide() except: self.ui.get_object("hbox_facebook_auth_done").hide() if self.dialog.ui: self.dialog.ui.get_object("vbox_create").hide()
def password(self): n = self._password if n is None: if gtkpresence: try: keyring = gnomekeyring.get_default_keyring_sync() keyring_info = gnomekeyring.get_info_sync(keyring) if keyring_info.get_is_locked(): nof_tries = 3 for i in range(nof_tries): keyring_pass = getpass('Enter password to unlock your default keychain: ') try: gnomekeyring.unlock_sync(keyring, keyring_pass) break except gnomekeyring.DeniedError: if i+1==nof_tries: sys.stderr.write('\nFailed to unlock keychain (%s times)\n' % (i+1)) else: sys.stderr.write("\nInvalid password, try again...\n") items = gnomekeyring.find_items_sync(gnomekeyring.ITEM_NETWORK_PASSWORD, {"server": self.server, "protocol": "ftp", "user": self.username}) if len(items) > 0: n = items[0].secret except gnomekeyring.DeniedError: sys.stderr.write("\nGnome keyring error : Access denied ..\n") except gnomekeyring.NoMatchError: sys.stderr.write("\nGnome keyring error : No credential for %s..\n" % self.server) except Exception, msg: sys.stderr.write("\nGnome keyring error : %s\n" % (msg)) sys.stderr.flush() if n is None: n = getpass('Enter password for ftp://%s@%s: ' % (self.username, self.server)) self._password = n
def get_passwd(self, user): self.attributes['user'] = user try: items = gkey.find_items_sync(self.scheme, self.attributes) return (items[0].attributes["user"], items[0].secret) except (gkey.NoMatchError, gkey.CancelledError, IndexError): return None
def __init__(self, account=None, dialog=None): """Creates the account pane for configuring identi.ca accounts""" gtk.VBox.__init__( self, False, 20 ) self.ui = gtk.Builder() self.ui.set_translation_domain ("gwibber") self.ui.add_from_file (resources.get_ui_asset("gwibber-accounts-identica.ui")) self.ui.connect_signals(self) self.vbox_settings = self.ui.get_object("vbox_settings") self.pack_start(self.vbox_settings, False, False) self.show_all() self.account = account or {} self.dialog = dialog self.url_prefix = "https://identi.ca" has_secret_key = True if self.account.has_key("id"): try: value = gnomekeyring.find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET, {"id": str("%s/%s" % (self.account["id"], "secret_token"))})[0].secret except gnomekeyring.NoMatchError: has_secret_key = False try: if self.account.has_key("access_token") and self.account.has_key("secret_token") and self.account.has_key("username") and has_secret_key: self.ui.get_object("hbox_statusnet_auth").hide() self.ui.get_object("statusnet_auth_done_label").set_label(_("%s has been authorized by %s") % (self.account["username"])) self.ui.get_object("hbox_statusnet_auth_done").show() else: self.ui.get_object("hbox_statusnet_auth_done").hide() if self.dialog.ui: self.dialog.ui.get_object('vbox_create').hide() except: self.ui.get_object("hbox_statusnet_auth_done").hide() if self.dialog.ui: self.dialog.ui.get_object("vbox_create").hide()
def password(self): n = self._password if n is None: if gtkpresence: try: keyring = gnomekeyring.get_default_keyring_sync() keyring_info = gnomekeyring.get_info_sync(keyring) if keyring_info.get_is_locked(): nof_tries = 3 for i in range(nof_tries): keyring_pass = getpass("Enter password to unlock your default keychain: ") try: gnomekeyring.unlock_sync(keyring, keyring_pass) break except gnomekeyring.DeniedError: if i + 1 == nof_tries: sys.stderr.write("\nFailed to unlock keychain (%s times)\n" % (i + 1)) else: sys.stderr.write("\nInvalid password, try again...\n") items = gnomekeyring.find_items_sync( gnomekeyring.ITEM_NETWORK_PASSWORD, {"server": self.server, "protocol": "ftp", "user": self.username}, ) if len(items) > 0: n = items[0].secret except gnomekeyring.DeniedError: sys.stderr.write("\nGnome keyring error : Access denied ..\n") except gnomekeyring.NoMatchError: sys.stderr.write("\nGnome keyring error : No credential for %s..\n" % self.server) except Exception, msg: sys.stderr.write("\nGnome keyring error : %s\n" % (msg)) sys.stderr.flush() if n is None: n = getpass("Enter password for ftp://%s@%s: " % (self.username, self.server)) self._password = n
def connect(self): try: auth = netrc().authenticators(self.host) # TODO check if the host exists in netrc except IOError as msgio: if gtkpresence: try: keyring = gnomekeyring.get_default_keyring_sync() keyring_info = gnomekeyring.get_info_sync(keyring) if keyring_info.get_is_locked(): keyring_pass = getpass('Enter password to unlock your ' 'keychain [%s]: ' % (keyring)) try: gnomekeyring.unlock_sync(keyring, keyring_pass) except Exception as msg: sys.stderr.write("\nUnable to unlock your " "keychain: %s\n" % msg) else: _log().debug("+ [%s] unlocked." % keyring) itempass = gnomekeyring.ITEM_NETWORK_PASSWORD pars = { "server": self.host, "protocol": "ftp", "user": self.user } items = gnomekeyring.find_items_sync( itempass, pars) if len(items) > 0: ftp = ftplib.FTP(self.host, self.user, items[0].secret) else: raise Exception('gnomekeyring', 'NoMatchError') except gnomekeyring.DeniedError: sys.stderr.write("\nGnome keyring error : " "Access denied ..\n" "netrc error: %s\n" % (msgio)) sys.exit(1) except gnomekeyring.NoMatchError: sys.stderr.write("\nGnome keyring error : " "No credential for %s..\n" "netrc error: %s\n" % (self.host, msgio)) sys.exit(1) except Exception as msg: sys.stderr.write("\nGnome keyring error : %s\n" "netrc error: %s\n" % (msg, msgio)) sys.exit(1) else: assert self.user == auth[0] ftp = ftplib.FTP() ftp.connect(self.host, self.port) ftp.login(auth[0], auth[2]) try: ftp.cwd(self.path) except ftplib.error_perm: ftp.mkd(self.path) ftp.cwd(self.path) self.ftp = ftp self.dirs = set()
def query(self): ''' Match keyring items from keyring. Return True if something was matched, False otherwise. ''' results = [] try: if self.id: info = gk.item_get_info_sync(self.keyring, self.id) attr = gk.item_get_attributes_sync(self.keyring, self.id) result = {'id': self.id, 'secret': info.get_secret(), 'name': info.get_display_name(), 'attr': attr} results.append(result) else: matches = gk.find_items_sync(self.item_type, self.params) for match in matches: result = {'id': match.item_id, 'secret': match.secret, 'attr': match.attributes} info = gk.item_get_info_sync(self.keyring, match.item_id) result['name'] = info.get_display_name() # filter by name if desired if not self.name or self.name == result['name']: results.append(result) except gk.Error: pass if not results: return False for index, result in enumerate(results): if index > 0: print for index2, tab in enumerate(self.output): if index2 > 0: sys.stdout.write('\t') if self.output_attribute_names: sys.stdout.write(tab + '=') out = None if tab == 'id': out = result['id'] elif tab == 'secret': out = result['secret'] elif tab == 'name': out = result['name'] elif tab in result['attr']: out = result['attr'][tab] if out: sys.stdout.write(str(out)) if not self.no_newline: print return True
def clear_cc_details(): print "clearing CC details" try: ids = gnomekeyring.find_items_sync (gnomekeyring.ITEM_GENERIC_SECRET, keyring_attributes) gnomekeyring.item_delete_sync (keyring, id[0]) except Exception, e: print e
def get_cc_details(): print "getting CC details" try: ids = gnomekeyring.find_items_sync (gnomekeyring.ITEM_GENERIC_SECRET, keyring_attributes) data = ids[0].secret return string.split(data, "\n") except Exception, e: print e
def get_password(self, user): attrs = { "server": self._server, "protocol": self._protocol, "user": user } items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) return items[0].secret
def get_password(self, volume): params = dict(appname = "truecrypt-control", volume = volume.encode('ascii','replace')) try: matches = gnomekeyring.find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET, params) return matches[0].secret except gnomekeyring.NoMatchError: print "password not found" return None
def has_credentials(self): try: attrs = {"server": self._server} items = gkey.find_items_sync(self._type, attrs) return len(items) > 0 except gkey.DeniedError: return False except gkey.NoMatchError: return False
def delete_credentials(self): attrs = { "server": self._server, "protocol": self._protocol, "user": self._user } items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) id = items[0].item_id gkey.item_delete_sync(gkey.get_default_keyring_sync(), id)
def delete_credentials(self, user, pw=None): attrs = { "user":user, "server":self._server, "protocol":self._protocol, } items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) for item in items: gkey.item_delete_sync(None, item.item_id)
def get_credentials(self, server, protocol=None): try: attrs = {"server": server} if protocol: attrs["protocol"] = protocol items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) return (items[0].attributes["user"], items[0].secret) except gkey.NoMatchError: return None
def get_password(): """Look up the account's IMAP password from the Gnome Keyring.""" return gkey.find_items_sync( gkey.ITEM_NETWORK_PASSWORD, { "protocol": "imap", "server": "mail.messagingengine.com", "user": "******" } )[0].secret
def get_credentials(self, user): attrs = {"server": self._server, "protocol": self._protocol} try: items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) for item in items: if item.attributes["user"] == user: return item.secret except gkey.NoMatchError: pass return None
def search_key(self,query): """ Search for a key into the keyrings using query parameters """ try: result_list = gk.find_items_sync(gk.ITEM_GENERIC_SECRET, query) except gk.NoMatchError: return None return result_list
def get_secret(id): value = "" try: value = gnomekeyring.find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET, {"id": str(id)})[0].secret #mlock(value) except gnomekeyring.NoMatchError: print id raise exceptions.GwibberServiceError("keyring") return value
def get_password(username, server): attrs = { 'user':username, 'server':server, 'protocol':'imap' } items = gkey.find_items_sync( gkey.ITEM_NETWORK_PASSWORD, attrs ) return items[0].secret
def getPassword(self, user): attrs = { "server": self._server, 'protocol': self._protocol, 'user': str(user) } try: items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) if items != []: return items[0].secret return False except: return False
def get_secret(id): value = "" try: value = gnomekeyring.find_items_sync( gnomekeyring.ITEM_GENERIC_SECRET, {"id": str(id)})[0].secret #mlock(value) except gnomekeyring.NoMatchError: print id raise exceptions.GwibberServiceError("keyring") return value
def get_credentials(self): """ @return: A tuple C{(user, password)} or throws an exception if the credentials for the account are not known """ attrs = {"server": self._host, "protocol": self._protocol} items = gnomekeyring.find_items_sync(gnomekeyring.ITEM_NETWORK_PASSWORD, attrs) if (len(items) > 1): LOGGER.warn ("More than one account found for %s" % self._host) return (items[0].attributes["user"], items[0].secret)
def _GetDataFromKeyring(self): """Get authname and password from GNOME keyring""" authname = "" password = "" try: items = gk.find_items_sync(gk.ITEM_NETWORK_PASSWORD, self._gkAttr) authname = items[0].attributes["user"] password = items[0].secret except gk.NoMatchError: pass return [authname, password]
def deletePassword(self, user): attrs = { "server": self._server, 'protocol': self._protocol, 'user': str(user) } try: items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) except: return for item in items: gkey.item_delete_sync(item.keyring, item.item_id)
def getpass(self): try: result_list = gnomekeyring.find_items_sync( gnomekeyring.ITEM_GENERIC_SECRET, dict(appname=APP_NAME)) except gnomekeyring.NoMatchError: # Create new credentials if nothing was found self.newpass() except BaseException as e: # Todo: add some logging pass else: self.login, self.password = result_list[0].secret.split('\n') return self.login, self.password
def from_gnomekeyring(self): # Try for gtk gui specific credentials. try: items = gnomekeyring.find_items_sync( gnomekeyring.ITEM_GENERIC_SECRET, { "aws-host": "aws.amazon.com", }) except (gnomekeyring.NoMatchError, gnomekeyring.DeniedError): self.show_a_password_dialog() return None else: key_id, secret_key = items[0].secret.split(":") return AWSCredentials(access_key=key_id, secret_key=secret_key)
def get_password_from_keyring(self, datasource): """Retrieve password from keyring and set it to datasource.""" if not USE_KEYRING or datasource.url.password: return item_type = gnomekeyring.ITEM_GENERIC_SECRET attrs = {"crunchyfrog": datasource.id} try: entry = gnomekeyring.find_items_sync(item_type, attrs) entry = entry[0] except gnomekeyring.NoMatchError: entry = None if entry is not None: datasource.url.password = entry.secret
def get_credentials(self, acc): self.lock.acquire() try: logger.debug("Getting credentials with gnome keyring for account %s" % (acc.get_name())) attrs = {"account_name": acc.get_name()} try: items = gk.find_items_sync(gk.ITEM_NETWORK_PASSWORD, attrs) except gk.NoMatchError, e: items = list() if len(items) < 1: raise KeyringException("Cannot find the keyring data for the account %s" % (acc.get_name())) logger.debug("items ok") return Credentials (items[0].attributes["username"], items[0].secret)
def get_item_id(): global _item_id if _item_id: return _item_id try: results = gk.find_items_sync(gk.ITEM_GENERIC_SECRET, _attrs) _item_id = results[0].item_id except gk.NoMatchError: # Create item _item_id = gk.item_create_sync(_keyring, _type, _display_name, _attrs, '', True) return _item_id
def hasPassword(self, user): try: attrs = { "server": self._server, 'protocol': self._protocol, 'user': str(user) } items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) if items != []: return True return False #print items[0].attributes['user'] except gkey.DeniedError: return False except gkey.NoMatchError: return False
def get_item_id(): global _item_id if _item_id: return _item_id try: results = gk.find_items_sync(gk.ITEM_GENERIC_SECRET, _attrs) _item_id = results[0].item_id except gk.NoMatchError: # Check if ''_keyring'' has been created. if _keyring not in gk.list_keyring_names_sync(): # if it is missing then create a new keyring called ''_keyring'' gk.create_sync(_keyring, _keyring) # Create item _item_id = gk.item_create_sync(_keyring, _type, _display_name, _attrs, '', True) return _item_id
def __init__(self, account=None, dialog=None): """Creates the account pane for configuring facebook accounts""" gtk.VBox.__init__(self, False, 20) self.ui = gtk.Builder() self.ui.set_translation_domain("gwibber") self.ui.add_from_file( gwibber.resources.get_ui_asset("gwibber-accounts-facebook.ui")) self.ui.connect_signals(self) self.vbox_settings = self.ui.get_object("vbox_settings") self.pack_start(self.vbox_settings, False, False) self.show_all() if account: self.account = account else: self.account = {} self.dialog = dialog has_secret_key = True if self.account.has_key("id"): try: value = gnomekeyring.find_items_sync( gnomekeyring.ITEM_GENERIC_SECRET, {"id": str("%s/%s" % (self.account["id"], "secret_key"))})[0].secret except gnomekeyring.NoMatchError: has_secret_key = False try: if self.account["session_key"] and self.account[ "secret_key"] and self.account[ "username"] and has_secret_key: self.ui.get_object("hbox_facebook_auth").hide() self.ui.get_object("fb_auth_done_label").set_label( _("%s has been authorized by Facebook") % str(self.account["username"])) self.ui.get_object("hbox_facebook_auth_done").show() else: self.ui.get_object("hbox_facebook_auth_done").hide() self.ui.get_object("facebook_auth_button").modify_bg( gtk.STATE_NORMAL, gtk.gdk.color_parse("red")) if self.dialog: self.dialog.get_object('vbox_create').hide() except: self.ui.get_object("hbox_facebook_auth_done").hide() if self.dialog: self.dialog.get_object("vbox_create").hide()
def get_keychain_pass(account=None, server=None): if sys.platform == 'darwin': command = 'sudo -u ' + user + \ ' /usr/bin/security -v find-internet-password -g -a ' + account +\ ' -s ' + server + ' ' + home + '/Library/Keychains/login.keychain' output = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT) outtext = [l for l in output.splitlines() if l.startswith('password: '******'password: "******"', outtext).group(1) elif sys.platform == 'linux2': attrs = {'server': server, 'protocol': 'http'} items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) return (items[0].attributes['user'], items[0].secret)[1] else: raise Exception('Platform "' + sys.platform + '" not supported.')
def LoginDetails(self, warning=False): """ Displays the account details dialog. Parameters: warning -- True if the validation failed and the user must be informed. """ xmlString = pkg_resources.resource_string(__name__, "LoginDialog.ui") gtkBuilder = gtk.Builder() gtkBuilder.add_from_string(xmlString) signals = { "on_buttonOK_clicked": self.OnAcceptDetails, "on_buttonCancel_clicked": self.OnCancelDetails } gtkBuilder.connect_signals(signals) self.entryUsername = gtkBuilder.get_object("entryUsername") self.entryPassword = gtkBuilder.get_object("entryPassword") self.labelWarning = gtkBuilder.get_object("labelWarning") self.buttonOK = gtkBuilder.get_object("buttonOK") self.loginWindow = gtkBuilder.get_object("LoginDetailsDialog") self.entryUsername.set_activates_default(True) self.entryPassword.set_activates_default(True) self.buttonOK.set_flags(gtk.CAN_DEFAULT) self.buttonOK.grab_default() self.api.set_window_icon(self.loginWindow) # set the entry text to the saved values username = self.api.get_config_value("fsUsername") if username is not None and keyring: password = None try: items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, {"username": username}) if len(items) > 0: password = items[0].secret except gkey.DeniedError, gkey.NoMatchError: pass
def get_from_keyring(self, acctid, name): item = {"id": str("%s/%s" % (acctid, name))} try: return gnomekeyring.find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET, item)[0].secret except gnomekeyring.NoMatchError: return None
def query(self): ''' Match keyring items from keyring. Return True if something was matched, False otherwise. ''' results = [] try: if self.id: info = gk.item_get_info_sync(self.keyring, self.id) attr = gk.item_get_attributes_sync(self.keyring, self.id) result = { 'id': self.id, 'secret': info.get_secret(), 'name': info.get_display_name(), 'attr': attr } results.append(result) else: matches = gk.find_items_sync(self.item_type, self.params) for match in matches: if match.keyring != self.keyring: continue result = { 'id': match.item_id, 'secret': match.secret, 'attr': match.attributes } info = gk.item_get_info_sync(match.keyring, match.item_id) result['name'] = info.get_display_name() # filter by name if desired if not self.name or self.name == result['name']: results.append(result) except gk.Error as e: print >> sys.stderr, e.__class__.__name__, e.message pass if not results: return False for index, result in enumerate(results): if index > 0: print for index2, tab in enumerate(self.output): if index2 > 0: sys.stdout.write('\t') if self.output_attribute_names: sys.stdout.write(tab + '=') out = None if tab == 'id': out = result['id'] elif tab == 'secret': out = result['secret'] elif tab == 'name': out = result['name'] elif tab in result['attr']: out = result['attr'][tab] if out: sys.stdout.write(str(out)) if not self.no_newline: print return True
def get_refresh_token(repo): # modified from # https://jason.the-graham.com/2011/01/16/gnome_keyring_with_msmtp_imapfilter_offlineimap/ attrs = {"repo": repo} items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) return (items[0].attributes["user"], items[0].secret)
def get_credentials(repo): keyring = gkey.get_default_keyring_sync() attrs = {"repo": repo} items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs) return (items[0].attributes["user"], items[0].secret)