def test_keyring_populate(self):
attr = { 'token' : 'the-token',
'consumer-key' : 'the-consumer-key',
'usage' : 'software-center-agent-token',
}
secret = 'consumer_secret=xxx&token=xxx&consumer_key=xxx&token_secret=xxx&name=s-c'
keyring_names = gk.list_keyring_names_sync()
print keyring_names
self.assertFalse(self.KEYRING_NAME in keyring_names)
gk.create_sync(self.KEYRING_NAME, "")
keyring_names = gk.list_keyring_names_sync()
self.assertTrue(self.KEYRING_NAME in keyring_names)
res = gk.item_create_sync(self.KEYRING_NAME,
gk.ITEM_GENERIC_SECRET,
"Software Center Agent token",
attr,
secret,
True) # update if exists
self.assertTrue(res)
# get the token from the keyring using the 'usage' field
# in the attr
search_attr = { 'usage' : 'software-center-agent-token',
}
found = gk.find_items_sync(gk.ITEM_GENERIC_SECRET,
search_attr)
self.assertEqual(len(found), 1)
for item in found:
self.assertEqual(item.keyring, self.KEYRING_NAME)
#print item.item_id, item.attributes
self.assertEqual(item.secret, secret)
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 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 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 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 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 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 __init__(self, keyring="opensesame"):
"""Get OpenSesame keyring name stored in gconf
"""
self.keyring = keyring
self.default_keyring = gkr.get_default_keyring_sync()
if self.keyring not in gkr.list_keyring_names_sync():
self.first_time_setup()
self.unlock_keyring()
def keyring_exists(self): """Check if keyring exists""" result = False if self.is_available(): result = self.KEYRING_NAME in keyring.list_keyring_names_sync() 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)
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 get_keyrings():
l = []
for name in gkr.list_keyring_names_sync():
locked = gkr.get_info_sync(name).get_is_locked()
keyring = {"id": name, "locked": locked}
l.append(keyring)
return l
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_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 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 cmd_export_to_gnome_keyring():
"""Write out accounts to Gnome Keyring. Only useful for 'backup',
if you have keyring tools. There is currently no way to import
these keys back into kip.
Requires python2 and gnomekeyring lib.
Note that this does NOT make the passwords usable to Chrome - this is
not a counterpart to import_chrome_gnome_keyring.
"""
import time
import gnomekeyring as gk
import glib
glib.set_application_name('kip')
keyrings = gk.list_keyring_names_sync()
if not 'kip' in keyrings:
gk.create_sync('kip', None) # None means prompt user for password
for filename in glob.glob('{}/*'.format(HOME_PWD)):
user, pwd, notes = extract(filename)
domain = os.path.basename(filename)
print("Exporting {} ({})".format(domain, user))
"""
msg = "Export %s (%s)? [y|N]" % (domain, user)
try:
choice = raw_input(msg)
except NameError:
# python 3
choice = input(msg)
if choice.lower() != 'y':
print('Skipping')
continue
"""
attributes = {
"username": user.encode("utf8"),
"notes": notes.encode("utf8"),
"date_created": str(int(time.time())),
}
gk.item_create_sync('kip',
gk.ITEM_GENERIC_SECRET,
domain,
attributes,
pwd.encode("utf8"),
True)
def cmd_export_to_gnome_keyring():
"""Write out accounts to Gnome Keyring. Only useful for 'backup',
if you have keyring tools. There is currently no way to import
these keys back into kip.
Requires python2 and gnomekeyring lib.
Note that this does NOT make the passwords usable to Chrome - this is
not a counterpart to import_chrome_gnome_keyring.
"""
import time
import gnomekeyring as gk
import glib
glib.set_application_name('kip')
keyrings = gk.list_keyring_names_sync()
if not 'kip' in keyrings:
gk.create_sync('kip', None) # None means prompt user for password
for filename in glob.glob('{}/*'.format(HOME_PWD)):
user, pwd, notes = extract(filename)
domain = os.path.basename(filename)
print("Exporting {} ({})".format(domain, user))
"""
msg = "Export %s (%s)? [y|N]" % (domain, user)
try:
choice = raw_input(msg)
except NameError:
# python 3
choice = input(msg)
if choice.lower() != 'y':
print('Skipping')
continue
"""
attributes = {
"username": user.encode("utf8"),
"notes": notes.encode("utf8"),
"date_created": str(int(time.time())),
}
gk.item_create_sync('kip',
gk.ITEM_GENERIC_SECRET,
domain,
attributes,
pwd.encode("utf8"),
True)
def open_Keyring(self):
allowed = False
if self.supported()>=0 and G.is_available() :
_gnome_keyrings = G.list_keyring_names_sync()
allowed = True
try :
if self.appletName not in _gnome_keyrings :
self.prnt.createKeyring("%s: %s doesn`t exist"%(self.name, self.appletName))
return False
self.KEYRING_NAME = self.appletName
except Exception, err :
allowed = False
finally : pass
def __init__(self, clerk, keyring):
self.clerk = clerk
self.keyring = None
# check keyring daemon
if not gnomekeyring.is_available():
self.clerk.close_shop('Gnome Keyring Daemon is not available')
# check keyring
self.keyring = self.__find_fuzzy(keyring, gnomekeyring.list_keyring_names_sync())
if not self.keyring:
self.clerk.close_shop('There is no keyring with name "{}"'.format(
keyring))
def get_item_id():
global _item_id
if _item_id:
return _item_id
try:
results = gk.find_items_sync(gk.ITEM_GENERIC_SECRET, _attrs)
_item_id = results[0].item_id
except gk.NoMatchError:
# Check if ''_keyring'' has been created.
if _keyring not in gk.list_keyring_names_sync():
# if it is missing then create a new keyring called ''_keyring''
gk.create_sync(_keyring, _keyring)
# Create item
_item_id = gk.item_create_sync(_keyring, _type, _display_name, _attrs,
'', True)
return _item_id
def get_item_id():
global _item_id
if _item_id:
return _item_id
try:
results = gk.find_items_sync(gk.ITEM_GENERIC_SECRET, _attrs)
_item_id = results[0].item_id
except gk.NoMatchError:
# Check if ''_keyring'' has been created.
if _keyring not in gk.list_keyring_names_sync():
# if it is missing then create a new keyring called ''_keyring''
gk.create_sync(_keyring, _keyring)
# Create item
_item_id = gk.item_create_sync(_keyring, _type,
_display_name, _attrs, '', True)
return _item_id
def store_password(self,
entry,
password,
attributes=None,
entry_type=EntryType.GENERIC):
"""Create new entry in keyring with specified data"""
assert self.is_available()
# create a new keyring if it doesn't exist
if not self.KEYRING_NAME in keyring.list_keyring_names_sync():
dialog = PasswordDialog(self._application)
dialog.set_title(_('New keyring'))
dialog.set_label(
_('We need to create a new keyring to safely '
'store your passwords. Choose the password you '
'want to use for it.'))
response = dialog.get_response()
if response[0] == gtk.RESPONSE_OK \
and response[1] == response[2]:
# create new keyring
keyring.create_sync(self.KEYRING_NAME, response[1])
self.__update_info()
else:
# wrong password
raise KeyringCreateError('No keyring to store password to.')
# if keyring is locked, try to unlock it
if self.is_locked() and not self.__unlock_keyring():
return False
# store password to existing keyring
keyring.item_create_sync(
self.KEYRING_NAME,
self.KEYRING_TYPE[entry_type],
entry,
attributes if attributes is not None else {},
password,
True # update if exists
)
return True
def store_password(self, entry, password, attributes=None, entry_type=EntryType.GENERIC):
"""Create new entry in keyring with specified data"""
assert self.is_available()
# create a new keyring if it doesn't exist
if not self.KEYRING_NAME in keyring.list_keyring_names_sync():
dialog = PasswordDialog(self._application)
dialog.set_title(_('New keyring'))
dialog.set_label(_(
'We need to create a new keyring to safely '
'store your passwords. Choose the password you '
'want to use for it.'
))
response = dialog.get_response()
if response[0] == gtk.RESPONSE_OK \
and response[1] == response[2]:
# create new keyring
keyring.create_sync(self.KEYRING_NAME, response[1])
self.__update_info()
else:
# wrong password
raise KeyringCreateError('No keyring to store password to.')
# if keyring is locked, try to unlock it
if self.is_locked() and not self.__unlock_keyring():
return False
# store password to existing keyring
keyring.item_create_sync(
self.KEYRING_NAME,
self.KEYRING_TYPE[entry_type],
entry,
attributes if attributes is not None else {},
password,
True # update if exists
)
return True
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 __init__(self, group, name, *attr, **args):
super(AccountOption, self).__init__ (group, name, *attr, **args)
# check for availability of keyring
if not gnomekeyring.is_available():
raise Exception('GnomeKeyring is not available!!')
# THIS IS A WORKAROUND FOR A BUG IN KEYRING (usually we would use
# gnomekeyring.get_default_keyring_sync() here):
# find first available keyring
self.keyring_list = gnomekeyring.list_keyring_names_sync()
if len(self.keyring_list) == 0:
raise Exception('No keyrings found. Please create one first!')
else:
# we prefer the default keyring
try:
self.keyring = gnomekeyring.get_default_keyring_sync()
except:
if "session" in self.keyring_list:
print "Warning: No default keyring found, using session keyring. Storage is not permanent!"
self.keyring = "session"
else:
print "Warning: Neither default nor session keyring found, assuming keyring %s!" % self.keyring_list[0]
self.keyring = self.keyring_list[0]
def __init__(self):
self.keyring_name = 'proxywise'
self.__keyring_password = '******'
self.home = expanduser("~")
self.config_path = self.home + "/.config/proxywise"
self.config_file_name = self.config_path + "/config.json"
if not os.path.exists(self.config_path):
os.makedirs(self.config_path)
if not os.path.exists(self.config_file_name):
config_file = open(self.config_file_name, 'w')
json.dump( {
"active_profile": None,
"ignore_host_list": ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"]
}, config_file, sort_keys=True, indent=4, separators=(',', ': '))
config_file.close()
if not self.keyring_name in gk.list_keyring_names_sync():
gk.create_sync(self.keyring_name, self.__keyring_password)
self.Unlock()
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 __init__(self):
keyrings = gnomekeyring.list_keyring_names_sync()
if KEYRING_NAME not in keyrings:
gnomekeyring.create_sync(KEYRING_NAME, KEYRING_PASSWD)
keyring = gnomekeyring.list_item_ids_sync(KEYRING_NAME)
for user in CONFIG['accounts']:
user = user.encode('utf8')
found = False
for item in keyring:
gnomekeyring.unlock_sync(KEYRING_NAME, KEYRING_PASSWD)
info = gnomekeyring.item_get_info_sync(KEYRING_NAME, item)
gnomekeyring.lock_sync(KEYRING_NAME)
if user == info.get_display_name():
found = True
break
if not found:
self.save_user_credentials(user)
try:
import gnomekeyring as gk
keyring = 'gk'
except ImportError:
try:
import PyKDE4.kdeui.KWallet
keyring = 'kk'
except ImportError:
import PyMacAdmin.Security.Keychain
keyring = 'xk'
import glib
import objects
glib.set_application_name('gk_text')
if 'pycle' not in gk.list_keyring_names_sync():
gk.create_sync('pycle', 'pyclepass')
class Connection(object):
"""A database connection"""
def __init__(self, username, password, **params):
if 'key' in params:
self.key = params['key']
else:
self.key = None
if 'sid' in params:
self.sid = params['sid']
self.name = username + '@' + self.sid
elif 'host' in params:
self.host = params['host']
def check_exists(self, keyring):
return keyring in gk.list_keyring_names_sync()
def _keyring_exists(self): existing_keys = gk.list_keyring_names_sync() return (keyring_name in existing_keys)
def __init__(self, keyring = "truecrypt"):
self.keyring = keyring
if not keyring in gnomekeyring.list_keyring_names_sync():
password = getText()
gnomekeyring.create_sync(keyring, password)
def _first_time(self):
assert(self.keyring not in gkr.list_keyring_names_sync())
self.openkeyring = OpenKeyring(self.keyring)
assert(self.keyring in gkr.list_keyring_names_sync())
try:
import gnomekeyring
except ImportError:
HAVE_GNOMEKEYRING = False
else:
HAVE_GNOMEKEYRING = True
# TEST:
#import gobject
#gtk.set_application_name("keyring-test")
if HAVE_GNOMEKEYRING:
# check availability
if not gnomekeyring.is_available():
print "Keyring not available."
# 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')
def get_keyrings(self):
"""
Return keyring names list
"""
return gk.list_keyring_names_sync()
#!/usr/bin/python
import gnomekeyring
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
exit(-1)
try:
found = re.search('(?<=<INPUT type=hidden name=chalangeack value=)\w*',
login_page)
chalangeack = found.group(0)
except:
stderr.write("Error while manipulating login page.\
Maybe its format has changed.\n")
exit(-2)
if not gk.is_available():
print "Error with the keyring daemon."
exit(-100)
if not 'login' in gk.list_keyring_names_sync():
print "Error: no 'login' keyering. Edit the sources to select\
another keyring."
exit(-101)
creditals = get_creditals()
if creditals == None:
print "No login data found"
from getpass import getpass
login = getpass("Login: "******"Type YES to save them: ")
if save == 'YES':
create_pass(login, password)
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)
serv = imaplib.IMAP4_SSL(server, port)
# if your imap mail server doesn't use ssl comment the above
# line and uncomment this one.
# serv = imaplib.IMAP4(server,port)
serv.login(login, password)
serv.select(inbox)
data = str(serv.status(inbox, "(MESSAGES UNSEEN)"))
serv.close()
serv.logout()
# prepare regular expression
p = re.compile("(.*UNSEEN |\) '\]\))")
return int(p.sub("", data))
glib.set_application_name(APP_NAME)
keyrings = gk.list_keyring_names_sync()
if KEYRING_NAME not in keyrings:
print "Keyring", KEYRING_NAME, "not found"
exit()
if gk.get_info_sync(KEYRING_NAME).get_is_locked():
message = "Give password for keyring"
while True:
password = get_password(message)
if password is not None:
try:
gk.unlock_sync(KEYRING_NAME, password)
break
except gk.IOError:
message = "Password is wrong. Try again."
else:
def get_password():
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)
if item.get_display_name() == 'Mail':
return item.get_secret()
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)
try:
import gnomekeyring
except ImportError:
HAVE_GNOMEKEYRING = False
else:
HAVE_GNOMEKEYRING = True
# TEST:
#import gobject
#gtk.set_application_name("keyring-test")
if HAVE_GNOMEKEYRING:
# check availability
if not gnomekeyring.is_available():
print "Keyring not available."
# 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')
