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 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 __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 _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 __init__(self, keyring_name):
"""
Initialize a new instance of PasswordManager bound to the specified
keyring.
Throws a NoPassSetException if a new keyring should be created but no
password is set by the user.
"""
self.keyring_name = keyring_name
if not self._keyring_exists:
# We want to create a new keyring and therefore we need
# a password. We open an inputbox to ask the user for a
# new password. We will ask twice because we need a validation
# that the user entered the password correct.
PASSWORD_MSG = "Enter a new password for the keyring to be created"
PASSWORD_MSG_RETRY = "The passwords don't match. Please retry"
while True:
# We ask the user for a new password. We will ask twice for a
# password so we can validate that the user made no typo.
# If the user aborts the process we raise a NoPassSetException
frist_attempt = inputbox("Create new keyring for gcm", PASSWORD_MSG)
if first_attempt == False:
raise NoPassSetException
second_attempt = inputbox("Create new keyring for gcm", "Re-enter your password!")
password_correct = (first_attempt == second_attempt)
if password_correct:
newpassword = first_attempt
break
else:
PASSWORD_MSG = PASSWORD_MSG_RETRY
gk.create_sync(self.keyring_name, newpassword)
gk.set_lock_timeout(self.keyring_name, 60)
gk.set_lock_on_idle(self.keyring_name, True)
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 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 __init__(self):
self.keyring = None
if not haveKeyring:
return
try:
self.keyring = gnomekeyring.get_default_keyring_sync()
if self.keyring == None:
# Code borrowed from
# http://trac.gajim.org/browser/src/common/passwords.py
self.keyring = 'default'
try:
gnomekeyring.create_sync(self.keyring, None)
except gnomekeyring.AlreadyExistsError:
pass
except:
logging.exception("Error determining keyring")
self.keyring = None
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 __init__(self):
self.keyring = None
if not haveKeyring:
return
try:
self.keyring = gnomekeyring.get_default_keyring_sync()
if self.keyring == None:
# Code borrowed from
# http://trac.gajim.org/browser/src/common/passwords.py
self.keyring = 'default'
try:
gnomekeyring.create_sync(self.keyring, None)
except gnomekeyring.AlreadyExistsError:
pass
except:
logging.exception("Error determining keyring")
self.keyring = None
def first_time_setup(self):
"""First time running Open Sesame?
Create keyring and an auto-unlock key in default keyring. Make sure
these things don't already exist.
"""
if not self._auto_unlock_key_position():
pw = password.create_passwords()[0]
attrs = {'application': self.keyring}
gkr.item_create_sync(self.default_keyring
,gkr.ITEM_GENERIC_SECRET
,self.keyring
,attrs
,pw
,True)
found_pos = self._auto_unlock_key_position()
item_info = gkr.item_get_info_sync(self.default_keyring, found_pos)
gkr.create_sync(self.keyring, item_info.get_secret())
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 __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 __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)
def create_app(self):
if self._app_name not in gk.list_keyring_names_sync():
gk.create_sync(self._app_name, self._app_pass)
# from the docs: "update_if_exists: If true, then another item matching
# the type, and attributes will be updated instead of creating a new item."
# So we either store unique attributes with each, or set update_if_exists
# to False.
# If we do both, additional keys with the same name and different IDs
# will get created.
gnomekeyring.item_create_sync(keyring, gnomekeyring.ITEM_GENERIC_SECRET,
item_name, {'name': item_name}, secret, True)
if __name__ == '__main__':
args = parse_args()
'''Sometimes the 'login' keyring is not automatically marked as default
(the user needs to do it manually). If no keyring is marked as default,
fall back to the 'login' keyring.'''
default_keyring = gnomekeyring.get_default_keyring_sync() or 'login'
keyring_pass = get_secret(default_keyring, args.keyring)
if not keyring_pass:
keyring_pass = getpass.getpass(
'New password for keyring ' + args.keyring + ': ')
gnomekeyring.create_sync(args.keyring, keyring_pass)
store_secret(default_keyring, args.keyring, keyring_pass)
gnomekeyring.unlock_sync(args.keyring, keyring_pass)
secret = get_secret(args.keyring, args.item_name)
if not secret:
secret = getpass.getpass('New password for ' + args.item_name + ': ')
store_secret(args.keyring, args.item_name, secret)
print(secret)
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']
self.name = username + '@' + self.host
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 create_Keyring(self, password = None): try : G.create_sync(self.appletName, to_unicode(password)) except Exception, err : print "[ In GnomeKeyring.create_Keyring() ]: ", err
def create_keyring(self,keyring,password):
"""
Create a new keyring with given name and password
"""
gk.create_sync(keyring,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)
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)