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