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 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 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
