def deleteKey(self, value, nameOrAttr='name', keyOrValue='key'): attrs = self.__find(value, nameOrAttr, keyOrValue) if attrs == False: print 'No such key exists.' else: gk.item_delete_sync(self.keyring, attrs['id']) if keyOrValue == value else False print "Successful key deletion."
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 _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 remove_logins(self, kind, username, url): _logger.debug("removing login (%s, %s, %s)" % (kind, username, url)) new_fallbacks = set() for ki in self.__fallback_items: if ki.get_kind() == kind and \ ki.get_username() == username and \ ki.get_url() == url: pass else: new_fallbacks.add(ki) self.__fallback_items = new_fallbacks if self.is_available(): try: found = bignative.keyring_find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET, dict(appname='BigBoard', kind=kind, username=username, url=url)) except TypeError: found = set() for f in found: gnomekeyring.item_delete_sync('session', f.item_id)
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 delete(self, auth_token): """ Deletes C{auth_token} from the keyring as its faulty """ try: gnomekeyring.item_delete_sync(self.keyring, auth_token) except Exception, e: raise
def clear_password(self, scheme, host, username): """Remove the password from the cache.""" try: if (scheme, host, username) in self.item_ids: ring_id, item_id = self.item_ids[(scheme, host, username)] gnomekeyring.item_delete_sync(ring_id, item_id) except gnomekeyring.NoKeyringDaemonError: pass
def delete(self): if keyring == 'gk': if self.key != None: gk.item_delete_sync('pycle', self.key) elif keyring == 'kk': pass elif keyring == 'xk': pass
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 forget_password(self, menu_item = None): if not gnomekeyring.is_available(): return None if self.__uri is None or self.__bind_dn is None: return None display_name = "@".join([self.__bind_dn, self.__uri]) for pw_id in gnomekeyring.list_item_ids_sync("login"): if gnomekeyring.item_get_info_sync("login", pw_id).get_display_name() == display_name: gnomekeyring.item_delete_sync('login', pw_id)
def remove_key(self,keyring,query): """ Removes a key from an specified keyring that matches specified query """ key=self.search_key(query) if key: # TODO: Get keyring and key id from result gk.item_delete_sync(keyring,id) else: raise
def delete_details(self): """ Delete account details """ try: item = self.__get_item() if item is not None: gk.item_delete_sync(self.NAME, item) return True return False except self.GK_EXCEPT as e: raise AccountError(repr(e))
def delete(self): ''' Delete a keyring item. Return True if item created successfully, False otherwise. ''' try: gk.item_delete_sync(self.keyring, self.id) except gk.Error, e: print >>sys.stderr, 'Error deleting keyring item!\nDetails:\n%s'%e return False
def remove_credentials(self, acc): self.lock.acquire() try: logger.debug("Removing credentias from gnome keyring for the account: %s" % (acc.get_name())) if hasattr(acc, "keyringid"): gk.item_delete_sync(self._KEYRING_NAME, int(acc.keyringid)) logger.debug("Credentials removed") else: logger.debug("The account has not credentials asigned, continue") finally: self.lock.release()
def on_account_delete(self, widget): if "id" in self.account: try: private_fields = [f.split(":")[-1] for f in self.services[self.account["service"]]["config"] if ":" in f] for f in private_fields: if self.account[f].startswith(":KEYRING:"): keyring_id = int(self.account[f].split(":")[-1]) gnomekeyring.item_delete_sync(gnomekeyring.get_default_keyring_sync(), keyring_id) except: pass self.gwibber.accounts.Delete(self.account["id"]) self.populate_account_tree() self.select_first()
def _set_credentials(self, username, password): " Stores the username and password in the Gnome keyring. " self._fetch_credentials() self._username, self._password = username, password if self._item_id: gnomekeyring.item_delete_sync(self._keyring, self._item_id) self._keyring = 'login' self._item_id = gnomekeyring.item_create_sync(self._keyring, gnomekeyring.ITEM_GENERIC_SECRET, 'rt-helper', {'application': APPLICATION_NAME, 'username': username}, password, False)
def delpass(self, username, server): ret = True # Does it already exist? protocol = self.get_protocol() try: results = gk.find_network_password_sync(user=username, server=server, protocol=protocol) except gk.NoMatchError: print "No password set for user '%s' in server '%s'" % (username, server) ret = False if ret: gk.item_delete_sync(self.keyring, results[0]['item_id']) print "Password successfully removed" return ret
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 store_password(self, scheme, host, username, password): """Return the password of username@root.""" try: if (scheme, host, username) in self.item_ids: ring_id, item_id = self.item_ids[(scheme, host, username)] gnomekeyring.item_delete_sync(ring_id, item_id) 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)
def new_auth(): # Clear all old entries try: for item in gk.find_items_sync(gk.ITEM_GENERIC_SECRET, {'application': KEY_NAME}): gk.item_delete_sync(KEYRING_NAME, item.item_id) except gk.NoMatchError: pass # Read in username and password user = raw_input('User: '******'user': user, 'application': KEY_NAME} gk.item_create_sync(KEYRING_NAME, gk.ITEM_GENERIC_SECRET, KEY_NAME, attrs, passwd, True) return user,passwd
def remove_entry(self, entry): """Remove entry from keyring""" if not self.keyring_exists(): raise InvalidKeyringError('Keyring does not exist!') result = False # if keyring is locked, try to unlock it if self.is_locked() and not self.__unlock_keyring(): return result # get entry id entry_id = self.__get_entry_id(entry) if entry_id is not None: keyring.item_delete_sync(self.KEYRING_NAME, entry_id) result = True return result
def remove(self, accounts): # delete obsolete entries from Keyring defaultKeyring = gnomekeyring.get_default_keyring_sync() if defaultKeyring == None: defaultKeyring = 'login' valid_accounts = [] for acc in accounts: # create list of all valid accounts protocol = 'imap' if acc.imap else 'pop' valid_accounts.append('Mailnag password for %s://%s@%s' % \ (protocol, acc.user, acc.server)) if gnomekeyring.list_item_ids_sync(defaultKeyring): # find and delete invalid entries displayNameDict = {} for identity in gnomekeyring.list_item_ids_sync(defaultKeyring): item = gnomekeyring.item_get_info_sync(defaultKeyring, identity) displayNameDict[item.get_display_name()] = identity for key in displayNameDict.keys(): if key.startswith('Mailnag password for') \ and key not in valid_accounts: gnomekeyring.item_delete_sync(defaultKeyring, displayNameDict[key])
def gnomekeyring_delete_secrets(items): tried_to_unlock = False ret = 0 for container, itemid in items: itemid = int(itemid) try: gnomekeyring.item_delete_sync(container, itemid) except gnomekeyring.IOError as e: logging.info('%s', e) if not tried_to_unlock: tried_to_unlock = True if gnomekeyring_unlock(): # Try again. try: gnomekeyring.item_delete_sync(container, itemid) continue except gnomekeyring.IOError as e: logging.info('%s', e) print >> sys.stderr, 'Failed to delete %s #%d' % (container, itemid) ret = 1 return ret
def save(self,username,password,interval,multi=True,separator=False): try: self.gconf.set_int(self.interval_key,interval) self.gconf.set_bool(self.multi_key,multi) self.gconf.set_bool(self.sep_key,separator) self.multiline = multi self.separator = separator if not keyring: self.gconf.set_string(self.username_key,username) self.gconf.set_string(self.password_key,password) else: keys = gk.list_item_ids_sync(self.appname) if len(keys)>0: for key in keys: gk.item_delete_sync(self.appname,key) gk.item_create_sync(self.appname,gk.ITEM_GENERIC_SECRET,username,{"username":username},password,True) except Exception as exc: return False return True
def save_password(self, password, **attrs): """Save the new password, save the old password with the date prepended """ pos_of_match = self._match_exists(attrs['searchable']) if pos_of_match: old_password = self.get_password(pos_of_match).get_secret() gkr.item_delete_sync(self.keyring, pos_of_match) desc = str(int(time.time())) + "_" + attrs['searchable'] gkr.item_create_sync(self.keyring ,gkr.ITEM_GENERIC_SECRET ,desc ,{} ,old_password ,True) desc = attrs['searchable'] pos = gkr.item_create_sync(self.keyring ,gkr.ITEM_GENERIC_SECRET ,desc ,attrs ,password ,True) return pos
def save(self, username, password, interval, multi=True, separator=False): try: self.gconf.set_int(self.interval_key, interval) self.gconf.set_bool(self.multi_key, multi) self.gconf.set_bool(self.sep_key, separator) self.multiline = multi self.separator = separator if not keyring: self.gconf.set_string(self.username_key, username) self.gconf.set_string(self.password_key, password) else: keys = gk.list_item_ids_sync(self.appname) if len(keys) > 0: for key in keys: gk.item_delete_sync(self.appname, key) gk.item_create_sync(self.appname, gk.ITEM_GENERIC_SECRET, username, {"username": username}, password, True) except Exception as exc: return False return True
def set_credentials(self, user, pw): """ Store or update username and password for account """ # Note: attrs is used to look up the account for old user credentials attrs = { "server": self._host, "protocol": self._protocol, } LOGGER.debug ("Updating credentials for %s" % self._host) keyring = gnomekeyring.get_default_keyring_sync() # Look up all accounts registered for this service and realm and delete # them. We get weird errors if more than one account is present try: items = gnomekeyring.find_items_sync (gnomekeyring.ITEM_NETWORK_PASSWORD, attrs) except gnomekeyring.NoMatchError: LOGGER.debug ("No existing accounts for %s" % self._host) items = [] for item in items: LOGGER.debug ("Purging account %s@%s" % (item.attributes["user"], item.attributes["server"])) gnomekeyring.item_delete_sync (keyring, item.item_id) # Add the 'user' attribute to attrs and commit it to the keyring LOGGER.debug ("Creating new account %s@%s" % (user, self._host)) attrs["user"] = user gnomekeyring.item_create_sync(keyring, gnomekeyring.ITEM_NETWORK_PASSWORD, self._realm, attrs, pw, True) LOGGER.debug ("Credential update success")
def tearDown(self): if self.auth_token: gnomekeyring.item_delete_sync(self.defkeyring, self.auth_token)
def delete(): 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().endswith(DISPLAY_NAME): item_info = gk.item_delete_sync(KEYRING, key)
def delete_password(self, keyring, login): _, item_id = self._get_item(keyring, login) if item_id is not None: gnomekeyring.item_delete_sync("Login", item_id)
def remove_keyring(self, password): id = password.split(":")[1] gkey.item_delete_sync(self._keyring, int(id))
def del_item(user, server, protocol): results = gkey.find_network_password_sync(user = username, server = server, protocol = protocol) gkey.item_delete_sync(keyring, results[0]['item_id'])
def delete_password(self, url, user): gk_data = self._keyring_data(url, user) if gk_data is None: return gnomekeyring.item_delete_sync(gk_data['keyring'], gk_data['item_id'])
def delete_key(self, keyid): gk.item_delete_sync(self.keyring_name, keyid)
def clear_secret(self, _id): try: gnomekeyring.item_delete_sync(self.keyring, _id) return True except: return False