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!"))
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 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 password(self):
n = self._password
if n is None:
if gtkpresence:
try:
keyring = gnomekeyring.get_default_keyring_sync()
keyring_info = gnomekeyring.get_info_sync(keyring)
if keyring_info.get_is_locked():
nof_tries = 3
for i in range(nof_tries):
keyring_pass = getpass("Enter password to unlock your default keychain: ")
try:
gnomekeyring.unlock_sync(keyring, keyring_pass)
break
except gnomekeyring.DeniedError:
if i + 1 == nof_tries:
sys.stderr.write("\nFailed to unlock keychain (%s times)\n" % (i + 1))
else:
sys.stderr.write("\nInvalid password, try again...\n")
items = gnomekeyring.find_items_sync(
gnomekeyring.ITEM_NETWORK_PASSWORD,
{"server": self.server, "protocol": "ftp", "user": self.username},
)
if len(items) > 0:
n = items[0].secret
except gnomekeyring.DeniedError:
sys.stderr.write("\nGnome keyring error : Access denied ..\n")
except gnomekeyring.NoMatchError:
sys.stderr.write("\nGnome keyring error : No credential for %s..\n" % self.server)
except Exception, msg:
sys.stderr.write("\nGnome keyring error : %s\n" % (msg))
sys.stderr.flush()
if n is None:
n = getpass("Enter password for ftp://%s@%s: " % (self.username, self.server))
self._password = n
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 password(self):
n = self._password
if n is None:
if gtkpresence:
try:
keyring = gnomekeyring.get_default_keyring_sync()
keyring_info = gnomekeyring.get_info_sync(keyring)
if keyring_info.get_is_locked():
nof_tries = 3
for i in range(nof_tries):
keyring_pass = getpass('Enter password to unlock your default keychain: ')
try:
gnomekeyring.unlock_sync(keyring, keyring_pass)
break
except gnomekeyring.DeniedError:
if i+1==nof_tries:
sys.stderr.write('\nFailed to unlock keychain (%s times)\n' % (i+1))
else:
sys.stderr.write("\nInvalid password, try again...\n")
items = gnomekeyring.find_items_sync(gnomekeyring.ITEM_NETWORK_PASSWORD,
{"server": self.server,
"protocol": "ftp",
"user": self.username})
if len(items) > 0:
n = items[0].secret
except gnomekeyring.DeniedError:
sys.stderr.write("\nGnome keyring error : Access denied ..\n")
except gnomekeyring.NoMatchError:
sys.stderr.write("\nGnome keyring error : No credential for %s..\n" % self.server)
except Exception, msg:
sys.stderr.write("\nGnome keyring error : %s\n" % (msg))
sys.stderr.flush()
if n is None:
n = getpass('Enter password for ftp://%s@%s: ' % (self.username, self.server))
self._password = n
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_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)
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 _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
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 connect(self):
try:
auth = netrc().authenticators(self.host)
# TODO check if the host exists in netrc
except IOError as msgio:
if gtkpresence:
try:
keyring = gnomekeyring.get_default_keyring_sync()
keyring_info = gnomekeyring.get_info_sync(keyring)
if keyring_info.get_is_locked():
keyring_pass = getpass('Enter password to unlock your '
'keychain [%s]: ' % (keyring))
try:
gnomekeyring.unlock_sync(keyring, keyring_pass)
except Exception as msg:
sys.stderr.write("\nUnable to unlock your "
"keychain: %s\n" % msg)
else:
_log().debug("+ [%s] unlocked." % keyring)
itempass = gnomekeyring.ITEM_NETWORK_PASSWORD
pars = {
"server": self.host,
"protocol": "ftp",
"user": self.user
}
items = gnomekeyring.find_items_sync(
itempass, pars)
if len(items) > 0:
ftp = ftplib.FTP(self.host, self.user,
items[0].secret)
else:
raise Exception('gnomekeyring', 'NoMatchError')
except gnomekeyring.DeniedError:
sys.stderr.write("\nGnome keyring error : "
"Access denied ..\n"
"netrc error: %s\n" % (msgio))
sys.exit(1)
except gnomekeyring.NoMatchError:
sys.stderr.write("\nGnome keyring error : "
"No credential for %s..\n"
"netrc error: %s\n" % (self.host, msgio))
sys.exit(1)
except Exception as msg:
sys.stderr.write("\nGnome keyring error : %s\n"
"netrc error: %s\n" % (msg, msgio))
sys.exit(1)
else:
assert self.user == auth[0]
ftp = ftplib.FTP()
ftp.connect(self.host, self.port)
ftp.login(auth[0], auth[2])
try:
ftp.cwd(self.path)
except ftplib.error_perm:
ftp.mkd(self.path)
ftp.cwd(self.path)
self.ftp = ftp
self.dirs = set()
def connect(self):
try:
auth = netrc().authenticators(self.host)
# TODO check if the host exists in netrc
except IOError as msgio:
if gtkpresence:
try:
keyring = gnomekeyring.get_default_keyring_sync()
keyring_info = gnomekeyring.get_info_sync(keyring)
if keyring_info.get_is_locked():
keyring_pass = getpass('Enter password to unlock your '
'keychain [%s]: ' % (keyring))
try:
gnomekeyring.unlock_sync(keyring, keyring_pass)
except Exception as msg:
sys.stderr.write("\nUnable to unlock your "
"keychain: %s\n" % msg)
else:
_log().debug("+ [%s] unlocked." % keyring)
itempass = gnomekeyring.ITEM_NETWORK_PASSWORD
pars = {
"server": self.host,
"protocol": "ftp",
"user": self.user
}
items = gnomekeyring.find_items_sync(
itempass, pars)
if len(items) > 0:
ftp = ftplib.FTP(self.host, self.user,
items[0].secret)
else:
raise Exception('gnomekeyring', 'NoMatchError')
except gnomekeyring.DeniedError:
sys.stderr.write("\nGnome keyring error : "
"Access denied ..\n"
"netrc error: %s\n" % (msgio))
sys.exit(1)
except gnomekeyring.NoMatchError:
sys.stderr.write("\nGnome keyring error : "
"No credential for %s..\n"
"netrc error: %s\n" % (self.host, msgio))
sys.exit(1)
except Exception as msg:
sys.stderr.write("\nGnome keyring error : %s\n"
"netrc error: %s\n" % (msg, msgio))
sys.exit(1)
else:
assert self.user == auth[0]
ftp = ftplib.FTP()
ftp.connect(self.host, self.port)
ftp.login(auth[0], auth[2])
try:
ftp.cwd(self.path)
except ftplib.error_perm:
ftp.mkd(self.path)
ftp.cwd(self.path)
self.ftp = ftp
self.dirs = set()
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 __init__(self, name, server=None, protocol=None):
self.name = name
self.attributes = {}
if server: self.attributes['server'] = server
if protocol: self.attributes['protocol'] = protocol
self.scheme = gkey.ITEM_NETWORK_PASSWORD
self.keyring = gkey.get_default_keyring_sync()
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 __init__(self, name, server, protocol, setName=False): if setName: import gobject gobject.set_application_name (name) self._name = name self._server = server self._protocol = protocol self._keyring = gkey.get_default_keyring_sync()
def __init__(self):
# get default keyring name
try:
self.keyring = gk.get_default_keyring_sync()
except gk.nokeyringdaemonerror:
print("err: can't open gnome keyring")
print("are you running this program under a gnome session ?")
sys.exit(-1)
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 __init__(self, name, server=None, protocol=None):
self.name = name
self.attributes = {}
if server: self.attributes['server'] = server
if protocol: self.attributes['protocol'] = protocol
self.scheme = gkey.ITEM_NETWORK_PASSWORD
self.keyring = gkey.get_default_keyring_sync()
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_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 __init__(self, name):
"""name - application name"""
self.__name = name
self.__keyring = gkey.get_default_keyring_sync()
# for transiton only. Remove somwhere around april 2011
self._override_old_passwords({"Rapidshare": "http",
"Imageshack": "http",
"Twitpic": "http",
"proxy": 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 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 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 create(self, name, attrs, secret, keyring=gk.get_default_keyring_sync(), force=False):
self.check_attributes(attrs)
attrs2 = self.del_empty_attributes(attrs)
if not force and self.find(attrs, True) != []:
logging.warn(" Secret already exists for display_name = '%s', attrs = '%s'" % (name, str(attrs)))
return -1
return gk.set_network_password_sync(keyring, password=secret, **attrs2)
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 delete_credentials(self):
attrs = {
"server": self._server,
"protocol": self._protocol,
"user": self._user
}
items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs)
id = items[0].item_id
gkey.item_delete_sync(gkey.get_default_keyring_sync(), id)
def __init__(self, app="msmtp", protocol="smtp"):
self.app = app
self.protocol = protocol
self.valid_hosts = []
try:
self.keyring = gk.get_default_keyring_sync()
except gk.NoKeyringDaemonError:
print >> sys.stderr, "Error: Can not open gnome keyring."
print >> sys.stderr, "Are you running a GNOME session?"
sys.exit(2)
def __init__(self, app="msmtp", protocol="smtp"):
self.app = app
self.protocol = protocol
self.valid_hosts = []
try:
self.keyring = gk.get_default_keyring_sync()
except gk.NoKeyringDaemonError:
print >> sys.stderr, "Error: Can not open gnome keyring."
print >> sys.stderr, "Are you running a GNOME session?"
sys.exit(2)
def __loadKeyring():
""" Load the keyring if needed """
global __keyring
import gnomekeyring as gk
if __keyring is None:
__keyring = gk.get_default_keyring_sync()
if __keyring is None:
__keyring = 'login'
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 __init__(self):
self.app = 'msmtp'
self.protocol = 'smtp'
self.user= "******"
self.server= "smtp.gmail.com"
# get default keyring name
try:
self.keyring = gk.get_default_keyring_sync()
except gk.NoKeyringDaemonError:
print "ERR: can't open gnome keyring"
print "Are you running this program under a GNOME session ?"
sys.exit(-1)
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_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 on_account_delete(self, widget):
if "id" in self.account:
try:
private_fields = [f.split(":")[-1] for f in self.services[self.account["service"]]["config"] if ":" in f]
for f in private_fields:
if self.account[f].startswith(":KEYRING:"):
keyring_id = int(self.account[f].split(":")[-1])
gnomekeyring.item_delete_sync(gnomekeyring.get_default_keyring_sync(), keyring_id)
except:
pass
self.gwibber.accounts.Delete(self.account["id"])
self.populate_account_tree()
self.select_first()
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 delete_clicked (self, data):
select = self.iconview.get_selected_items()
if len(select) == 0:
print _("nothing to delete")
return
i = select[0][0]
iter = self.model.get_iter(i)
s = self.model.get(iter,0,1,2)
server = s[0]
#ask confirmation
dialog = gtk.MessageDialog (self.window,
gtk.MESSAGE_QUESTION,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.BUTTONS_YES_NO,
_("Are you sure you want remove the server \"%(server)s\"?") %{"server": server})
r = dialog.run()
dialog.destroy()
if (r == gtk.RESPONSE_NO):
print _("deletion canceled")
else:
GCONF_AUTH_KEY = "/apps/gtkvncviewer"
gconfclient = gconf.client_get_default()
gconfclient.add_dir (GCONF_AUTH_KEY,
gconf.CLIENT_PRELOAD_RECURSIVE)
entry = gconfclient.get_entry(GCONF_AUTH_KEY+"/"+server,
"", False)
server = entry.get_key()
server = server.replace (GCONF_AUTH_KEY+"/", "")
auth_token = entry.get_value().get_int()
if auth_token > 0:
try:
#delete gnome-keyring entry
keyring = gnomekeyring.get_default_keyring_sync()
gnomekeyring.item_delete_sync(keyring, auth_token)
#delete gconf entry
gconfclient.unset(GCONF_AUTH_KEY+"/"+server)
#remove from icon view
select = self.iconview.get_selected_items()
if len(select) == 0:
return
i = select[0][0]
iter = self.model.get_iter(i)
self.model.remove(iter)
print server+" deleted"
except gnomekeyring.DeniedError:
auth_token = 0
print _("gnome-keyring access denied, could not delete")
else:
print _("gconf read error, could not delete")
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 on_account_delete(self, widget):
if not hasattr(self, 'account'):
pass
else:
if "id" in self.account:
try:
private_fields = [f.split(":")[-1] for f in self.services[self.account["service"]]["config"] if ":" in f]
for f in private_fields:
if self.account[f].startswith(":KEYRING:"):
keyring_id = int(self.account[f].split(":")[-1])
gnomekeyring.item_delete_sync(gnomekeyring.get_default_keyring_sync(), keyring_id)
except:
pass
self.gwibber.accounts.Delete(self.account["id"])
self.populate_account_tree()
self.select_account()
def __init__(self):
if os.path.basename(sys.argv[0]).find('msmtp') >= 0:
self.app = 'msmtp'
self.protocol = 'smtp'
elif os.path.basename(sys.argv[0]).find('mpop') >= 0:
self.app = 'mpop'
self.protocol = 'pop3'
else:
print("ERR: program must contain 'msmtp' or 'mpop' in its name")
sys.exit(-1)
# get default keyring name
try:
self.keyring = gk.get_default_keyring_sync()
except gk.NoKeyringDaemonError:
print("ERR: can't open gnome keyring")
print("Are you running this program under a GNOME session ?")
sys.exit(-1)
def __init__(self):
if os.path.basename(sys.argv[0]).find('msmtp') >= 0:
self.app = 'msmtp'
self.protocol = 'smtp'
elif os.path.basename(sys.argv[0]).find('mpop') >= 0:
self.app = 'mpop'
self.protocol = 'pop3'
else:
print "ERR: program must contain 'msmtp' or 'mpop' in its name"
sys.exit(-1)
# get default keyring name
try:
self.keyring = gk.get_default_keyring_sync()
except gk.NoKeyringDaemonError:
print "ERR: can't open gnome keyring"
print "Are you running this program under a GNOME session ?"
sys.exit(-1)
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 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 get_passwd(address, username):
kr = gnomekeyring.get_default_keyring_sync()
attr = {
'username': username,
'address': address,
'application': APP_NAME
}
try:
result_list = gnomekeyring.find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET, attr)
except gnomekeyring.NoMatchError:
passwd = getpass('Password: '******'More than one password')
return passwds[0]
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 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 option_parser():
parser = optparse.OptionParser(version="%prog 0.1", usage="%prog [OPTION ...] CMD\n\nCommands = [get]|set")
parser.add_option(
"-a",
"--attrs",
help="Comma separated pairs of attrribute and its value for secret in format attr1:val1[,attr2:val2,attr3:val3]",
)
parser.add_option(
"-k", "--keyring", default=gk.get_default_keyring_sync(), help="Specify keyring to add new secret."
)
parser.add_option(
"-t",
"--type",
help="Secret type; generic (default) or network.\n\tNOTE: if type 'network' is given, you must specify some of attributes;\n\tuser, domain, server, object, protocol, authtype, port.",
)
parser.add_option("-v", "--verbose", action="store_true", help="Verbose mode")
gog = optparse.OptionGroup(parser, "Options for 'get' command")
default_fmt = "#%(id)d: %(display_name)s in keyring %(keyring)s"
gog.add_option(
"-f",
"--format",
default=default_fmt,
help="Output result in given python string style format. \n\t"
+ r'[Default: "#%(id)d: %(display_name)s in keyring %(keyring)s"]',
)
gog.add_option(
"-S", "--single", action="store_true", help="Print the first secret only even if multiple secrets are found."
)
parser.add_option_group(gog)
sog = optparse.OptionGroup(parser, "Options for 'set' command")
sog.add_option("", "--name", help="Specify display_name for new secret to create. [MUST]")
sog.add_option(
"",
"--secret",
default=False,
help="Specify secret (password). NOTE: this tool will ask you about it and it's not necessaary to specify password.",
)
parser.add_option_group(sog)
return parser
def add_server (self, data):
#add it to the iconview
pixbuf = self.iconview.render_icon(gtk.STOCK_NETWORK, gtk.ICON_SIZE_BUTTON)
username = self.wTree.get_widget("usernameEntry").get_text()
password = self.wTree.get_widget("pwdEntry").get_text()
server = self.wTree.get_widget("serverEntry").get_text()
if server == "":
return
self.model.append([server, username, password, pixbuf])
#now save it in gnome-keyring
GCONF_AUTH_KEY = "/apps/gtkvncviewer/"+server
keyring = gnomekeyring.get_default_keyring_sync()
auth_token = gnomekeyring.item_create_sync(
keyring,
gnomekeyring.ITEM_GENERIC_SECRET,
"gtkvncviewer VNC server credentials ("+server+")",
dict(appname="gtkvncviewer, credentials of vnc server \""+server+"\""),
"\n".join((username, password)), True)
gconf.client_get_default().set_int(GCONF_AUTH_KEY, auth_token)
class Keyring(object):
def __init__(self, name, server, protocol):
self._name = name
self._server = server
self._protocol = protocol
self._key = gkey.ITEM_NETWORK_PASSWORD
self._keyring = gkey.get_default_keyring_sync()
def has_credentials(self):
try:
if self._key == gkey.ITEM_NETWORK_PASSWORD:
attrs = {"server": self._server, "protocol": self._protocol}
items = gkey.find_items_sync(gkey.ITEM_NETWORK_PASSWORD, attrs)
return len(items) > 0
if self._key == gkey.ITEM_GENERIC_SECRET:
attrs = {"name": self._name}
items = gkey.find_items_sync(gkey.ITEM_GENERIC_SECRET, 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 remove_keyring(self, password):
id = password.split(":")[1]
gkey.item_delete_sync(self._keyring, int(id))
def set_credentials(self, (user, pw)):
attrs = {
"user": user,
"server": self._server,
"protocol": self._protocol,
}
id = gkey.item_create_sync(gkey.get_default_keyring_sync(),\
gkey.ITEM_NETWORK_PASSWORD, self._name, attrs, pw, True)
return id
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, name, user, server, protocol):
self._name = name
self._user = user
self._server = server
self._protocol = protocol
self._keyring = gkey.get_default_keyring_sync()
tuples = options.params_int.split(',')
for tupl in tuples:
if not tupl:
# empty string
continue
name, val = tupl.split('=', 1)
val = int(val)
self.params[name] = val
except ValueError, e:
parser.error('Incorrect syntax of "-i param1=value1,'
'param2=value2"! See --help.\nDetails:\n%s' % e)
if options.keyring:
self.keyring = options.keyring
else:
self.keyring = gk.get_default_keyring_sync()
if options.output1:
options.output = 'secret'
options.no_newline = True
if (options.set or options.unlock) and not options.password:
# ask for password
options.password = getpass.getpass()
self.secret = options.password
self.id = options.id
self.name = options.name
self.item_type = CLI.ITEM_TYPES[options.type]
self.output = options.output.split(',')
self.no_newline = options.no_newline
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 __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()
def __init__(self):
if not gnomekeyring.is_available():
raise Exception("Gnome keyring not available!")
self.keyring_name = gnomekeyring.get_default_keyring_sync()
