def store_password(self, datasource):
"""Update password.
If the gnomekeyring bindings are available, the password is stored
in the keyring. Otherwise it's stored in datasources.cfg.
It's assumed, that the data source has an ID. So, this method
*must* be called after the data source has been saved once.
:param datasource: A data source.
"""
if not USE_KEYRING:
return
item_type = gnomekeyring.ITEM_GENERIC_SECRET
attrs = {"crunchyfrog": datasource.id}
try:
entry = gnomekeyring.find_items_sync(item_type, attrs)
entry = entry[0]
except gnomekeyring.NoMatchError:
entry = None
if datasource.url.password is not None:
gnomekeyring.item_create_sync(None, item_type,
'crunchyfrog/%s' % datasource.id,
attrs, datasource.url.password, True)
elif entry is not None:
gnomekeyring.item_delete_sync(None, entry.item_id)
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 ask_password(self, method, key, message, first):
"""Query for a password."""
display_name = "submit password %s.%s" % (method, key)
attrs = dict(submit=1, method=method, key=key)
try:
# first try: perhaps the correct password is in the keyring
if first:
try:
items = gnomekeyring.find_items_sync(
gnomekeyring.ITEM_GENERIC_SECRET, attrs)
return items[0].secret
except gnomekeyring.NoMatchError:
pass
# no, it isn’t; show a dialog to get the password
password, store = self.password_dialog(
method, key, message, first, True)
if password is None: return None
if store:
gnomekeyring.item_create_sync(
self.keyring, gnomekeyring.ITEM_GENERIC_SECRET,
display_name, attrs, password, True)
return password
except gnomekeyring.DeniedError:
raise AuthenticationFailedError(
n_("Unable to access GNOME keyring."))
def set_credentials_msmtp(self,user,pw):
# display name for password.
display_name = '%s password for %s at %s' % ("MSMTP", user, self._server)
usr_attrs = {'user':user, 'server':_server, 'protocol':smtp}
# Now it gets ready to add into the keyring. Do it.
# Its id will be returned if success or an exception will be raised
gkey.item_create_sync(gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, display_name, attrs, pw, False)
def FinishLogin(self, username, password):
"""
Attempts to login in to confirm the given credentials.
If successful, the username is written to a local file for subsequent use
and the password is saved in the user's keyring (if available, or a local
file otherwise).
The GUI calls are done using gobject.idle_add() to assure they're
within the main gtk thread.
"""
self.freeSound.Login(username, password)
if self.freeSound.loggedIn:
self.api.set_config_value("fsUsername", username)
if keyring:
gkey.item_create_sync(gkey.get_default_keyring_sync(),
gkey.ITEM_NETWORK_PASSWORD,
EXTENSION_DATA_NAME,
{"username": username}, password, True)
else:
self.api.set_config_value("fsPassword", password)
gobject.idle_add(self.loginWindow.destroy)
if self.showSearch:
self.showSearch = False
gobject.idle_add(self.OnMenuItemClick)
else:
gobject.idle_add(self.loginWindow.destroy)
if self.retryLogin:
gobject.idle_add(self.LoginDetails, _("Login failed!"))
def set_password(plugin_id, username, password):
kr_name = gnomekeyring.get_default_keyring_sync()
attrs = {'username': username, 'plugin_id': plugin_id}
gnomekeyring.item_create_sync(
kr_name, gnomekeyring.ITEM_GENERIC_SECRET,
_("Password for %s in %s (Kupfer)") %
(username, plugin_id), attrs, password, True)
def _GetNameAndPassword(self):
"""Display a modal dialog asking for a name and password.
This info is used for login when deploying the applications; it is
saved in GNOME keyring.
Returns:
wx.ID_OK or wx.ID_CANCEL
"""
self._ConfigureDialog()
rtn = self.dialog.ShowModal()
if rtn == wx.ID_OK:
self._authname = str(self.dialog.name_text_ctrl.GetValue())
self._password = self.dialog.password_text_ctrl.GetValue()
# Store information in keyring
try:
items = gk.find_items_sync(gk.ITEM_NETWORK_PASSWORD, self._gkAttr)
for item in items:
if item.attributes["user"] != self._authname:
gk.item_delete_sync('login', item.item_id)
except gk.NoMatchError:
pass
self._gkAttr["user"] = self._authname
gk.item_create_sync('login', gk.ITEM_NETWORK_PASSWORD, 'Google App Engine Credentials', self._gkAttr, self._password, True)
return rtn
def FinishLogin(self, username, password):
"""
Attempts to login in to confirm the given credentials.
If successful, the username is written to a local file for subsequent use
and the password is saved in the user's keyring (if available, or a local
file otherwise).
The GUI calls are done using gobject.idle_add() to assure they're
within the main gtk thread.
"""
self.freeSound.Login(username, password)
if self.freeSound.loggedIn:
self.api.set_config_value("fsUsername", username)
if keyring:
gkey.item_create_sync(gkey.get_default_keyring_sync(),
gkey.ITEM_NETWORK_PASSWORD,
EXTENSION_DATA_NAME,
{"username" : username},
password,
True)
else:
self.api.set_config_value("fsPassword", password)
gobject.idle_add(self.loginWindow.destroy)
if self.showSearch:
self.showSearch = False
gobject.idle_add(self.OnMenuItemClick)
else:
gobject.idle_add(self.loginWindow.destroy)
if self.retryLogin:
gobject.idle_add(self.LoginDetails, _("Login failed!"))
def add_user(self, username, password, uri, labels=None, timeout=None):
atts = {'uri': uri, 'labels': labels, 'timeout': timeout}
key,item = self.search_user(username)
if item is not None:
self.delete_user(key=key)
gk.item_create_sync(self._app_name, gk.ITEM_GENERIC_SECRET, username, \
atts, password, True)
def set_credentials(self, user, pw):
attrs = {
"user": user,
"server": self._server,
"protocol": self._protocol,
}
gkey.item_create_sync(gkey.get_default_keyring_sync(),
gkey.ITEM_NETWORK_PASSWORD, self._name, attrs, pw, True)
def entry_passwd_to_keyrings(keyring_name,servername,username,passwd):
atts = {
'application' : 'Python mail notification',
'username' : username,
'server' : servername,
}
gk.item_create_sync(keyring_name, gk.ITEM_GENERIC_SECRET,
servername,atts,passwd,True)
def create_sync(self, server_info):
gk.item_create_sync(
'GKApp',
gk.ITEM_NETWORK_PASSWORD,
server_info["user"] + "@" + server_info["host"] + ":" + server_info["port"], # This is the description and a unique identifier of the keyring item
server_info.pop("pass"), # This is the complete information about the stored connection without the password
server_info["pass"], # This is the password of the stored connection
True) # update if exists with same description and attributes
def set_password(plugin_id, username, password):
kr_name = gnomekeyring.get_default_keyring_sync()
attrs = {'username': username, 'plugin_id': plugin_id}
gnomekeyring.item_create_sync(kr_name,
gnomekeyring.ITEM_GENERIC_SECRET,
_("Password for %s in %s (Kupfer)") % (username,
plugin_id),
attrs, password, True)
def set_credentials(self, user, pw, key=""):
attrs = {
"user": user,
"server": self._host,
"protocol": self._protocol,
"key": key,
}
gnomekeyring.item_create_sync(gnomekeyring.get_default_keyring_sync(),
gnomekeyring.ITEM_NETWORK_PASSWORD, self._realm, attrs, pw, True)
def set_credentials(self, user, pw):
# Ensure the arguments are simple strings; it can't handle unicode.
user, pw = str(user), str(pw)
if self.has_credentials() and self.get_credentials() == (user, pw):
return
attrs = {"user": user, "server": self._server}
gkey.item_create_sync(gkey.get_default_keyring_sync(), self._type, self._name, attrs, pw, True)
def set_password(self, pw):
attrs = {
"user": self._user,
"server": self._server,
"protocol": self._protocol,
}
gkey.item_create_sync(gkey.get_default_keyring_sync(),
gkey.ITEM_NETWORK_PASSWORD, self._name, attrs,
pw, True)
def set_credentials(self, username, password, server, email_address=None):
self._clear()
print "Inserting new entry..."
attrs = {"key": self._key, "user": username, "server": server, "protocol": self._protocol}
if email_address:
attrs["email_address"] = email_address
gkey.item_create_sync(
gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD, self._owner, attrs, password, True
)
def store_secret(keyring, item_name, secret):
# The last 3 params are: attributes, secret, update_if_exists.
# 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)
def save(self):
if keyring == 'gk':
try:
gk.item_create_sync('pycle', gk.ITEM_GENERIC_SECRET, self.name, {'username': self.username, 'sid': self.sid}, self.password, True)
except AttributeError:
gk.item_create_sync('pycle', gk.ITEM_GENERIC_SECRET, self.name, {'username': self.username, 'host': self.host}, self.password, True)
elif keyring == 'kk':
pass
elif keyring == 'xk':
pass
def set_credentials(repo, user, pw):
KEYRING_NAME = "offlineimap"
if isinstance(repo, list):
repo = repo[0]
if isinstance(user, list):
user = user[0]
attrs = { "repo": repo, "user": user }
keyring = gkey.get_default_keyring_sync()
print "Set password in keyring [{}] using {}"\
.format(KEYRING_NAME, attrs)
gkey.item_create_sync(keyring, gkey.ITEM_NETWORK_PASSWORD,
KEYRING_NAME, attrs, pw, True)
def set_keychain_pass(protocol, server, user, password):
if sys.platform != 'linux2':
raise Exception('Only Linux is supported for setting passwords.')
attrs = {'user': user,
'server': server,
'protocol': protocol}
name = 'offlineimap ' + server
gkey.item_create_sync(gkey.get_default_keyring_sync(),
gkey.ITEM_NETWORK_PASSWORD,
name, attrs, password, True)
def set_credentials(repo, user, pw):
KEYRING_NAME = "offlineimap"
if isinstance(repo, list):
repo = repo[0]
if isinstance(user, list):
user = user[0]
attrs = {"repo": repo, "user": user}
keyring = gkey.get_default_keyring_sync()
print "Set password in keyring [{}] using {}"\
.format(KEYRING_NAME, attrs)
gkey.item_create_sync(keyring, gkey.ITEM_NETWORK_PASSWORD, KEYRING_NAME,
attrs, pw, True)
def set_keychain_pass(protocol, server, user, password):
if sys.platform != 'linux2':
raise Exception('Only Linux is supported for setting passwords.')
attrs = {'user': user,
'server': server,
'protocol': protocol}
name = 'offlineimap ' + server
gkey.item_create_sync(gkey.get_default_keyring_sync(),
gkey.ITEM_NETWORK_PASSWORD,
name, attrs, password, True)
def set_password(self, service, username, password):
"""Set password for the username of the service
"""
try:
gnomekeyring.item_create_sync(
self.KEYRING_NAME, gnomekeyring.ITEM_NETWORK_PASSWORD,
"Password for '%s' on '%s'" % (username, service),
{'user': username, 'domain': service},
password, True)
except gnomekeyring.CancelledError:
# The user pressed "Cancel" when prompted to unlock their keyring.
raise PasswordSetError("cancelled by user")
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 set_password(self, service, username, password):
"""Set password for the username of the service
"""
try:
gnomekeyring.item_create_sync(
self.KEYRING_NAME, gnomekeyring.ITEM_NETWORK_PASSWORD,
"Password for '%s' on '%s'" % (username, service), {
'user': username,
'domain': service
}, password, True)
except gnomekeyring.CancelledError:
# The user pressed "Cancel" when prompted to unlock their keyring.
raise PasswordSetError("cancelled by user")
def set_details(self, usr, pwd):
""" Set the account details with a username and password """
try:
item = self.__get_item()
if item is not None:
self.__set_usr(usr, item)
self.__set_pwd(pwd, item)
else:
attrs = {"username" : str(usr)}
gk.item_create_sync(self.NAME, self.TYPE,
self.ITEM, attrs, pwd, True)
except self.GK_EXCEPT as e:
raise AccountError(repr(e))
def set_credentials(self, user, password):
"""
Set a key.
"""
attrs = {
"user": user,
"server": self._server,
"protocol": self._protocol,
}
gkey.item_create_sync(
gkey.get_default_keyring_sync(), gkey.ITEM_NETWORK_PASSWORD,
"%s://%s@%s" % (attrs["protocol"], attrs["user"], attrs["server"]),
attrs, password, True)
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 set_password(self, key, password, _folder = None):
if not G.is_available() :
self.prnt.Parent.eventNotification("%s not available." % self.name)
return None
folder = to_unicode(_folder) if _folder else self.appletName
try:
G.item_create_sync(
self.KEYRING_NAME, G.ITEM_NETWORK_PASSWORD,
"Password for '%s' in '%s'" % (to_unicode(key), folder),
{'user': to_unicode(key), 'domain': folder},
to_unicode(password), True)
except G.CancelledError:
raise PasswordSetError("cancelled by user")
finally : pass
def set_password(username, server, password):
attrs = {
'user':username,
'server':server,
'protocol':'imap'
}
gkey.item_create_sync(
gkey.get_default_keyring_sync(),
gkey.ITEM_NETWORK_PASSWORD,
'Mail-Password %s' % server,
attrs,
password,
True
)
def __storeAuthInfo(id, login, passwd):
""" Store the login/password associated with id, either in the Gnome keyring or in the prefs """
try:
import gnomekeyring as gk
useGK = True
except:
useGK = False
# No Gnome keyring
if not useGK:
prefs.set(__name__, id + '_login', login)
prefs.set(__name__, id + '_passwd', b64encode(passwd)) # Pretty useless, but the user prefers not to see his password as clear text
return
# From here we can use the Gnome keyring
__loadKeyring()
try:
label = '%s (%s)' % (consts.appName, id)
authInfo = '\n'.join((login, passwd))
token = gk.item_create_sync(__keyring, gk.ITEM_GENERIC_SECRET, label, {'appName': consts.appName, 'id': id}, authInfo, True)
prefs.set(__name__, id + '_gkToken', token)
except:
pass
class Keyring(object):
#
# Original author: http://www.rittau.org/blog/20070726-01
# Original code: http://www.rittau.org/gnome/python/keyring.py
#
def __init__(self, name, server, protocol):
self._name = name
self._server = server
self._protocol = protocol
self._keyring = gkey.get_default_keyring_sync()
def has_credentials(self):
try:
attrs = {"server": self._server, "protocol": self._protocol}
items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs)
return len(items) > 0
except gkey.DeniedError:
return False
def get_credentials(self):
attrs = {"server": self._server, "protocol": self._protocol}
items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs)
return (items[0].attributes["user"], items[0].secret)
def set_credentials(self, (user, pw)):
attrs = {
"user": user,
"server": self._server,
"protocol": self._protocol,
}
gkey.item_create_sync(gkey.get_default_keyring_sync(),
gkey.ITEM_NETWORK_PASSWORD, self._name, attrs,
pw, True)
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 put_in_keyring(self, acctid, name, value):
id = "%s/%s" % (acctid, name)
return gnomekeyring.item_create_sync(
gnomekeyring.get_default_keyring_sync(),
gnomekeyring.ITEM_GENERIC_SECRET,
"Gwibber preference: %s" % id,
{"id": str(id)}, str(value), True)
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 put_pass(self, username, password, server):
keyring_type = gk.ITEM_NETWORK_PASSWORD
display_name = '%s password for %s at %s' % (self.app.upper(), username, server)
usr_attrs = {'user': username, 'server': server, 'protocol': self.protocol}
id = gk.item_create_sync(self.keyring, keyring_type,
display_name, usr_attrs, password, False)
return id is not None
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 _set_password_to_keyring(self):
if self.username == "":
return False
keyring = gnomekeyring.get_default_keyring_sync()
display_name = "HTTP secret for %s at twitter.com" % (self.username)
type = gnomekeyring.ITEM_NETWORK_PASSWORD
# just a utility function to create attrs easily.
def parse(s):
ret = {}
try:
ret = dict([(k, v) for k, v in [x.split(":") for x in s.split(",")] if k and v])
except ValueError:
pass
return ret
# create attrs :: {} (dict)
attrs = {
"user": None,
"domain": None,
"server": None,
"object": None,
"protocol": None,
"authtype": None,
"port": None,
}
usr_attrs = parse("server:twitter.com,user:%s,protocol:http" % (self.username))
attrs.update(usr_attrs)
try:
id = gnomekeyring.item_create_sync(keyring, type, display_name, usr_attrs, self.password, True)
except gnomekeyring.Error, e:
return False
class Keyring(object):
def __init__(self, name, server, protocol):
self._name = name
self._server = server
self._protocol = protocol
self._keyring = 'imap'
def has_credentials(self):
try:
attrs = {"server": self._server, "protocol": self._protocol}
items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs)
return len(items) > 0
except gkey.DeniedError:
return False
def get_password(self, user):
attrs = {
"server": self._server,
"protocol": self._protocol,
"user": user
}
items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs)
return items[0].secret
def set_credentials(self, (user, pw)):
attrs = {
"user": user,
"server": self._server,
"protocol": self._protocol,
}
gkey.item_create_sync(self._keyring, gkey.ITEM_NETWORK_PASSWORD,
self._name, attrs, pw, True)
def set_password(self, key_name, user, password):
return gnomekeyring.item_create_sync(self.keyring_name,
gnomekeyring.ITEM_GENERIC_SECRET,
key_name, {
"user": user,
"key_name": key_name
}, password, True)
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
class Keyring(object):
def __init__(self, name, server, protocol): #instead of server we use mail for offlineimap
self._name = name
self._server = server
self._protocol = protocol
self._keyring = gkey.get_default_keyring_sync()
def has_credentials(self):
try:
attrs = {"server": self._server, "protocol": self._protocol}
items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs)
return len(items) > 0
except gkey.DeniedError:
return False
def get_credentials(self):
attrs = {"server": self._server, "protocol": self._protocol}
items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs)
return (items[0].attributes["user"], items[0].secret)
#def set_credentials(self, (user, pw)):
def set_credentials(self, (user, pw)):
attrs = {
"user": user,
"server": self._server,
"protocol": self._protocol,
}
gkey.item_create_sync(gkey.get_default_keyring_sync(),
gkey.ITEM_NETWORK_PASSWORD, self._name, attrs, pw, True)
def store_login(self, kind, username, url, password):
if not password:
self.remove_logins(kind, username, url)
return
_logger.debug("storing login (%s, %s, %s)" % (kind, username, url))
if not self.is_available():
found = None
for ki in self.__fallback_items:
if ki.get_kind() == kind and \
ki.get_username() == username and \
ki.get_url() == url:
found = ki
if found:
found.set_password(password)
else:
ki = KeyringItem(kind=kind,
username=username,
url=url,
password=password)
self.__fallback_items.add(ki)
else:
keyring_item_id = gnomekeyring.item_create_sync('session',
gnomekeyring.ITEM_GENERIC_SECRET,
"BigBoard",
dict(appname="BigBoard",
kind=kind,
username=username,
url=url),
password, True)
def imei_cb(imei):
gconf_key = "/apps/%s/%s/keyring_auth_token" % (slug, imei)
auth_token = gnomekeyring.item_create_sync(
self.keyring, gnomekeyring.ITEM_GENERIC_SECRET,
"%s secrets!" % APP_LONG_NAME, dict(appname=APP_LONG_NAME),
str(pin), True)
gconf.client_get_default().set_int(gconf_key, auth_token)
return auth_token
def set_password_in_gnome_keyring(user, server, protocol):
print 'It looks like this is the first time you run %s' % get_app()
print 'with the user "%s" at server "%s" using protocol "%s"' % (
user, server, protocol)
password_match = False
while not password_match:
password1 = getpass.getpass('Enter password: '******'Enter password again: ')
password_match = password1 == password2
if not password_match:
print 'Passwords do not match. Please, enter them again'
keyring = gnomekeyring.get_default_keyring_sync()
display_name = '%s password for %s at %s' % (get_app(), user, server)
attrs = {'user': user, 'server': server, 'protocol': protocol}
gnomekeyring.item_create_sync(keyring, gnomekeyring.ITEM_NETWORK_PASSWORD,
display_name, attrs, password1, False)
return password1
def add_item(user, password, server, protocol):
description = '%s password for %s at %s' % (protocol, user, server)
type = gkey.ITEM_NETWORK_PASSWORD
usr_attrs = {'user' : user,
'server' : server,
'protocol' : protocol}
id = gkey.item_create_sync(keyring, type, description, usr_attrs, password, False)
return id is not None
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 save_key(self, response_id, data):
try:
if data != gtk.RESPONSE_ACCEPT:
# User cancelled. They can ask for the password again somehow.
return
content = self.password_dialog.get_content_area()
key_id = content.get_children()[0].get_children()[1].get_text()
secret_key = content.get_children()[1].get_children()[1].get_text()
creds = AWSCredentials(access_key=key_id, secret_key=secret_key)
self.create_client(creds)
gnomekeyring.item_create_sync(None,
gnomekeyring.ITEM_GENERIC_SECRET,
"AWS access credentials",
{"aws-host": "aws.amazon.com"},
"%s:%s" % (key_id, secret_key), True)
finally:
self.password_dialog.hide()
# XXX? Does this leak?
self.password_dialog = None
def on_export(self, value):
"""Export the given tuple/list containing a username and a password. The
function stores the password in the gnomekeyring and returns a
string in form 'username:auth_token'."""
# store password in storage
attribs = dict(name=value[0])
auth_token = gnomekeyring.item_create_sync(self.keyring,
gnomekeyring.ITEM_GENERIC_SECRET, value[0], attribs, value[1], True)
# build value from username and auth_token
return value[0] + ':' + str(auth_token)
def put_pass(self, username, password, server):
keyring_type = gk.ITEM_NETWORK_PASSWORD
display_name = '%s password for %s at %s' % (self.app.upper(),
username, server)
usr_attrs = {
'user': username,
'server': server,
'protocol': self.protocol
}
id = gk.item_create_sync(self.keyring, keyring_type, display_name,
usr_attrs, password, False)
return id is not None
def create(self):
''' Create a new keyring item.
Return True if item created successfully, False otherwise.
'''
try:
id = gk.item_create_sync(self.keyring, self.item_type, self.name,
self.params, self.secret, False)
except gk.Error, e:
print >> sys.stderr, 'Error creating keyring item!\nDetails:\n%s' % e
return False
def add_secret(self, secret):
_id = None
try:
_id = gnomekeyring.item_create_sync(
self.keyring, gnomekeyring.ITEM_GENERIC_SECRET,
secret.get_name(), secret.get_attributes(),
secret.get_secret(), True)
except:
logging.exception("Failed to add keyring secret")
return _id
def store_password(self, scheme, host, username, password):
"""Return the password of username@root."""
self.clear_password(scheme, host, username)
try:
item_id = gnomekeyring.item_create_sync(
None, gnomekeyring.ITEM_NETWORK_PASSWORD, host, {
"user": username,
"protocol": scheme,
"server": host
}, password, True)
except (gnomekeyring.CancelledError,
gnomekeyring.NoKeyringDaemonError):
pass
self.item_ids[(scheme, host, username)] = (None, item_id)
