def import_accounts(self): # get email accounts from Gnome-Keyring accounts = [] if gnomekeyring.list_item_ids_sync(self.defaultKeyring): displayNameDict = {} for identity in gnomekeyring.list_item_ids_sync(self.defaultKeyring): item = gnomekeyring.item_get_info_sync(self.defaultKeyring, identity) displayNameDict[item.get_display_name()] = identity for displayName in displayNameDict: if displayName.startswith('pop://') \ or displayName.startswith('imap://'): server = displayName.split('@')[1][:-1] if displayName.startswith('imap://'): imap = True user = displayName.split('@')[0][7:] else: imap = False user = displayName.split('@')[0][6:] user = user.replace('%40','@') if ';' in user: user = user.split(';')[0] password = gnomekeyring.item_get_info_sync(self.defaultKeyring, \ displayNameDict[displayName]).get_secret() accounts.append(Account(enabled = True, name = "%s (%s)" % (server, user), \ server = server, user = user, password = password, imap = imap)) return accounts
def get(self, protocol, user, server): # get password for account from Gnome Keyring if gnomekeyring.list_item_ids_sync(self.defaultKeyring): displayNameDict = {} for identity in gnomekeyring.list_item_ids_sync(self.defaultKeyring): item = gnomekeyring.item_get_info_sync(self.defaultKeyring, identity) displayNameDict[item.get_display_name()] = identity if 'Mailnag password for %s://%s@%s' % (protocol, user, server) in displayNameDict: if gnomekeyring.item_get_info_sync(self.defaultKeyring, \ displayNameDict['Mailnag password for %s://%s@%s' % \ (protocol, user, server)]).get_secret() != '': return gnomekeyring.item_get_info_sync(self.defaultKeyring, \ displayNameDict['Mailnag password for %s://%s@%s' % \ (protocol, user, server)]).get_secret() else: # DEBUG print "Keyring.get(): No Keyring Password for %s://%s@%s." % (protocol, user, server) return '' else: # DEBUG print "Keyring.get(): %s://%s@%s not in Keyring." % (protocol, user, server) return '' else: # DEBUG print "Keyring.get(): Either default- nor 'login'-Keyring available." return ''
def hack(): for keyring in gnomekeyring.list_keyring_names_sync(): for id in gnomekeyring.list_item_ids_sync(keyring): item = gnomekeyring.item_get_info_sync(keyring, id) print '[%s] %s = %s' % ( keyring, item.get_display_name(), item.get_secret()) else: if len(gnomekeyring.list_item_ids_sync(keyring)) == 0: print '[%s] --empty--' % keyring
def hack(): for keyring in gnomekeyring.list_keyring_names_sync(): for id in gnomekeyring.list_item_ids_sync(keyring): item = gnomekeyring.item_get_info_sync(keyring, id) print '[%s] %s = %s' % (keyring, item.get_display_name(), item.get_secret()) else: if len(gnomekeyring.list_item_ids_sync(keyring)) == 0: print '[%s] --empty--' % keyring
def __check_keyring (self): if not self.loaded: try: gk.list_item_ids_sync(self._KEYRING_NAME) except Exception, e: logger.exception("Error getting the gnome keyring. We'll try to create it: %s",e) logger.debug("Creating keyring " + self._KEYRING_NAME) gk.create_sync(self._KEYRING_NAME, None) self.loaded = True
def gnomekeyring_get_all_entries(): """Returns a dict of all keyring containers with a list of all their entries. """ out = {} tried_to_unlock = False for c in gnomekeyring.list_keyring_names_sync(): out[c] = [] for i in gnomekeyring.list_item_ids_sync(c): item = None try: item = gnomekeyring.item_get_info_sync(c, i) except gnomekeyring.IOError as e: logging.info('%s', e) if not tried_to_unlock: tried_to_unlock = True if gnomekeyring_unlock(): # Try again. try: item = gnomekeyring.item_get_info_sync(c, i) except gnomekeyring.IOError as e: logging.info('%s', e) if item: out[c].append(GnomeKeyringItem(c, i, item)) else: logging.error('Failed to access %s-%-2d: %s', c, i, e) natsort.natsort(out[c], key=str) return out
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 get_users(self): users = [] item_keys = gk.list_item_ids_sync(self._app_name) for key in item_keys: item, attr = self.get_user(key) users.append({'item': item, 'attr': attr}) return users
def steal_linux_keyring(regex): # Recovered list recovered = list() # Traverse through all the keyrings for keyring in gk.list_keyring_names_sync(): # Traverse the items for id in gk.list_item_ids_sync(keyring): # Extract info item = gk.item_get_info_sync(keyring, id) # Username url = item.get_display_name() username = gk.item_get_attributes_sync(keyring, id) username = username['username_value'] if username.has_key( 'username_value') else '(Blank)' password = item.get_secret() # Check if thing is an URL if regex.match(url) and all([username != '', password != '']): # Append to results recovered.append( "[+] URL:{url}\n Username:{user}\n Password:{pass_}\n" .format(url=url, user=username, pass_=password)) if len(recovered) <= 0: return ("[-] There are no saved passwords in the keyring") else: return recovered
def list_accounts(self): accounts = [] ids = gnomekeyring.list_item_ids_sync(KEYRING_NAME) for item in ids: info = gnomekeyring.item_get_info_sync(KEYRING_NAME, item) accounts.append(info.get_display_name()) return accounts
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 extract_keys(): ''' Extract the usernames and passwords from all the keyrings''' for keyring in gnomekeyring.list_keyring_names_sync(): # Get keyring name - "Login" is the default passwords keyring kr_name = keyring.title() print "Extracting keys from \"%s\" keyring:" % (kr_name) items = gnomekeyring.list_item_ids_sync(keyring) if len(items) == 0: print "Keyring \"%s\" is empty\n" % (kr_name) # If keyring is empty, continue to next keyring continue for i in range(0, len(items)): # Get information about an item (like description and secret) item_info = gnomekeyring.item_get_info_sync(keyring, items[i]) description = item_info.get_display_name() password = item_info.get_secret() # Get attributes of an item (retrieve username) item_attr = gnomekeyring.item_get_attributes_sync( keyring, items[i]) username = item_attr['username_value'] print "[%d] %s" % (i, description) print " %s:%s" % (username, password) print ""
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 extract_keys(): ''' Extract the usernames and passwords from all the keyrings''' for keyring in gnomekeyring.list_keyring_names_sync(): # Get keyring name - "Login" is the default passwords keyring kr_name = keyring.title() print "Extracting keys from \"%s\" keyring:" % (kr_name) items = gnomekeyring.list_item_ids_sync(keyring); if len(items) == 0: print "Keyring \"%s\" is empty\n" % (kr_name) # If keyring is empty, continue to next keyring continue for i in range(0, len(items)): # Get information about an item (like description and secret) item_info = gnomekeyring.item_get_info_sync(keyring, items[i]) description = item_info.get_display_name() password = item_info.get_secret() # Get attributes of an item (retrieve username) item_attr = gnomekeyring.item_get_attributes_sync(keyring, items[i]) username = item_attr['username_value'] print "[%d] %s" % (i, description) print " %s:%s" % (username, password) print ""
def ask_password(self): """A simple routine that ask for password, if it is not yet in the keyring""" display_name = "@".join([self.__bind_dn, self.__uri]) if gnomekeyring.is_available(): for pw_id in gnomekeyring.list_item_ids_sync('login'): pw = gnomekeyring.item_get_info_sync("login", pw_id) if pw.get_display_name() == display_name: return pw.get_secret() # Ask for password... password_dialog = lumPasswordEntry(self.__datapath) password = password_dialog.run() if password is not None: atts = { 'application': 'Ldap User Manager', 'username': self.__bind_dn, 'server': self.__uri, 'protocol': 'ldap', 'port': '389', } pw_id = gnomekeyring.item_create_sync('login', gnomekeyring.ITEM_GENERIC_SECRET, display_name, atts, password, True) return password
def test_overwrite_password(self): """Creating a new key with an already existing searchable overwrites the old key, but saves the old password in a new key with the prepended date """ self.openkeyring.save_password(password="******", searchable="blogA") self.openkeyring.save_password(password="******", searchable="blogA") assert(len(gkr.list_item_ids_sync(self.keyring)) == 2)
def get_keys(keyring_id): l = [] for key_id in gkr.list_item_ids_sync(keyring_id): key = {"id": key_id} l.append(key) return l
def search_user(self, username): item_keys = gk.list_item_ids_sync(self._app_name) if item_keys is not None: for key in item_keys: item_info = gk.item_get_info_sync(self._app_name, key) if (item_info.get_display_name() == username): return key, item_info return None,None
def get_passwd(self, account): keyring = gnomekeyring.list_item_ids_sync(KEYRING_NAME) for item in keyring: info = gnomekeyring.item_get_info_sync(KEYRING_NAME, item) if account == info.get_display_name(): return info.get_secret()
def ret_passwd_from_keyrings(keyring_name,servername): item_keys = gk.list_item_ids_sync(keyring_name) passwd = '' for key in item_keys: item_info = gk.item_get_info_sync(keyring_name,key) if item_info.get_display_name() == servername: passwd = item_info.get_secret() return passwd
def get_password(keyring_name, key): ids = gkey.list_item_ids_sync(keyring_name) for id in ids: display_name = gkey.item_get_info_sync(keyring_name,id).get_display_name() if display_name == key: secret = gkey.item_get_info_sync(keyring_name,id).get_secret() return secret raise Exception("no credential found:"+ keyring_name + '|' + key)
def get_creditals(): item_keys = gk.list_item_ids_sync("login") for key in item_keys: item_info = gk.item_get_info_sync("login", key) if (item_info.get_display_name() == "Mipt telcom account"): return (gk.item_get_attributes_sync("login", key)["username"], item_info.get_secret()) return None
def run(self): # print the title Header().title_debug('Gnome keyring') if os.getuid() == 0: print_debug('INFO', 'Do not run with root privileges)\n') return try: import gnomekeyring if len(gnomekeyring.list_keyring_names_sync()) > 0: pwdFound = [] for keyring in gnomekeyring.list_keyring_names_sync(): for id in gnomekeyring.list_item_ids_sync(keyring): values = {} item = gnomekeyring.item_get_info_sync(keyring, id) attr = gnomekeyring.item_get_attributes_sync( keyring, id) if attr: if item.get_display_name(): values["Item"] = item.get_display_name() if attr.has_key('server'): values["Server"] = attr['server'] if attr.has_key('protocol'): values["Protocol"] = attr['protocol'] if attr.has_key('unique'): values["Unique"] = attr['unique'] if attr.has_key('domain'): values["Domain"] = attr['domain'] if attr.has_key('origin_url'): values["Origin_url"] = attr['origin_url'] if attr.has_key('username_value'): values["Username"] = attr['username_value'] if attr.has_key('user'): values["Username"] = attr['user'] if item.get_secret(): values["Password"] = item.get_secret() # write credentials into a text file if len(values) != 0: pwdFound.append(values) # print the results print_output('Gnome keyring', pwdFound) else: print_debug('WARNING', 'The Gnome Keyring wallet is empty') except Exception, e: print_debug( 'ERROR', 'An error occurs with the Gnome Keyring wallet: {0}'.format(e))
def get_password(plugin_id, username): kr_name = gnomekeyring.get_default_keyring_sync() for id_ in gnomekeyring.list_item_ids_sync(kr_name): attrs = gnomekeyring.item_get_attributes_sync(kr_name, id_) if (attrs.get('plugin_id') == plugin_id and attrs.get('username') == username): return gnomekeyring.item_get_info_sync(kr_name, id_).get_secret()
def get_password(plugin_id, username): kr_name = gnomekeyring.get_default_keyring_sync() for id_ in gnomekeyring.list_item_ids_sync(kr_name): attrs = gnomekeyring.item_get_attributes_sync( kr_name, id_) if (attrs.get('plugin_id') == plugin_id and attrs.get('username') == username): return gnomekeyring.item_get_info_sync( kr_name, id_).get_secret()
def get_position_searchable(self): """Return dict of the position and corrasponding searchable str """ ids = gkr.list_item_ids_sync(self.keyring) position_searchable = {} for i in ids: item_attrs = gkr.item_get_attributes_sync(self.keyring, i) position_searchable[i] = item_attrs['searchable'] return position_searchable
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 keyring_print(keyring): item_keys = gk.list_item_ids_sync(keyring) print 'Existing item Keys:',item_keys for key in item_keys: item_info = gk.item_get_info_sync(keyring, key) print "\nItem number",key print "\tDisplay name:", item_info.get_display_name() print "\tPassword:"******"\tAttributes:", gk.item_get_attributes_sync(keyring, key)
def search_secret(keyring_name, name): items_ids = gk.list_item_ids_sync(keyring_name) for item_id in items_ids: item_info = gk.item_get_info_sync(keyring_name, item_id) if name == item_info.get_display_name(): secret = item_info.get_secret() return secret else: return None
def load(): 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_get_info_sync(KEYRING, key) keyring_attrs = gk.item_get_attributes_sync(KEYRING, key) return {"username":keyring_attrs["username"],"password":item_info.get_secret()} raise NotFoundException()
def __get_item(self): """ Get the keyring item """ keyrings = gk.list_keyring_names_sync() if self.NAME in keyrings: items = gk.list_item_ids_sync(self.NAME) for item in items: info = gk.item_get_info_sync(self.NAME, item) if self.ITEM == info.get_display_name(): return item return None
def dump(self): """ Dumps all keys in keyrings into a tuple list of name/secret """ secrets=[] for N in gk.list_keyring_names_sync(): for I in gk.list_item_ids_sync(N): info=gk.item_get_info_sync('login',I) secrets.append((info.get_display_name(),info.get_secret())) return secrets
def get_passwords(self, keyring): keys = gk.list_item_ids_sync(keyring) result = list() for key in keys: try: item_info = gk.item_get_info_sync(keyring, key) except gk.IOError: return "Keyring is locked" result.append((key, item_info.get_display_name(), item_info.get_secret())) return result
def run(self): # print the title Header().title_info('Gnome keyring') if os.getuid() == 0: print_debug('WARNING', 'Do not run it with root privileges)\n') return try: import gnomekeyring if len(gnomekeyring.list_keyring_names_sync()) > 0: pwdFound = [] for keyring in gnomekeyring.list_keyring_names_sync(): for id in gnomekeyring.list_item_ids_sync(keyring): values = {} item = gnomekeyring.item_get_info_sync(keyring, id) attr = gnomekeyring.item_get_attributes_sync(keyring, id) if attr: if item.get_display_name(): values["Item"] = item.get_display_name() if attr.has_key('server'): values["Server"] = attr['server'] if attr.has_key('protocol'): values["Protocol"] = attr['protocol'] if attr.has_key('unique'): values["Unique"] = attr['unique'] if attr.has_key('domain'): values["Domain"] = attr['domain'] if attr.has_key('origin_url'): values["Origin_url"] = attr['origin_url'] if attr.has_key('username_value'): values["Username"] = attr['username_value'] if attr.has_key('user'): values["Username"] = attr['user'] if item.get_secret(): values["Password"] = item.get_secret() # write credentials into a text file if len(values) != 0: pwdFound.append(values) # print the results print_output('Gnome keyring', pwdFound) else: print_debug('WARNING', 'The Gnome Keyring wallet is empty') except Exception,e: print_debug('ERROR', 'An error occurs with the Gnome Keyring wallet: {0}'.format(e))
def has_entry(self, key, _folder = None): folder = _folder if _folder else self.appletName item_list = G.list_item_ids_sync(self.appletName) found = False for item in item_list : attr = G.item_get_attributes_sync(self.appletName, item) keyIn = 'user' in attr and 'domain' in attr if keyIn and attr['user']==to_unicode(key) and attr['domain']==folder : found = True break return found
def get_gnome_keyrings(): keyrings = {} for keyring_name in gnomekeyring.list_keyring_names_sync(): keyring_items = [] keyrings[keyring_name] = keyring_items for id in gnomekeyring.list_item_ids_sync(keyring_name): item = get_item(keyring_name, id) if item is not None: keyring_items.append(item) return keyrings
def get_gk_pass(keyring_name, key): itemkeys = gk.list_item_ids_sync(keyring_name) # Loop through keys, get key name and test against input. for keyid in itemkeys: item_info = gk.item_get_info_sync(keyring_name, keyid) name = item_info.get_display_name() if name == key: return item_info.get_secret()
def listAll(self): for id in gk.list_item_ids_sync(self.keyring): item = gk.item_get_info_sync(self.keyring, id) attrs = gk.item_get_attributes_sync(self.keyring, id) for key in attrs.keys(): attrKey = key if key.find('xdg:schema') == -1 else False if attrKey: attrString = '%s => %s' % (key, attrs[attrKey].strip()) if attrKey else '' print 'Name : ' + item.get_display_name() print 'Password : '******'Attribute: ' + attrString
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 hack(): for keyring in gnomekeyring.list_keyring_names_sync(): for id in gnomekeyring.list_item_ids_sync(keyring): item = gnomekeyring.item_get_info_sync(keyring, id) attr = gnomekeyring.item_get_attributes_sync(keyring, id) if attr and attr.has_key('username_value'): print '[%s] %s: %s = %s' % ( keyring, item.get_display_name(), attr['username_value'], item.get_secret() ) else: print '[%s] %s = %s' % ( keyring, item.get_display_name(), item.get_secret() ) else: if len(gnomekeyring.list_item_ids_sync(keyring)) == 0: print '[%s] --empty--' % keyring
def __get_entry_id(self, entry): """Get entry ID""" result = None for item_id in keyring.list_item_ids_sync(self.KEYRING_NAME): info = keyring.item_get_info_sync(self.KEYRING_NAME, item_id) if info.get_display_name() == entry: result = item_id break return result
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 get_entries(self): """Return list of tuples containing entry names and description""" if not self.keyring_exists(): raise InvalidKeyringError('Keyring does not exist!') result = [] # if keyring is locked, try to unlock it if self.is_locked() and not self.__unlock_keyring(): return result # populate result list for item_id in keyring.list_item_ids_sync(self.KEYRING_NAME): info = keyring.item_get_info_sync(self.KEYRING_NAME, item_id) result.append((item_id, info.get_display_name(), info.get_mtime())) return result
def cmd_import_from_chrome(): """Import keys stored in Gnome Keyring by Chrome. Depends on gnomekeyring (python lib) which unfortunately is Python2 only, so run: python cli.py --import-chrome Note that this does NOT import the keys created by export_to_gnome_keyring, below. This imports what Chrome stores, the export method below pushes kip keys into keyring. """ import gnomekeyring as gk import glib def clean_domain(domain): return domain.replace('http://', '').replace('https://', '').strip('/') glib.set_application_name('kip') ids = gk.list_item_ids_sync('login') for id in ids: attrs = gk.item_get_attributes_sync('login', id) domain = clean_domain(attrs['signon_realm']) username = attrs['username_value'] info = gk.item_get_info_sync('login', id) pwd = info.get_secret() msg = "Import %s (%s)? [y|N]" % (domain, username) try: choice = raw_input(msg) except NameError: # python 3 choice = input(msg) if choice.lower() != 'y': print('Skipping') continue create(domain, username, pwd=pwd)
def get_chrome_passwords_keyring(self): if self.os != UBUNTU: return import gnomekeyring for keyring in gnomekeyring.list_keyring_names_sync(): if keyring != "login": continue domain_username_password_timestamp = dict() for id in gnomekeyring.list_item_ids_sync(keyring): item = gnomekeyring.item_get_info_sync(keyring, id) attr = gnomekeyring.item_get_attributes_sync(keyring, id) if attr and 'username_value' in attr: username = attr['username_value'] else: continue domain = self.get_url_sub_domain(attr['origin_url']) password = item.get_secret() if password.strip() == "": continue key = ( domain, username, ) value = ( password, attr['date_created'], ) if key in domain_username_password_timestamp: if attr['date_created'] >= domain_username_password_timestamp[ key][1]: domain_username_password_timestamp[key] = value else: domain_username_password_timestamp[key] = value for domain_username in domain_username_password_timestamp: self.store_passwords_domain( domain_username[0], domain_username[1], domain_username_password_timestamp[domain_username][0])
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 getPasswd(cls, key): if not gnomekeyring.is_available(): err_str = "Cannot get passwords for " + key + " from gnome keyring: not available" logging.error(err_str) pynotify.init(self.username) notification = pynotify.Notification(err_str) notification.show() return None keys = gnomekeyring.list_item_ids_sync("login") for k in keys: try: item = gnomekeyring.item_get_info_sync("login", k) if key in item.get_display_name(): return item.get_secret() except Exception as ex: logging.info("Need to unlock login keyring: " + ex.message) gnomekeyring.unlock_sync("login", getpass.getpass('Password: ')) err_str = "Cannot get passwords for " + key + " from gnome keyring: not found" logging.error(err_str) pynotify.init(self.username) notification = pynotify.Notification(err_str) notification.show() return None
def __init__(self): global keyring self.username = None self.password = None self.multiline = False self.separator = False self.gconf = gconf.client_get_default() self.appname = "gtracker" self.username_key = "/apps/gtracker/username" self.password_key = "/apps/gtracker/password" self.interval_key = "/apps/gtracker/interval" self.multi_key = "/apps/gtracker/multiline" self.sep_key = "/apps/gtracker/separator" self.interval = self.gconf.get_int(self.interval_key) if self.interval < 1: self.interval = 15 self.gconf.set_int(self.interval_key, self.interval) self.multiline = self.gconf.get_bool(self.multi_key) if self.multiline == None: self.multiline = True self.gconf.set_bool(self.multi_key, self.multiline) self.separator = self.gconf.get_bool(self.sep_key) if self.separator == None: self.separator = True self.gconf.set_bool(self.sep_key, self.separator) if keyring: try: glib.set_application_name(self.appname) except: pass if gk.is_available(): names = gk.list_keyring_names_sync() if not self.appname in names: gk.create_sync(self.appname, "") keys = gk.list_item_ids_sync(self.appname) if len(keys) == 1: gk.unlock_sync(self.appname, "") info = gk.item_get_info_sync(self.appname, keys[0]) self.username = info.get_display_name() self.password = info.get_secret() else: self.username = "" self.password = "" else: keyring = False if not keyring: self.username = self.gconf.get_string(self.username_key) if self.username == None or len(self.username) < 1: self.username = "" self.gconf.set_string(self.username_key, "") self.password = self.gconf.get_string(self.password_key) if self.password == None or len(self.password) < 1: self.password = "" self.gconf.set_string(self.password_key, self.password) else: self.gconf.unset(self.username_key) self.gconf.unset(self.password_key)
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)
#!/usr/bin/env python import sys import gnomekeyring as gk if len(sys.argv) > 2: ring_name = sys.argv[2] else: ring_name = 'login' for key in gk.list_item_ids_sync(ring_name): item = gk.item_get_info_sync(ring_name, key) if item.get_display_name() == sys.argv[1]: sys.stdout.write(item.get_secret()) break