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