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 trigger_unlock(): gk.item_create_sync(KEYRING, gk.ITEM_GENERIC_SECRET, "dummy",{"dummy":"dummy"}, "dummy", True) item_keys = gk.list_item_ids_sync(KEYRING) for key in item_keys: item_info = gk.item_get_info_sync(KEYRING, key) if item_info.get_display_name() == "dummy": item_info = gk.item_delete_sync(KEYRING, key)
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 set_credentials_msmtp(self,user,pw): # display name for password. display_name = '%s password for %s at %s' % ("MSMTP", user, self._server) usr_attrs = {'user':user, 'server':_server, 'protocol':smtp} # Now it gets ready to add into the keyring. Do it. # Its id will be returned if success or an exception will be raised gkey.item_create_sync(gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, display_name, attrs, pw, False)
def FinishLogin(self, username, password): """ Attempts to login in to confirm the given credentials. If successful, the username is written to a local file for subsequent use and the password is saved in the user's keyring (if available, or a local file otherwise). The GUI calls are done using gobject.idle_add() to assure they're within the main gtk thread. """ self.freeSound.Login(username, password) if self.freeSound.loggedIn: self.api.set_config_value("fsUsername", username) if keyring: gkey.item_create_sync(gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, EXTENSION_DATA_NAME, {"username": username}, password, True) else: self.api.set_config_value("fsPassword", password) gobject.idle_add(self.loginWindow.destroy) if self.showSearch: self.showSearch = False gobject.idle_add(self.OnMenuItemClick) else: gobject.idle_add(self.loginWindow.destroy) if self.retryLogin: gobject.idle_add(self.LoginDetails, _("Login failed!"))
def set_password(plugin_id, username, password): kr_name = gnomekeyring.get_default_keyring_sync() attrs = {'username': username, 'plugin_id': plugin_id} gnomekeyring.item_create_sync( kr_name, gnomekeyring.ITEM_GENERIC_SECRET, _("Password for %s in %s (Kupfer)") % (username, plugin_id), attrs, password, True)
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 FinishLogin(self, username, password): """ Attempts to login in to confirm the given credentials. If successful, the username is written to a local file for subsequent use and the password is saved in the user's keyring (if available, or a local file otherwise). The GUI calls are done using gobject.idle_add() to assure they're within the main gtk thread. """ self.freeSound.Login(username, password) if self.freeSound.loggedIn: self.api.set_config_value("fsUsername", username) if keyring: gkey.item_create_sync(gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, EXTENSION_DATA_NAME, {"username" : username}, password, True) else: self.api.set_config_value("fsPassword", password) gobject.idle_add(self.loginWindow.destroy) if self.showSearch: self.showSearch = False gobject.idle_add(self.OnMenuItemClick) else: gobject.idle_add(self.loginWindow.destroy) if self.retryLogin: gobject.idle_add(self.LoginDetails, _("Login failed!"))
def add_user(self, username, password, uri, labels=None, timeout=None): atts = {'uri': uri, 'labels': labels, 'timeout': timeout} key,item = self.search_user(username) if item is not None: self.delete_user(key=key) gk.item_create_sync(self._app_name, gk.ITEM_GENERIC_SECRET, username, \ atts, password, True)
def set_credentials(self, user, pw): attrs = { "user": user, "server": self._server, "protocol": self._protocol, } gkey.item_create_sync(gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, self._name, attrs, pw, True)
def entry_passwd_to_keyrings(keyring_name,servername,username,passwd): atts = { 'application' : 'Python mail notification', 'username' : username, 'server' : servername, } gk.item_create_sync(keyring_name, gk.ITEM_GENERIC_SECRET, servername,atts,passwd,True)
def create_sync(self, server_info): gk.item_create_sync( 'GKApp', gk.ITEM_NETWORK_PASSWORD, server_info["user"] + "@" + server_info["host"] + ":" + server_info["port"], # This is the description and a unique identifier of the keyring item server_info.pop("pass"), # This is the complete information about the stored connection without the password server_info["pass"], # This is the password of the stored connection True) # update if exists with same description and attributes
def set_password(plugin_id, username, password): kr_name = gnomekeyring.get_default_keyring_sync() attrs = {'username': username, 'plugin_id': plugin_id} gnomekeyring.item_create_sync(kr_name, gnomekeyring.ITEM_GENERIC_SECRET, _("Password for %s in %s (Kupfer)") % (username, plugin_id), attrs, password, True)
def set_credentials(self, user, pw, key=""): attrs = { "user": user, "server": self._host, "protocol": self._protocol, "key": key, } gnomekeyring.item_create_sync(gnomekeyring.get_default_keyring_sync(), gnomekeyring.ITEM_NETWORK_PASSWORD, self._realm, attrs, pw, True)
def set_credentials(self, user, pw): # Ensure the arguments are simple strings; it can't handle unicode. user, pw = str(user), str(pw) if self.has_credentials() and self.get_credentials() == (user, pw): return attrs = {"user": user, "server": self._server} gkey.item_create_sync(gkey.get_default_keyring_sync(), self._type, self._name, attrs, pw, True)
def set_password(self, pw): attrs = { "user": self._user, "server": self._server, "protocol": self._protocol, } gkey.item_create_sync(gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, self._name, attrs, pw, True)
def set_credentials(self, username, password, server, email_address=None): self._clear() print "Inserting new entry..." attrs = {"key": self._key, "user": username, "server": server, "protocol": self._protocol} if email_address: attrs["email_address"] = email_address gkey.item_create_sync( gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, self._owner, attrs, password, True )
def store_secret(keyring, item_name, secret): # The last 3 params are: attributes, secret, update_if_exists. # from the docs: "update_if_exists: If true, then another item matching # the type, and attributes will be updated instead of creating a new item." # So we either store unique attributes with each, or set update_if_exists # to False. # If we do both, additional keys with the same name and different IDs # will get created. gnomekeyring.item_create_sync(keyring, gnomekeyring.ITEM_GENERIC_SECRET, item_name, {'name': item_name}, secret, True)
def save(self): if keyring == 'gk': try: gk.item_create_sync('pycle', gk.ITEM_GENERIC_SECRET, self.name, {'username': self.username, 'sid': self.sid}, self.password, True) except AttributeError: gk.item_create_sync('pycle', gk.ITEM_GENERIC_SECRET, self.name, {'username': self.username, 'host': self.host}, self.password, True) elif keyring == 'kk': pass elif keyring == 'xk': pass
def set_credentials(repo, user, pw): KEYRING_NAME = "offlineimap" if isinstance(repo, list): repo = repo[0] if isinstance(user, list): user = user[0] attrs = { "repo": repo, "user": user } keyring = gkey.get_default_keyring_sync() print "Set password in keyring [{}] using {}"\ .format(KEYRING_NAME, attrs) gkey.item_create_sync(keyring, gkey.ITEM_NETWORK_PASSWORD, KEYRING_NAME, attrs, pw, True)
def set_keychain_pass(protocol, server, user, password): if sys.platform != 'linux2': raise Exception('Only Linux is supported for setting passwords.') attrs = {'user': user, 'server': server, 'protocol': protocol} name = 'offlineimap ' + server gkey.item_create_sync(gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, name, attrs, password, True)
def set_credentials(repo, user, pw): KEYRING_NAME = "offlineimap" if isinstance(repo, list): repo = repo[0] if isinstance(user, list): user = user[0] attrs = {"repo": repo, "user": user} keyring = gkey.get_default_keyring_sync() print "Set password in keyring [{}] using {}"\ .format(KEYRING_NAME, attrs) gkey.item_create_sync(keyring, gkey.ITEM_NETWORK_PASSWORD, KEYRING_NAME, attrs, pw, True)
def set_password(self, service, username, password): """Set password for the username of the service """ try: gnomekeyring.item_create_sync( self.KEYRING_NAME, gnomekeyring.ITEM_NETWORK_PASSWORD, "Password for '%s' on '%s'" % (username, service), {'user': username, 'domain': service}, password, True) except gnomekeyring.CancelledError: # The user pressed "Cancel" when prompted to unlock their keyring. raise PasswordSetError("cancelled by user")
def cmd_export_to_gnome_keyring(): """Write out accounts to Gnome Keyring. Only useful for 'backup', if you have keyring tools. There is currently no way to import these keys back into kip. Requires python2 and gnomekeyring lib. Note that this does NOT make the passwords usable to Chrome - this is not a counterpart to import_chrome_gnome_keyring. """ import time import gnomekeyring as gk import glib glib.set_application_name('kip') keyrings = gk.list_keyring_names_sync() if not 'kip' in keyrings: gk.create_sync('kip', None) # None means prompt user for password for filename in glob.glob('{}/*'.format(HOME_PWD)): user, pwd, notes = extract(filename) domain = os.path.basename(filename) print("Exporting {} ({})".format(domain, user)) """ msg = "Export %s (%s)? [y|N]" % (domain, user) try: choice = raw_input(msg) except NameError: # python 3 choice = input(msg) if choice.lower() != 'y': print('Skipping') continue """ attributes = { "username": user.encode("utf8"), "notes": notes.encode("utf8"), "date_created": str(int(time.time())), } gk.item_create_sync('kip', gk.ITEM_GENERIC_SECRET, domain, attributes, pwd.encode("utf8"), True)
def set_password(self, service, username, password): """Set password for the username of the service """ try: gnomekeyring.item_create_sync( self.KEYRING_NAME, gnomekeyring.ITEM_NETWORK_PASSWORD, "Password for '%s' on '%s'" % (username, service), { 'user': username, 'domain': service }, password, True) except gnomekeyring.CancelledError: # The user pressed "Cancel" when prompted to unlock their keyring. raise PasswordSetError("cancelled by user")
def set_details(self, usr, pwd): """ Set the account details with a username and password """ try: item = self.__get_item() if item is not None: self.__set_usr(usr, item) self.__set_pwd(pwd, item) else: attrs = {"username" : str(usr)} gk.item_create_sync(self.NAME, self.TYPE, self.ITEM, attrs, pwd, True) except self.GK_EXCEPT as e: raise AccountError(repr(e))
def set_credentials(self, user, password): """ Set a key. """ attrs = { "user": user, "server": self._server, "protocol": self._protocol, } gkey.item_create_sync( gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, "%s://%s@%s" % (attrs["protocol"], attrs["user"], attrs["server"]), attrs, password, True)
def import_keyrings(file_p, file_name): keyrings = json.loads(file_p.read()) for keyring_name, keyring_items in keyrings.items(): try: existing_ids = gnomekeyring.list_item_ids_sync(keyring_name) except gnomekeyring.NoSuchKeyringError: sys.stderr.write( "No keyring '%s' found. Please create this keyring first" % keyring_name) sys.exit(1) existing_items = [get_item(keyring_name, id) for id in existing_ids] existing_items = [i for i in existing_items if i is not None] for item in keyring_items: if any(items_roughly_equal(item, i) for i in existing_items): print "Skipping %s because it already exists" % item[ 'display_name'] else: nearly = [ i for i in existing_items if items_roughly_equal(i, item, ignore_secret=True) ] if nearly: print "Existing secrets found for '%s'" % item[ 'display_name'] for i in nearly: print " " + i['secret'] print "So skipping value from '%s':" % file_name print " " + item['secret'] else: schema = item['attributes']['xdg:schema'] item_type = None if schema == u'org.freedesktop.Secret.Generic': item_type = gnomekeyring.ITEM_GENERIC_SECRET elif schema == u'org.gnome.keyring.Note': item_type = gnomekeyring.ITEM_NOTE elif schema == u'org.gnome.keyring.NetworkPassword': item_type = gnomekeyring.ITEM_NETWORK_PASSWORD if item_type is not None: gnomekeyring.item_create_sync( keyring_name, item_type, item['display_name'], fix_attributes(item['attributes']), item['secret'], False) print "Copying secret %s" % item['display_name'] else: print "Can't handle secret '%s' of type '%s', skipping" % ( item['display_name'], schema)
def set_password(self, key, password, _folder = None): if not G.is_available() : self.prnt.Parent.eventNotification("%s not available." % self.name) return None folder = to_unicode(_folder) if _folder else self.appletName try: G.item_create_sync( self.KEYRING_NAME, G.ITEM_NETWORK_PASSWORD, "Password for '%s' in '%s'" % (to_unicode(key), folder), {'user': to_unicode(key), 'domain': folder}, to_unicode(password), True) except G.CancelledError: raise PasswordSetError("cancelled by user") finally : pass
def set_password(username, server, password): attrs = { 'user':username, 'server':server, 'protocol':'imap' } gkey.item_create_sync( gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, 'Mail-Password %s' % server, attrs, password, True )
def __storeAuthInfo(id, login, passwd): """ Store the login/password associated with id, either in the Gnome keyring or in the prefs """ try: import gnomekeyring as gk useGK = True except: useGK = False # No Gnome keyring if not useGK: prefs.set(__name__, id + '_login', login) prefs.set(__name__, id + '_passwd', b64encode(passwd)) # Pretty useless, but the user prefers not to see his password as clear text return # From here we can use the Gnome keyring __loadKeyring() try: label = '%s (%s)' % (consts.appName, id) authInfo = '\n'.join((login, passwd)) token = gk.item_create_sync(__keyring, gk.ITEM_GENERIC_SECRET, label, {'appName': consts.appName, 'id': id}, authInfo, True) prefs.set(__name__, id + '_gkToken', token) except: pass
class Keyring(object): # # Original author: http://www.rittau.org/blog/20070726-01 # Original code: http://www.rittau.org/gnome/python/keyring.py # def __init__(self, name, server, protocol): self._name = name self._server = server self._protocol = protocol self._keyring = gkey.get_default_keyring_sync() 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 get_credentials(self): 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 set_credentials(self, (user, pw)): attrs = { "user": user, "server": self._server, "protocol": self._protocol, } gkey.item_create_sync(gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, self._name, attrs, pw, True)
def _get_item(self, keyring, login, create=False): login_key = self._key_for_login(keyring, login) try: item_keys = gnomekeyring.list_item_ids_sync("Login") except gnomekeyring.NoSuchKeyringError: if create: password = self._get_keychain_password() if password is not None: gnomekeyring.create_sync("Login", password) item_keys = [] else: return None, None else: return None, None for key in item_keys: item_info = gnomekeyring.item_get_info_sync("Login", key) if item_info.get_display_name() == login_key: return item_info, key if not create: return None, None item_key = gnomekeyring.item_create_sync( "Login", gnomekeyring.ITEM_GENERIC_SECRET, login_key, {}, str(uuid.uuid4()), True) item = gnomekeyring.item_get_info_sync("Login", item_key) return item, item_key
def put_in_keyring(self, acctid, name, value): id = "%s/%s" % (acctid, name) return gnomekeyring.item_create_sync( gnomekeyring.get_default_keyring_sync(), gnomekeyring.ITEM_GENERIC_SECRET, "Gwibber preference: %s" % id, {"id": str(id)}, str(value), True)
def _get_item(self, keyring, login, create=False): login_key = self._key_for_login(keyring, login) try: item_keys = gnomekeyring.list_item_ids_sync("Login") except gnomekeyring.NoSuchKeyringError: if create: password = self._get_keychain_password() if password is not None: gnomekeyring.create_sync("Login", password) item_keys = [] else: return None, None else: return None, None for key in item_keys: item_info = gnomekeyring.item_get_info_sync("Login", key) if item_info.get_display_name() == login_key: return item_info, key if not create: return None, None item_key = gnomekeyring.item_create_sync( "Login", gnomekeyring.ITEM_GENERIC_SECRET, login_key, {}, str(uuid.uuid4()), True ) item = gnomekeyring.item_get_info_sync("Login", item_key) return item, item_key
def put_pass(self, username, password, server): keyring_type = gk.ITEM_NETWORK_PASSWORD display_name = '%s password for %s at %s' % (self.app.upper(), username, server) usr_attrs = {'user': username, 'server': server, 'protocol': self.protocol} id = gk.item_create_sync(self.keyring, keyring_type, display_name, usr_attrs, password, False) return id is not None
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 _set_password_to_keyring(self): if self.username == "": return False keyring = gnomekeyring.get_default_keyring_sync() display_name = "HTTP secret for %s at twitter.com" % (self.username) type = gnomekeyring.ITEM_NETWORK_PASSWORD # just a utility function to create attrs easily. def parse(s): ret = {} try: ret = dict([(k, v) for k, v in [x.split(":") for x in s.split(",")] if k and v]) except ValueError: pass return ret # create attrs :: {} (dict) attrs = { "user": None, "domain": None, "server": None, "object": None, "protocol": None, "authtype": None, "port": None, } usr_attrs = parse("server:twitter.com,user:%s,protocol:http" % (self.username)) attrs.update(usr_attrs) try: id = gnomekeyring.item_create_sync(keyring, type, display_name, usr_attrs, self.password, True) except gnomekeyring.Error, e: return False
class Keyring(object): def __init__(self, name, server, protocol): self._name = name self._server = server self._protocol = protocol self._keyring = 'imap' 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 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 set_credentials(self, (user, pw)): attrs = { "user": user, "server": self._server, "protocol": self._protocol, } gkey.item_create_sync(self._keyring, gkey.ITEM_NETWORK_PASSWORD, self._name, attrs, pw, True)
def set_password(self, key_name, user, password): return gnomekeyring.item_create_sync(self.keyring_name, gnomekeyring.ITEM_GENERIC_SECRET, key_name, { "user": user, "key_name": key_name }, password, True)
def get_login_password(): """ Retrieve credentials from Gnome Keyring """ # From python-gnomekeyring examples keyring = gnomekeyring.get_default_keyring_sync() auth_token = gconf.client_get_default().get_int(GCONF_AUTH_KEY) if auth_token > 0: try: secret = gnomekeyring.item_get_info_sync(keyring, auth_token).get_secret() except gnomekeyring.DeniedError: login = None password = None auth_token = 0 else: login, password = secret.split('\n') else: login = None password = None login, password = password_dialog(login, password) # Save new login and password to gnome keyring auth_token = gnomekeyring.item_create_sync( keyring, gnomekeyring.ITEM_GENERIC_SECRET, "TV-kaista subtitles downloader", dict(appname="tv-kaista-subs-py, subtitles downloader"), "\n".join((login, password)), True) gconf.client_get_default().set_int(GCONF_AUTH_KEY, auth_token) return login, password
class Keyring(object): def __init__(self, name, server, protocol): #instead of server we use mail for offlineimap self._name = name self._server = server self._protocol = protocol self._keyring = gkey.get_default_keyring_sync() 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 get_credentials(self): 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 set_credentials(self, (user, pw)): def set_credentials(self, (user, pw)): attrs = { "user": user, "server": self._server, "protocol": self._protocol, } gkey.item_create_sync(gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, self._name, attrs, pw, True)
def store_login(self, kind, username, url, password): if not password: self.remove_logins(kind, username, url) return _logger.debug("storing login (%s, %s, %s)" % (kind, username, url)) if not self.is_available(): found = None for ki in self.__fallback_items: if ki.get_kind() == kind and \ ki.get_username() == username and \ ki.get_url() == url: found = ki if found: found.set_password(password) else: ki = KeyringItem(kind=kind, username=username, url=url, password=password) self.__fallback_items.add(ki) else: keyring_item_id = gnomekeyring.item_create_sync('session', gnomekeyring.ITEM_GENERIC_SECRET, "BigBoard", dict(appname="BigBoard", kind=kind, username=username, url=url), password, True)
def imei_cb(imei): gconf_key = "/apps/%s/%s/keyring_auth_token" % (slug, imei) auth_token = gnomekeyring.item_create_sync( self.keyring, gnomekeyring.ITEM_GENERIC_SECRET, "%s secrets!" % APP_LONG_NAME, dict(appname=APP_LONG_NAME), str(pin), True) gconf.client_get_default().set_int(gconf_key, auth_token) return auth_token
def set_password_in_gnome_keyring(user, server, protocol): print 'It looks like this is the first time you run %s' % get_app() print 'with the user "%s" at server "%s" using protocol "%s"' % ( user, server, protocol) password_match = False while not password_match: password1 = getpass.getpass('Enter password: '******'Enter password again: ') password_match = password1 == password2 if not password_match: print 'Passwords do not match. Please, enter them again' keyring = gnomekeyring.get_default_keyring_sync() display_name = '%s password for %s at %s' % (get_app(), user, server) attrs = {'user': user, 'server': server, 'protocol': protocol} gnomekeyring.item_create_sync(keyring, gnomekeyring.ITEM_NETWORK_PASSWORD, display_name, attrs, password1, False) return password1
def add_item(user, password, server, protocol): description = '%s password for %s at %s' % (protocol, user, server) type = gkey.ITEM_NETWORK_PASSWORD usr_attrs = {'user' : user, 'server' : server, 'protocol' : protocol} id = gkey.item_create_sync(keyring, type, description, usr_attrs, password, False) return id is not None
def store_password(self, entry, password, attributes=None, entry_type=EntryType.GENERIC): """Create new entry in keyring with specified data""" assert self.is_available() # create a new keyring if it doesn't exist if not self.KEYRING_NAME in keyring.list_keyring_names_sync(): dialog = PasswordDialog(self._application) dialog.set_title(_('New keyring')) dialog.set_label( _('We need to create a new keyring to safely ' 'store your passwords. Choose the password you ' 'want to use for it.')) response = dialog.get_response() if response[0] == gtk.RESPONSE_OK \ and response[1] == response[2]: # create new keyring keyring.create_sync(self.KEYRING_NAME, response[1]) self.__update_info() else: # wrong password raise KeyringCreateError('No keyring to store password to.') # if keyring is locked, try to unlock it if self.is_locked() and not self.__unlock_keyring(): return False # store password to existing keyring keyring.item_create_sync( self.KEYRING_NAME, self.KEYRING_TYPE[entry_type], entry, attributes if attributes is not None else {}, password, True # update if exists ) return True
def save_key(self, response_id, data): try: if data != gtk.RESPONSE_ACCEPT: # User cancelled. They can ask for the password again somehow. return content = self.password_dialog.get_content_area() key_id = content.get_children()[0].get_children()[1].get_text() secret_key = content.get_children()[1].get_children()[1].get_text() creds = AWSCredentials(access_key=key_id, secret_key=secret_key) self.create_client(creds) gnomekeyring.item_create_sync(None, gnomekeyring.ITEM_GENERIC_SECRET, "AWS access credentials", {"aws-host": "aws.amazon.com"}, "%s:%s" % (key_id, secret_key), True) finally: self.password_dialog.hide() # XXX? Does this leak? self.password_dialog = None
def on_export(self, value): """Export the given tuple/list containing a username and a password. The function stores the password in the gnomekeyring and returns a string in form 'username:auth_token'.""" # store password in storage attribs = dict(name=value[0]) auth_token = gnomekeyring.item_create_sync(self.keyring, gnomekeyring.ITEM_GENERIC_SECRET, value[0], attribs, value[1], True) # build value from username and auth_token return value[0] + ':' + str(auth_token)
def put_pass(self, username, password, server): keyring_type = gk.ITEM_NETWORK_PASSWORD display_name = '%s password for %s at %s' % (self.app.upper(), username, server) usr_attrs = { 'user': username, 'server': server, 'protocol': self.protocol } id = gk.item_create_sync(self.keyring, keyring_type, display_name, usr_attrs, password, False) return id is not None
def create(self): ''' Create a new keyring item. Return True if item created successfully, False otherwise. ''' try: id = gk.item_create_sync(self.keyring, self.item_type, self.name, self.params, self.secret, False) except gk.Error, e: print >> sys.stderr, 'Error creating keyring item!\nDetails:\n%s' % e return False
def add_secret(self, secret): _id = None try: _id = gnomekeyring.item_create_sync( self.keyring, gnomekeyring.ITEM_GENERIC_SECRET, secret.get_name(), secret.get_attributes(), secret.get_secret(), True) except: logging.exception("Failed to add keyring secret") return _id
def store_password(self, scheme, host, username, password): """Return the password of username@root.""" self.clear_password(scheme, host, username) try: item_id = gnomekeyring.item_create_sync( None, gnomekeyring.ITEM_NETWORK_PASSWORD, host, { "user": username, "protocol": scheme, "server": host }, password, True) except (gnomekeyring.CancelledError, gnomekeyring.NoKeyringDaemonError): pass self.item_ids[(scheme, host, username)] = (None, item_id)