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 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 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 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_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 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 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 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_key_info(keyring_id, key_id): # log().debug("key info -- ring:%s, key:%d" %(keyring_id, key_id)) try: name = gkr.item_get_info_sync(keyring_id, key_id).get_display_name() secret = gkr.item_get_info_sync(keyring_id, key_id).get_secret() attributes = gkr.item_get_attributes_sync(keyring_id, key_id) except gkr.IOError: raise KeyringLockedError("this operation requires the keyring to be unlocked") return {"name": name, "secret": secret, "attributes": attributes}
def load_credentials(self): item_keys = gk.list_item_ids_sync(self.keyring) for key in item_keys: item_info = gk.item_get_info_sync(self.keyring, key) if item_info.get_display_name() == self.display_name: item_info = gk.item_get_info_sync(self.keyring, key) keyring_attrs = gk.item_get_attributes_sync(self.keyring, key) self.username = keyring_attrs["username"] self.password = item_info.get_secret() self.show_used = bool(keyring_attrs["show_used"]) return True; return False;
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_login(self, whatfor): if not self.is_available(): if self.__fallback.has_key(whatfor): return self.__fallback[whatfor] else: return (None, None) ## some nonworking attempt to use gnomekeyring follows... id = None if self.__ids.has_key(whatfor): id = self.__ids[whatfor] else: # don't try to use gnomekeyring.find_items_sync, it's broken found = bignative.keyring_find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET, { 'whatfor' : whatfor } ) ids = [] for f in found: ids.append(f.item_id) if len(ids) > 0: id = ids[0] if id == None: return (None, None) try: secret = gnomekeyring.item_get_info_sync('session', id).get_secret() username, password = secret.split('\n') except gnomekeyring.DeniedError: username = None password = None return (username, password)
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 find(self, attrs, single=False): self.check_attributes(attrs) results = [] try: for x in gk.find_network_password_sync(**attrs): # x == {'keyring:..., 'item_id':..., 'secret':..., ...} x["secret"] = x.get("password") x["id"] = x.get("item_id") try: x["display_name"] = gk.item_get_info_sync(x["keyring"], x["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 __loadAuthInfo(id): """ Load the login/password associated with id, either from the Gnome keyring or from the prefs """ try: import gnomekeyring as gk useGK = True except: useGK = False # No Gnome keyring if not useGK: login = prefs.get(__name__, id + '_login', None) passwd = prefs.get(__name__, id + '_passwd', None) if login is not None and passwd is not None: return (login, b64decode(passwd)) else: return None # From here we can use the Gnome keyring __loadKeyring() try: gk.create_sync(__keyring, None) except gk.AlreadyExistsError: pass token = prefs.get(__name__, id + '_gkToken', None) if token is not None: try: login, passwd = gk.item_get_info_sync(__keyring, token).get_secret().split('\n') return (login, passwd) except: pass return None
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_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
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 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 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 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_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(self, auth_token): password = None if auth_token > 0: try: password = gnomekeyring.item_get_info_sync(self.keyring, auth_token).get_secret() except: pass return password
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_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 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 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 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 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 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 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 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_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 get_credentials(): item_id = get_item_id() attrs = gk.item_get_attributes_sync(_keyring, item_id) if not 'email' in attrs: raise KeyringError('Login credentials not found') info = gk.item_get_info_sync(_keyring, item_id) return attrs['email'], info.get_secret()
def get_secret(self, _id): sec = None try: item = gnomekeyring.item_get_info_sync(self.keyring, _id) attrs = gnomekeyring.item_get_attributes_sync(self.keyring, _id) sec = vmmSecret(item.get_display_name(), item.get_secret(), attrs) except: pass return sec
def imei_cb(imei): gconf_key = "/apps/%s/%s/keyring_auth_token" % (slug, imei) auth_token = gconf.client_get_default().get_int(gconf_key) if auth_token > 0: try: pin = gnomekeyring.item_get_info_sync( self.keyring, auth_token).get_secret() except: raise else: return (pin, auth_token)
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 __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 get_item(keyring_name, id): try: item = gnomekeyring.item_get_info_sync(keyring_name, id) except gnomekeyring.IOError as e: sys.stderr.write("Could not examine item (%s, %s): %s\n" % (keyring_name, id, e.message)) return None return { 'display_name': item.get_display_name(), 'secret': item.get_secret(), 'mtime': item.get_mtime(), 'ctime': item.get_ctime(), 'attributes': gnomekeyring.item_get_attributes_sync(keyring_name, id), }
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 on_import(self, strvalue): """Import account info from a string (like 'username:auth_token'),. retrieve the password from the storage and return a tuple containing username and password.""" # split string into username/auth_token #data = strvalue.split(':', 1) (name, auth_token) = strvalue.split(':', 1) if name and auth_token: # read pass from storage try: pw = gnomekeyring.item_get_info_sync(self.keyring, int(auth_token)).get_secret() except Exception, ex: print "ERROR: Unable to read password from keyring: %s" % ex pw = '' # return return (name, pw)
def change_secret(self, entry_id, secret): """Change secret for selected entry""" 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 information info = keyring.item_get_info_sync(self.KEYRING_NAME, entry_id) if info is not None: info.set_secret(secret) keyring.item_set_info_sync(self.KEYRING_NAME, entry_id, info) result = True return result
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 rename_entry(self, entry, new_name): """Rename entry""" 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 information entry_id = self.__get_entry_id(entry) info = keyring.item_get_info_sync(self.KEYRING_NAME, entry_id) if info is not None: info.set_display_name(new_name) keyring.item_set_info_sync(self.KEYRING_NAME, entry_id, info) result = True 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 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 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
# list names of keyrings and use the first one we can find keyring_list = gnomekeyring.list_keyring_names_sync() if len(keyring_list) == 0: print "No keyrings available." import sys sys.exit(1) else: print "We have %i keyrings" % len(keyring_list) print "KEYRING: %s" % keyring_list[0] # name/password to store name = 'myname' password = '******' # get default keyring keyring = gnomekeyring.get_default_keyring_sync( ) # crashes if no default exists # create attributes attribs = dict(name=name, magic='something') # create keyring item with password auth_token = gnomekeyring.item_create_sync( keyring, gnomekeyring.ITEM_GENERIC_SECRET, name, attribs, password, True) print auth_token print "save: token for account %s: %i" % (name, auth_token) token = "gnomekeyring:%i" % (auth_token, ) print token # now read it back from the keyring print "Password read from keyring is:" print gnomekeyring.item_get_info_sync(keyring, auth_token).get_secret()
def __init__(self): self.parse_options() #build GUI self.gladefile = "data/gtkvncviewer.glade" self.wTree = gtk.glade.XML(self.gladefile) self.dialog = self.wTree.get_widget("connectDialog") self.about = self.wTree.get_widget("aboutDialog") self.about.set_version(version) self.window = self.wTree.get_widget("window") self.window_label = self.wTree.get_widget("window_label") self.window_toolbar_note = self.wTree.get_widget("toolbar_note") self.window_toolbar = self.wTree.get_widget("toolbar") self.layout = self.wTree.get_widget("viewport1") self.scrolledwindow = self.wTree.get_widget("scrolledwindow1") self.fullscreenButton = self.wTree.get_widget("fullscreenButton") self.fullscreenButton.set_active(False) self.iconview = self.wTree.get_widget("iconview1") self.keysButton = self.wTree.get_widget("keysButton") self.keysMenu = self.wTree.get_widget("keysMenu") self.keysMenu.attach_to_widget(self.keysButton, None) self.vnc=gtkvnc.Display() self.model = gtk.ListStore (str,str,str,gtk.gdk.Pixbuf) self.iconview.set_model(self.model) self.iconview.set_text_column(0) self.iconview.set_pixbuf_column(3) self.helpMenu = self.wTree.get_widget("helpMenu") self.helpButton = self.wTree.get_widget("helpButton") self.helpMenu.attach_to_widget(self.helpButton, None) if (launchpad): LaunchpadIntegration.set_sourcepackagename("gtkvncviewer") LaunchpadIntegration.add_items(self.helpMenu,0,False,False) else: self.helpButton.set_sensitive(False) if (self.dialog): self.window.connect("destroy", gtk.main_quit) #Create our dictionay and connect it dic = { "on_quitButton_clicked" : gtk.main_quit, "on_aboutButton_clicked" : self.show_about_dialog, "on_aboutDialog_response" : self.handle_about_dialog_answer, "on_aboutDialog_delete_event" : self.hide_about_dialog, "on_connectButton_clicked" : self.vncconnect, "on_window_delete_event" : self.close_window, "on_disconnectButton_clicked" : self.disconnect, "on_addButton_clicked" : self.add_server, "on_iconview1_selection_changed" : self.selected, "on_iconview1_item_activated" : self.activated, "on_delButton_clicked" : self.delete_clicked, "on_screenshotButton_clicked" : self.screenshot, "on_helpButton_clicked" : self.helpMenuPop, "on_togglebutton1_toggled" : self.fullscreen, "on_toolbar_note_entered" : self.show_hide_toolbar, "on_window_motion_notify_event" : self.mouse_moved_in_window, "on_desktopIconButton_clicked" : self.icon_on_desktop, "on_CtrlAltDelmenuitem_activate": self.send_cad, "on_CtrlAltBackmenuitem_activate": self.send_cab, "on_CtrlEscmenuitem_activate": self.send_ce, "on_CtrlAltF1menuitem_activate": self.send_caf1, "on_CtrlAltF2menuitem_activate": self.send_caf2, "on_CtrlAltF3menuitem_activate": self.send_caf3, "on_CtrlAltF4menuitem_activate": self.send_caf4, "on_CtrlAltF5menuitem_activate": self.send_caf5, "on_CtrlAltF6menuitem_activate": self.send_caf6, "on_CtrlAltF7menuitem_activate": self.send_caf7, "on_CtrlAltF8menuitem_activate": self.send_caf8, "on_CtrlAltF9menuitem_activate": self.send_caf9, "on_CtrlAltF10menuitem_activate": self.send_caf10, "on_CtrlAltF11menuitem_activate": self.send_caf11, "on_CtrlAltF12menuitem_activate": self.send_caf12, "on_AltRlessitem_activate": self.send_arless, "on_AltRqitem_activate": self.send_arq, "on_AltRszligitem_activate": self.send_arszlig, "on_AltRplusitem_activate": self.send_arplus, "on_AltR7item_activate": self.send_ar7, "on_AltR8item_activate": self.send_ar8, "on_AltR9item_activate": self.send_ar9, "on_AltR0item_activate": self.send_ar0, "on_keysButton_clicked" : self.keysMenuPop} self.wTree.signal_autoconnect(dic) self.dialog.show() #read stored credentials GCONF_AUTH_KEY = "/apps/gtkvncviewer" keyring = gnomekeyring.get_default_keyring_sync() gconfclient = gconf.client_get_default() gconfclient.add_dir (GCONF_AUTH_KEY, gconf.CLIENT_PRELOAD_RECURSIVE) entries = gconfclient.all_entries(GCONF_AUTH_KEY) if len(entries) == 0: return #found nothing for i in range(len(entries)): server = entries[i].get_key() server = server.replace (GCONF_AUTH_KEY+"/", "") auth_token = entries[i].get_value().get_int() if auth_token > 0: try: secret = gnomekeyring.item_get_info_sync(keyring, auth_token).get_secret() except gnomekeyring.DeniedError: username = None password = None auth_token = 0 print _("gnome-keyring access denied") else: username, password = secret.split('\n') else: username = None password = None pixbuf = self.iconview.render_icon(gtk.STOCK_NETWORK, gtk.ICON_SIZE_BUTTON) self.model.append([server, username, password, pixbuf]) #if a server was specified at startup, connect to it if self.startup_options.server: res = self.find_server(self.startup_options.server) if (res): #found, connect iter = res[3] self.iconview.select_path(iter) wait() self.vncconnect(self.window) else: #not found, just fill the server name in the dialog server_textbox = self.wTree.get_widget("serverEntry") user_textbox = self.wTree.get_widget("usernameEntry") server_textbox.set_text(self.startup_options.server) user_textbox.grab_focus()
#!/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
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)