def set_credentials(self, username, password): """Store username and password""" if not self._config.has_section(SECTION): self._config.add_section(SECTION) self._config.set(SECTION, 'username', username) self._config.write(open(USER_CONFIG_FILE, 'w')) keyring.set_password(KEYRING_SERVICE, username, password)
def _login(self, username=None, store_password=False): if username is None: if self.USERNAME == "": raise LoginError("If you do not pass a username to login(), you should configure a default one!") else: username = self.USERNAME # Get password from keyring or prompt password_from_keyring = keyring.get_password("astroquery:www.eso.org", username) if password_from_keyring is None: if system_tools.in_ipynb(): log.warn("You may be using an ipython notebook:" " the password form will appear in your terminal.") password = getpass.getpass("{0}, enter your ESO password:\n".format(username)) else: password = password_from_keyring # Authenticate log.info("Authenticating {0} on www.eso.org...".format(username)) # Do not cache pieces of the login process login_response = self._request("GET", "https://www.eso.org/sso/login", cache=False) login_result_response = self._activate_form(login_response, form_index=-1, inputs={'username': username, 'password': password}) root = BeautifulSoup(login_result_response.content, 'html5lib') authenticated = not root.select('.error') if authenticated: log.info("Authentication successful!") else: log.exception("Authentication failed!") # When authenticated, save password in keyring if needed if authenticated and password_from_keyring is None and store_password: keyring.set_password("astroquery:www.eso.org", username, password) return authenticated
def get_username_and_pw (self): print 'Let us get a password...' username = self.prefs.get('cooksillustrated-username','') print 'Username='******'http://www.cooksillustrated.com', username ) else: pw = '' print 'Initial password: '******'Launch dialog...' # username, pw = de.getUsernameAndPassword( username=username, pw=pw ) # broken :( - temporary workaround? #username,pw = 'USERNAME','PASSWORD' print 'Done with dialog' self.prefs['cooksillustrated-username'] = username keyring.set_password( 'http://www.cooksillustrated.com',username,pw ) return username, pw
def db_login(force_password=False): """Makes sure that config.PASSWORD is set to the database password. If config.PASSWORD is alread defined, this function will not do anything. Otherwise it will try to fetch the password from the systems keychain. If no password is stored in the keychain yet, the user is prompted to enter the password and optinally store it in the system keychain. Args: force_password: If set to True, the user is prompted even if the password is stored in the keychain (useful if the password needs to be changed """ if "PASSWORD" in dir(config) != None: #password already set in config.py return import keyring, getpass config.PASSWORD = keyring.get_password(config.DATABASE, config.USER) if config.PASSWORD == None or force_password == True: while 1: print("A password is needed to continue. Please enter the password for") print(" * service: postgresql") print(" * database: " + config.DATABASE) print(" * user: "******"to continue.") config.PASSWORD = getpass.getpass("Please enter the password:\n") if config.PASSWORD != "": break else: print ("Authorization failed (no password entered).") # store the password if confirm("Do you want to securely store the password in the keyring of your operating system?",default=True): keyring.set_password(config.DATABASE, config.USER, config.PASSWORD) print("Password has been stored. You will not have to enter it again the next time. If you need to edit the password use the keychain manager of your system.")
def set_password(config, password=None): """ Save the password safely """ if password is None: password = getpass.getpass('Dein HSR-Kennwort (wird sicher im Keyring gespeichert): ') keyring.set_password('openhsr-connect', config['login']['username'], password)
def set(target, username): target_list = lst(targets()) if target not in target_list: raise ValueError("%s must be one of %r" % (target, target_list)) keyring.set_password(target, username, getpass.getpass()) print "Password set for %s, %s" % (target, username)
def set_password(password): """Stores the password in the keyring.""" username = get_conf(USERNAME_KEY) if not username: raise ValueError("Cannot set password without a username specified.") keyring.set_password("system", username, password)
def config_get(config, section, key=None, default=None): """Return value that matches key in config settings. Reference keyring if needed. """ config_section = config.get(section) if not key: return config_section if config_section.get(key, default) == 'USE_KEYRING': keyring_path = '%s/%s' % (section, key) keyring_value = keyring.get_password('serverherald', keyring_path) if keyring_value is None: print ('The keyring storage mechanism has been selected for' '%s but the keyring is empty' % keyring_path) while 1: user_value = getpass.getpass("%s: " % key) if user_value != '': keyring.set_password('serverherald', keyring_path, user_value) break return user_value else: return keyring_value else: return config_section.get(key, default)
def run(pelican): update_settings(pelican) host = pelican.settings['IMAP_IMPORTER']['HOST'] user = pelican.settings['IMAP_IMPORTER']['USER'] folders = pelican.settings['IMAP_IMPORTER']['FOLDERS'] new_password = False password = keyring.get_password('PELICAN_IMAP_IMPORTER', user) if password is None: password = get_password(user) new_password = True host = pelican.settings['IMAP_IMPORTER']['HOST'] # Connect imap = None try: imap = imaplib.IMAP4(host) context = ssl.create_default_context() imap.starttls(context) except Exception as e: logger.critical(_log + "Couldn't connect to '" + host + "'") logger.critical(_log + str(e)) exit() # Login try_again = True fail_counter = 0 while try_again: try: imap.login(user, password) try_again = False except imaplib.IMAP4_SSL.error as e: fail_counter += 1 logger.warning(_log + "Authentication failed!") logger.warning(_log + "Make sure that the user name and password are correct") if fail_counter > 3: exit() password = get_password(user) new_password = True # successful login if new_password: keyring.set_password('PELICAN_IMAP_IMPORTER', user, password) for folder in folders: imap.select(folder) typ, data = imap.search(None, 'ALL') for num in data[0].split(): typ, data = imap.fetch(num, '(RFC822)') #imap.append('INBOX.Server.Comments', None, None, message=data[0][1]) msg = email.message_from_bytes(data[0][1]) if process_email(pelican.settings, msg): del msg['X-PELICAN-IMAP-IMPORTER'] msg['X-PELICAN-IMAP-IMPORTER'] = 'processed-debug4' imap.store(num, '+FLAGS', '\\Deleted') # delete email imap.append(folder, '\\Seen', None, message=msg.as_bytes()) imap.expunge() imap.logout()
def locked_delete(self): """Delete Credentials file. Args: credentials: Credentials, the credentials to store. """ keyring.set_password(self._service_name, self._user_name, '')
def get_user_pass(self, _, reset=False): if reset is True: with app.open('user', 'r') as f: user = f.read() keyring.delete_password("umma", user) # delete password with app.open('user','w') as f: os.remove(f.name) try: with app.open('user', 'r') as f: user = f.read() except IOError: w = rumps.Window(message='US Mobile login name/email', title='Login', dimensions=(250,24), default_text="*****@*****.**") r = w.run() user = r.text passwd = keyring.get_password("umma", user) if passwd is None: w = rumps.Window(message='US Mobile login password', title='Login', dimensions=(250, 24), default_text="Your password") r = w.run() passwd = r.text keyring.set_password("umma", user, passwd) with app.open('user', 'w') as f: f.write(user) return user, passwd
def get_config_data(): fn = os.path.expanduser(DEFAULT_CONFIG_FILE) data = {} try: if os.path.exists(fn): with open(fn) as fd: data = yaml.safe_load(fd) if 'password' in data: keyring.set_password("zmon-cli", data['user'], data['password']) del data['password'] with open(fn, mode='w') as fd: yaml.dump(data, fd, default_flow_style=False, allow_unicode=True, encoding='utf-8') else: clickclick.warning("No configuration file found at [{}]".format(DEFAULT_CONFIG_FILE)) data['url'] = click.prompt("ZMon Base URL (e.g. https://zmon2.local/rest/api/v1)") data['user'] = click.prompt("ZMon username", default=os.environ['USER']) with open(fn, mode='w') as fd: yaml.dump(data, fd, default_flow_style=False, allow_unicode=True, encoding='utf-8') except Exception as e: error(e) return validate_config(data)
def get_auth_token(): global token if token is not None: return token import keyring token = keyring.get_password("github", fake_username) if token is not None: return token print( "Please enter your github username and password. These are not " "stored, only used to get an oAuth token. You can revoke this at " "any time on Github." ) user = input("Username: "******"Password: "******"scopes": ["public_repo", "gist"], "note": "IPython tools", "note_url": "https://github.com/ipython/ipython/tree/master/tools", } response = requests.post("https://api.github.com/authorizations", auth=(user, pw), data=json.dumps(auth_request)) response.raise_for_status() token = json.loads(response.text)["token"] keyring.set_password("github", fake_username, token) return token
def login(self): from work import get_setting_dict self.email = get_setting_dict()['email'] #self.username = self.getCredentials()['username'] if get_setting_dict().has_key('explicitFBToken'): self.fbConnection.logonTok(get_setting_dict()['explicitFBToken']) else: password = keyring.get_password('fogbugz', self.email) if not password: while True: if not password: import getpass password = getpass.getpass("FogBugz password: "******"No username was found!") #print self.username self.ixPerson = self.usernameToIXPerson()
def _setUp_maildiff(log, config): """ this function prompts user to enter email settings for this git maildiff command to store in .gitconfig while password is stored in os keychain. Args: config(dict): existing config from .gitconfig """ # check if data in global config if not config.has_key('maildiff.mailfrom'): log.info("\x1b[32mFirst time mail setup.\x1b[m") userEmail = config['user.email'] log.warning("Do you want to use your git email '%s' to send diffs or any other email address ?", userEmail) ret = raw_input('[YES]') if ret.lower() in ['', 'yes', 'y']: ret = userEmail __update_config(log, 'maildiff.mailfrom', ret) else: ret = __validate_address(ret) _exec_git_command(log, 'git maildiff.mailfrom %s' % ret) __update_config(log, 'maildiff.mailfrom', ret) log.info("Please enter password for the email: %s" , ret) emailPwd = getpass.getpass(prompt=" Password: "******"Add SMTP details for '%s'.", ret) smtpServer = raw_input(" SMTP Server: ") __update_config(log, 'maildiff.smtpserver', smtpServer) smtpServerPort = raw_input(" SMTP Server Port: ") __update_config(log, 'maildiff.smtpserverport', smtpServerPort) smtpEncryption = raw_input(" Server Encryption: ") __update_config(log, 'maildiff.smtpencryption', smtpEncryption) return True
def get_credentials(self, service, checker=None): url = self.config.get(service, "url") username = self.config.get(service, "username") key = "lancet+{}".format(url) if username: password = keyring.get_password(key, username) if password: return url, username, password with taskstatus.suspend(): while True: click.echo("Please provide your authentication information for {}".format(url)) if not username: username = click.prompt("Username") else: click.echo("Username: {}".format(username)) password = click.prompt("Password", hide_input=True) if checker: with taskstatus("Checking provided credentials") as ts: if not checker(url, username, password): ts.fail("Login failed") username, password = None, None continue else: ts.ok("Correctly authenticated to {}", url) keyring.set_password(key, username, password) return url, username, password
def store(username): """ Store given password for this username to keystore """ passwd = getpass.getpass() keyring.set_password('linkedinpy', username, passwd) click.echo("Password updated successfully")
def _login(self, username): import keyring from lxml import html # Get password from keyring or prompt password_from_keyring = keyring.get_password("astroquery:www.eso.org", username) if password_from_keyring is None: password = getpass.getpass("{0}, enter your ESO password:\n".format(username)) else: password = password_from_keyring # Authenticate print("Authenticating {0} on www.eso.org...".format(username)) login_response = self.request("GET", "https://www.eso.org/sso/login") login_result_response = self._activate_form(login_response, form_index=-1, inputs={'username': username, 'password':password}) root = html.document_fromstring(login_result_response.content) authenticated = (len(root.find_class('error')) == 0) if authenticated: print("Authentication successful!") else: print("Authentication failed!") # When authenticated, save password in keyring if needed if authenticated and password_from_keyring is None: keyring.set_password("astroquery:www.eso.org", username, password) return authenticated
def test_json_credentials_storage(self): access_token = 'foo' client_id = 'some_client_id' client_secret = 'cOuDdkfjxxnv+' refresh_token = '1/0/a.df219fjls0' token_expiry = datetime.datetime.utcnow() user_agent = 'refresh_checker/1.0' credentials = OAuth2Credentials( access_token, client_id, client_secret, refresh_token, token_expiry, GOOGLE_TOKEN_URI, user_agent) m = mox.Mox() m.StubOutWithMock(keyring, 'get_password') m.StubOutWithMock(keyring, 'set_password') keyring.get_password('my_unit_test', 'me').AndReturn(None) keyring.set_password('my_unit_test', 'me', credentials.to_json()) keyring.get_password('my_unit_test', 'me').AndReturn(credentials.to_json()) m.ReplayAll() s = Storage('my_unit_test', 'me') self.assertEquals(None, s.get()) s.put(credentials) restored = s.get() self.assertEqual('foo', restored.access_token) self.assertEqual('some_client_id', restored.client_id) m.UnsetStubs() m.VerifyAll()
def configure(config_file, env): config = {} conf = SafeConfigParser() passwd = None if conf.read(config_file): config['username'] = conf.get(env, 'username') config['dreadnot'] = conf.get(env, 'dreadnot') config['region'] = conf.get(env, 'region') else: config['dreadnot'] = raw_input('Dreadnot URL:') config['region'] = raw_input('Deployment region:') config['username'] = raw_input('Dreadnot username:'******'dreadnot', 'region', 'username'): conf.set(env, name, config[name]) with open(config_file, 'w') as f: conf.write(f) if keyring: passwd = keyring.get_password('dreadnot', config['dreadnot']) if not passwd: passwd = getpass.getpass('Dreadnot password:'******'dreadnot', config['dreadnot'], passwd) config['password'] = passwd return config
def configure(self): print("Enter user email ([email protected]) or press enter to skip") username = raw_input('({0})>'.format(self.USERNAME)) print("Enter email password or press enter to skip") password = getpass.getpass( prompt='>') # To stop shoulder surfing if username: gmailSettings.USERNAME = username if password: keyring.set_password(self.KEYRING_APP_ID, self.USERNAME, password) print("Clear alerts list? (yes/no)?") import distutils.util try: if distutils.util.strtobool(raw_input(">")): gmailSettings.SEND_ALERT_TO = [] # Clear the list print("Alerts list cleared") except ValueError: pass print("Send alerts to (press enter when done):") while True: user_input = raw_input('({0})>'.format(','.join(self.SEND_ALERT_TO))) if not user_input: break else: gmailSettings.SEND_ALERT_TO.append(user_input) self.saveSettings()
def get_username_and_password(force_fresh_input = False): """ Reads username and password from keyring or prompts user for them and saves them to the keyring. force_fresh_input enforces the prompt (to be used after bad login for example). """ import keyring, getpass username = keyring.get_password("mekk.greader", "default-login") if (not username) or force_fresh_input: while True: username = raw_input("Your Google account name: ") if username: break keyring.set_password("mekk.greader", "default-login", username) password = keyring.get_password("mekk.greader", username) if (not password) or force_fresh_input: while True: password = getpass.getpass("Password for %s: " % username) if password: break keyring.set_password("mekk.greader", username, password) return username, password
def get_config(self, args): stored_config_harvester = keyring.get_password("INDX", "INDX_Fitbit_Harvester") stored_config_fitbit = keyring.get_password("Fitbit.com", "Fitbit") self.logger.debug("Loaded harvester config from keyring: {0}".format(stored_config_harvester)) self.logger.debug("Loaded fitbit config from keyring: {0}".format(stored_config_fitbit)) if stored_config_fitbit is None : token_url = self.fitbit.get_token_url() config_fitbit = {} config_fitbit["url"] = token_url['url'] config_fitbit["req_token"] = token_url['req_token'] else : if (type(stored_config_fitbit) != dict): config_fitbit = json.loads(stored_config_fitbit) # if (type(config_fitbit) != dict): # config_fitbit = json.loads(config_fitbit) if 'token' not in config_fitbit : token_url = self.fitbit.get_token_url() config_fitbit["url"] = token_url['url'] config_fitbit["req_token"] = token_url['req_token'] keyring.set_password("Fitbit.com", "Fitbit", json.dumps(config_fitbit)) if stored_config_harvester is None: return json.dumps({"fitbit":config_fitbit}) # don't send the req_token return json.dumps({"fitbit":config_fitbit, "harvester":json.loads(stored_config_harvester)}) # don't send the req_token
def set_password(smtp_server, from_email): ''' Set the keyring password for the mail connection. Interactive.''' if keyring is None: raise ImportError('keyring module missing - service unsupported') password = getpass.getpass(prompt='Enter password for {} using {}: '.format(from_email, smtp_server)) keyring.set_password(smtp_server, from_email, password)
def set_config(self, args): stored_config_harvester = keyring.get_password("INDX", "INDX_Fitbit_Harvester") if stored_config_harvester is not None: stored_config_harvester = json.loads(stored_config_harvester) stored_config_fitbit = keyring.get_password("Fitbit.com", "Fitbit") if stored_config_fitbit is not None: stored_config_fitbit = json.loads(stored_config_fitbit) received_config = json.loads(args['config']) if (type(received_config) != dict): received_config = json.loads(received_config) self.logger.debug("Received config ({0}): {1}".format(type(received_config), received_config)) config = {} if 'fitbit' in received_config: fitbit_config = received_config['fitbit'] if fitbit_config and ('pin' in fitbit_config) and ('req_token' in fitbit_config): # this should check for the req_token in the stored config! self.logger.debug("Received pin: {0}".format(fitbit_config['pin'])) try: token = self.fitbit.get_token_with_pin(fitbit_config['pin'], fitbit_config['req_token']) self.logger.debug("Got auth token {0}, of type {1}".format(token, type(token))) if token: config['token']=token keyring.set_password("Fitbit.com", "Fitbit", json.dumps(config)) except Exception as exc: self.logger.error("Could not authorise to fitbit, with pin {0}, error: {1}".format(fitbit_config['pin'], exc)) if 'harvester' in received_config: harvester_config = received_config['harvester'] if harvester_config != stored_config_harvester: keyring.set_password("INDX", "INDX_Fitbit_Harvester", json.dumps(harvester_config))
def main(argv): encrypt = argv[0] keyfile = argv[1] service = argv[2] username = argv[3] if isinstance(encrypt, str): if encrypt.lower().startswith('t'): encrypt = True else: encrypt = False if encrypt: password = argv[4] key = RSA.generate(1024) cipher = PKCS1_v1_5.new(key) keyring.set_password(service, username, key.exportKey()) with open(keyfile, 'wb') as outf: outf.write(cipher.encrypt(password)) else: key = RSA.importKey(keyring.get_password(service, username)) cipher = PKCS1_v1_5.new(key) with open(keyfile, 'rb') as inf: return cipher.decrypt(inf.read(), None)
def read_config(args): config = osp.join(configdir, "login.conf") username = "" password = "" # read if keyring: log.debug("Reading credentials from keyring") try: username, password = (keyring.get_password(myname, "").split("\n") + ["\n"])[:2] except IOError as e: log.error(e) else: log.debug("Reading credentials from '%s'" % config) try: with open(config, "r") as fd: username, password = (fd.read().splitlines() + ["\n"])[:2] except IOError as e: log.error(e) # save if args.username or args.password: log.info("Saving credentials") if keyring: keyring.set_password(myname, "", "%s\n%s" % (args.username or username, args.password or password)) else: try: with open(config, "w") as fd: fd.write("%s\n%s\n" % (args.username or username, args.password or password)) os.chmod(config, 0600) except IOError as e: log.error(e) return dict(username=username, password=password)
def configure(self): print("Enter database username (postgres) or press enter to skip") username = raw_input('({0})>'.format(self.USERNAME)) if username: db_settings.USERNAME = username print("Enter database password or press enter to skip") password = getpass.getpass( prompt='>') # To stop shoulder surfing if password: keyring.set_password(self.KEYRING_APP_ID, self.USERNAME, password) print("Enter database server HOST Address to edit (127.0.0.1) or press enter to skip") DB_HOST = raw_input('({0})>'.format(self.DB_HOST)) if DB_HOST: db_settings.DB_HOST = DB_HOST print("Enter database server port to edit (playerStats) or press enter to skip") port = raw_input('({0})>'.format(str(self.PORT))) if port: db_settings.PORT = int(port) self.saveSettings() print("Settings Updated") sys.exit(0)
def login(self, reddit_id): passwd = keyring.get_password(app_name, reddit_id) if not passwd: passwd = getpass.getpass() # save it for next time keyring.set_password(app_name, reddit_id, passwd) headers = {"User-Agent": config['reddit_boot']} auth = requests.auth.HTTPBasicAuth(self.client_id, self.client_secret) data = {'grant_type': 'password' ,'username': reddit_id, 'password': passwd} response = requests.post(token_url,data=data,auth=auth,headers=headers) if response.status_code != 200: pprint(response.json()) sys.exit() json_data= response.json() self.access_token = json_data['access_token'] return User(reddit_id)
def get_auth(): def check_auth(auth): return requests.head(full_repo_url, auth=auth).status_code != httplib.UNAUTHORIZED # config file init config_file = os.path.join(BaseDirectory.save_config_path("malucrawl_reportificate"), "settings.ini") config = configparser.SafeConfigParser() config.read(config_file) if not config.has_section('auth'): config.add_section('auth') try: username = config.get('auth', 'username') except configparser.NoOptionError: username = raw_input("Username: "******"Authorization Failed" username = raw_input("Username: ") password = getpass.getpass() keyring.set_password(github_url, username, password) config.set('auth', 'username', username) config.write(open(config_file, 'w')) return (username, password)
def save_default_recipient(recipient_email: str): keyring.set_password(KEYRING_NAME, 'default_recipient', recipient_email)
def _set_key(self, servicename, key, value, **kwargs): keyring.set_password(servicename, key, value)
def _set_password(service): from keyring import set_password from getpass import getpass set_password(service, input("Username: "), getpass.getpass())
import sys, keyring print sys.argv[1], sys.argv[2], sys.argv[3] keyring.set_password("system", "myphoneemail", sys.argv[1]) keyring.set_password("system", "email", sys.argv[2]) keyring.set_password("system", sys.argv[2], sys.argv[3])
def SetPassword(new_password): keyring.set_password(_systemname, _username, new_password) _log.info("new password set to: {}".format(new_password))
def build_repo(args): payload = { 'clean': args.clean, 'platform': args.target, 'repo': args.repo, 'extra_symbols': args.extra_symbols } if args.replace_file: replace = [] for pair in args.replace_file: dest, src = pair.split(':') print(dest) cwd = os.getcwd() with open(join(cwd, src), 'r') as srcfile: replace.append({dest: srcfile.read()}) payload['replace'] = replace log.debug("Payload is: %s", payload) host = urlparse(args.api_url).netloc user = password = None try: user, host = urlparts.netloc.rsplit('@', 1) except: pass else: try: user, password = user.split(':', 1) except: pass user = args.user or user if not user: try: user = input('mbed username: '******'') return 1 if not password: try: password = keyring.get_password(host, user) if password is None: raise ValueError except: try: password = getpass.getpass('mbed password: '******'') return 1 log.debug("Auth info: host='%s' user='******' password='******'", host, user, password) # Send task to api log.debug(args.api_url + "/api/v2/tasks/compiler/start/ | data: %r", payload) r = requests.post(args.api_url + "/api/v2/tasks/compiler/start/", json=payload, auth=(user, password)) log.debug(r.content) if r.status_code != 200: raise Exception("Error while talking to the mbed API. Status: %s" % r.status_code) if keyring and confirm("Save password for user '%s' to keyring?"): keyring.set_password(urlparts.netloc, args.user, password) uuid = r.json()['result']['data']['task_id'] log.debug("Task accepted and given ID: %s", uuid) # Poll for output success = False for check in range(0, 40): log.debug("Checking for output: cycle %s of %s", check, 10) time.sleep(2) url = args.api_url + "/api/v2/tasks/compiler/output/%s" % uuid r = requests.get(url, auth=(user, password)) log.debug(r.content) response = r.json() messages = response['result']['data']['new_messages'] percent = 0 for message in messages: if message.get('message'): if message.get('type') != 'debug': log.info("[%s] %s", message['type'], message['message']) if message.get('action'): if message.get('percent'): percent = message['percent'] log.info("[%s%% - %s] %s", percent, message['action'], message.get('file', '')) if response['result']['data']['task_complete']: log.info("Task completed.") success = response['result']['data']['compilation_success'] log.info("Compile success: %s", success) break # Download binary if success: log.info("Downloading your binary") params = { 'repomode': True, 'program': response['result']['data']['program'], 'binary': response['result']['data']['binary'], 'task_id': uuid } r = requests.get(args.api_url + "/api/v2/tasks/compiler/bin/", params=params, auth=(user, password)) destination = join(args.destdir or os.getcwd(), response['result']['data']['binary']) with open(destination, 'wb') as fd: for chunk in r.iter_content(1024): fd.write(chunk) log.info("Finished!")
def set_wallet_password(self, password): keyring.set_password('tribler', 'btc_wallet_password', password)
# read and attach all files for file_name in attachments: # read in bytes mode to handle all file types with open(file_name, 'rb') as attachment: part = MIMEBase('application', 'octet-stream') # add the file data to the MIME part part.set_payload(attachment.read()) # apparently, encoding in ASCII is necessary for it to be in email encoders.encode_base64(part) # necessary headers to recognize as file attachment part.add_header("Content-Disposition", f'attachment; filename= {file_name}') # attach the file message.attach(part) # convert the message with attachments in order to send text = message.as_string() context = ssl.create_default_context() # connect to the gmail SMTP server with smtplib.SMTP_SSL('smtp.gmail.com', port, context=context) as server: # login to gmail account server.login(sender, get_password()) # send email to each recipient for recipient in RECIPIENTS: server.sendmail(sender, recipient, text) if __name__ == '__main__': em = input('Enter the email to add to the keychain: ') pw = input('Enter the password for that email: ') keyring.set_password('gmail', em, pw)
def setUp(self): """Set up for test""" print("Set up for [" + self.shortDescription() + "]") print("password is set ", keyring.set_password(SKYPE_KEYRING, "nexus12142", "xxxxxxxxx"))
def set_password(email, password): keyring.set_password('gmail', email, password) # setting the password
def set_password(self, password): try: logging.debug("Storing password in the keyring") keyring.set_password("UFO", conf.USER, str(password)) except: logging.debug("import keyring failed, (keyring.set_password)!")
import getpass import keyring # pip3 install keyring import re # Customize this! define_success = {'QB Rush': 3, 'Outside Run': 2, 'Inside Run': 2, 'Pass': 0} #Checking/Prompting for username/password user_name = keyring.get_password('glb2', 'user_name') password = keyring.get_password('glb2', 'password') if user_name is None: user_name = input('Your GLB2 Username: '******'glb2', 'user_name', user_name) if password is None: password = getpass.getpass('Your GLB2 Password: '******'glb2', 'password', password) login = {'action': 'login', 'user_name': user_name, 'password': password} # Grabs the whole defensive playbook: import requests # pip3 install requests import json with requests.Session() as c: c.post('http://glb2.warriorgeneral.com/game/login', data=login) r = c.get('http://glb2.warriorgeneral.com/game/playbook/O/ajax').content w = c.get('http://glb2.warriorgeneral.com/game/playbook/D/ajax').content
def activate(cls, ctxt, args): """ Called to determine whether to activate the extension. This call is made after processing command line arguments, and must return either ``None`` or an initialized instance of the extension. Note that this is a class method. :param ctxt: An instance of ``timid.context.Context``. :param args: An instance of ``argparse.Namespace`` containing the result of processing command line arguments. :returns: An instance of the extension class if the extension has been activated, ``None`` if it has not. If this method returns ``None``, no further extension methods will be called. """ # If no pull request was specified, do nothing if not args.github_pull: return None ctxt.emit('Github plugin activated') # Ensure we have a password service = 'timid-github!%s' % args.github_api passwd = args.github_pass if passwd is None and not args.github_keyring_set: # Try getting it from the keyring passwd = keyring.get_password(service, args.github_user) if passwd is None: # OK, try prompting for it passwd = getpass.getpass('[%s] Password for "%s"> ' % (args.github_api, args.github_user)) # Are we supposed to set it? if args.github_keyring_set: ctxt.emit('Saving password in keyring as requested') keyring.set_password(service, args.github_user, passwd) # Now we have authentication information, get a Github handle gh = github.Github(args.github_user, passwd, args.github_api) # Next, interpret the pull request designation try: # Try JSON first pull_raw = json.loads(args.github_pull) except ValueError: # Raw string repo, _sep, number = args.github_pull.partition('#') # Interpret the number if not number or not number.isdigit(): sys.exit('Invalid pull request number "%s"' % number) number = int(number) # Interpret the repo if '/' not in repo: user = gh.get_user() repo = '%s/%s' % (user.login, repo) # Look up the pull request try: repo = gh.get_repo(repo) pull = repo.get_pull(number) except Exception: # No such pull request, I guess sys.exit('Unable to resolve pull request "%s"' % args.github_pull) else: # OK, we have raw JSON data; wrap it in a PullRequest pull = gh.create_from_raw_data(github.PullRequest.PullRequest, pull_raw) ctxt.emit('Testing pull request %s#%d' % (pull.base.repo.full_name, pull.number)) # Need the repository name repo_name = pull.base.repo.name # Also need the branches repo_branch = pull.base.ref change_branch = pull.head.ref # Select the correct repository URL repo_url = _select_url(args.github_repo, pull.base.repo) ctxt.emit('Base repository %s' % repo_url, level=2) # Select the correct change repository URL. If not # independently specified, default to the same as the # repo_url. Note: the URLs could legally be the same, as a PR # could be made from one branch to another of the same # repository. change_url = _select_url(args.github_change_repo or args.github_repo, pull.head.repo) ctxt.emit('PR repository %s' % change_url, level=2) # With the pull, we need to select an appropriate commit last_commit = list(pull.get_commits())[-1] # Set up the final status information final_status = { 'status': 'success', 'text': 'Tests passed!', 'url': args.github_status_url, } # Handle the --github-override option if args.github_override: try: override_raw = json.loads(args.github_override) for key in final_status: if key in override_raw: final_status[key] = override_raw[key] except ValueError: pass # Now we process the other override options if args.github_override_status: final_status['status'] = args.github_override_status if args.github_override_text: final_status['text'] = args.github_override_text if args.github_override_url: final_status['url'] = args.github_override_url # Set some variables in the context for the use of any callers ctxt.variables.declare_sensitive('github_api_password') ctxt.variables.update({ 'github_api': args.github_api, 'github_api_username': args.github_user, 'github_api_password': passwd, 'github_repo_name': repo_name, 'github_pull': '%s#%d' % (pull.base.repo.full_name, pull.number), 'github_base_repo': repo_url, 'github_base_branch': repo_branch, 'github_change_repo': change_url, 'github_change_branch': change_branch, 'github_success_status': final_status['status'], 'github_success_text': final_status['text'], 'github_success_url': final_status['url'], 'github_status_url': args.github_status_url, }) # We are all set; initialize the extension return cls(gh, pull, last_commit, args.github_status_url, final_status, repo_name, repo_url, repo_branch, change_url, change_branch)
def process_bind_param(self, value, uuid): if value is None: return value keyring.set_password('systemcheck', username=uuid, password=value)
def _set_password(self): """ Записывает пароль в keyring :return: """ keyring.set_password(self._service_name, self._user, self._password)
def store_password_in_keyring(host, username, password): keyring.set_password('bonfire_' + host, username, password)
def set_password(self, password): keyring.set_password('photini', self.name, password)
def process_auth(args, config): # Set up logging logging.getLogger().setLevel(getattr(logging, args.log_level.upper(), None)) if config.region is None: config.region = util.Util.get_input("AWS Region: ") logging.debug('%s: region is: %s', __name__, config.region) # If there is a valid cache and the user opted to use it, use that instead # of prompting the user for input (it will also ignroe any set variables # such as username or sp_id and idp_id, as those are built into the SAML # response). The user does not need to be prompted for a password if the # SAML cache is used. if args.saml_assertion: saml_xml = base64.b64decode(args.saml_assertion) elif args.saml_cache and config.saml_cache: saml_xml = config.saml_cache logging.info('%s: SAML cache found', __name__) else: # No cache, continue without. logging.info('%s: SAML cache not found', __name__) if config.username is None: config.username = util.Util.get_input("Google username: "******"Google IDP ID: ") logging.debug('%s: idp is: %s', __name__, config.idp_id) if config.sp_id is None: config.sp_id = util.Util.get_input("Google SP ID: ") logging.debug('%s: sp is: %s', __name__, config.sp_id) # There is no way (intentional) to pass in the password via the command # line nor environment variables. This prevents password leakage. keyring_password = None if config.password_cmd: with os.popen(config.password_cmd) as subproc: config.password = subproc.read().strip() elif config.keyring: keyring_password = keyring.get_password("aws-google-auth", config.username) if keyring_password: config.password = keyring_password else: config.password = util.Util.get_password("Google Password: "******"Google Password: "******"aws-google-auth", config.username, config.password) # We now have a new SAML value that can get cached (If the user asked # for it to be) if args.saml_cache: config.saml_cache = saml_xml # The amazon_client now has the SAML assertion it needed (Either via the # cache or freshly generated). From here, we can get the roles and continue # the rest of the workflow regardless of cache. amazon_client = amazon.Amazon(config, saml_xml) roles = amazon_client.roles # Determine the provider and the role arn (if the the user provided isn't an option) if config.role_arn in roles and not config.ask_role: config.provider = roles[config.role_arn] else: if config.account and config.resolve_aliases: aliases = amazon_client.resolve_aws_aliases(roles) config.role_arn, config.provider = util.Util.pick_a_role( roles, aliases, config.account) elif config.account: config.role_arn, config.provider = util.Util.pick_a_role( roles, account=config.account) elif config.resolve_aliases: aliases = amazon_client.resolve_aws_aliases(roles) config.role_arn, config.provider = util.Util.pick_a_role( roles, aliases) else: config.role_arn, config.provider = util.Util.pick_a_role(roles) if not config.quiet: print("Assuming " + config.role_arn) print("Credentials Expiration: " + format(amazon_client.expiration.astimezone(get_localzone()))) if config.print_creds: amazon_client.print_export_line() if config.profile: config.write(amazon_client)
def _main(argv=None): # Protect access token and potentially encryption keys block_tracing() if argv is None: argv = sys.argv parser = argparse.ArgumentParser() userspacefs.add_cli_arguments(parser) parser.add_argument("-c", "--config-file", help="config file path") parser.add_argument( "-e", "--encrypted-folder", dest='encrypted_folders', type=parse_encrypted_folder_arg, default=[], action='append', help= "relative paths of encrypted folders, can be used multiple times. requires safefs" ) parser.add_argument( "--print-default-config-file", action='store_true', help="print default config file path to standard out and quit") parser.add_argument("mount_point", nargs='?') args = parser.parse_args(argv[1:]) config_dir = appdirs.user_config_dir(APP_NAME) if args.config_file is not None: config_file = args.config_file else: config_file = os.path.join(config_dir, "config.json") if args.print_default_config_file: print(config_file) return 0 try: os.makedirs(config_dir, exist_ok=True) except OSError as e: print("Unable to create configuration directory: %s" % (e, )) return -1 config = {} try: f = open(config_file) except IOError as e: if e.errno != errno.ENOENT: raise else: try: with f: config = json.load(f) except ValueError as e: print("Config file %r is not valid json: %s" % (config_file, e)) return -1 mount_point = args.mount_point if mount_point is None: mount_point = config.get("mount_point") if not args.smb_no_mount and mount_point is None: parser.print_usage() print("%s: error: please provide the mount_point argument" % (os.path.basename(argv[0]), )) return 1 encrypted_folders = config.get("encrypted_folders", []) + args.encrypted_folders if safefs_wrap_create_fs is None and encrypted_folders: print( "safefs not installed, can't transparently decrypt encrypted folders" ) return 1 access_token = None save_access_token = False save_config = False access_token_command = config.get("access_token_command", None) if access_token_command is not None: print("Running %r for access token" % (' '.join(access_token_command), )) try: access_token = subprocess.check_output( access_token_command).decode("utf-8") except UnicodeDecodeError: print("Access token command output is not utf-8 encoded") return -1 except TypeError: print("Bad access token command: %r, " % (access_token_command, )) return -1 if access_token is None: keyring_user = config.get("keyring_user", None) if keyring_user is not None: try: access_token = keyring.get_password(APP_NAME, keyring_user) except KeyringError as e: print("Failed to get access token from keyring: %s" % (e, )) if access_token is None: access_token_privy = config.get("access_token_privy", None) if access_token_privy is not None: passwd = None while True: passwd = getpass.getpass( "Enter access token passphrase (not your Dropbox password) (Ctrl-C to quit): " ) try: access_token = privy.peek(access_token_privy, passwd).decode('utf-8') except ValueError: if not yes_no_input( "Incorrect password, create new access token?"): continue break del passwd try_directly = False while True: if access_token is None: save_access_token = True if (access_token is None and try_directly and yes_no_input( "Want to try entering the access token directly?")): print("Go to https://dropbox.com/developers/apps to " "create an app and generate a personal access token.") while True: access_token = getpass.getpass( "Enter Access token (Ctrl-C to quit): ") if not access_token: print("Access tokens cannot be empty") continue break if access_token is None: auth_flow = dropbox.DropboxOAuth2FlowNoRedirect( APP_KEY, APP_SECRET) authorize_url = auth_flow.start() print("We need an access token. Perform the following steps:") print("1. Go to " + authorize_url) print("2. Click \"Allow\" (you may have to log in first)") print("3. Copy the authorization code.") while True: auth_code = input( "Enter authorization code (Ctrl-C to quit): ") if not auth_code: print("Authorization code cannot be empty") continue break try: oauth_result = auth_flow.finish(auth_code) except Exception as e: print("Authorization code was invalid!") try_directly = True continue access_token = oauth_result.access_token # test out access token try: dropbox.Dropbox(access_token).users_get_current_account() except (dropbox.exceptions.BadInputError, dropbox.exceptions.AuthError, ValueError) as e: print("Error using access token: %s" % (e, )) access_token = None try_directly = True except OSError: if not yes_no_input("Error connecting to Dropbox, Try again?"): return 1 else: break if save_access_token and yes_no_input( "We're all connected. Do you want to save your credentials for future runs?", default_yes=True): keyring_user = ''.join( [random.choice("asdfghjklzxcvbnmqwertyuiop") for _ in range(24)]) try: keyring.set_password(APP_NAME, keyring_user, access_token) except (KeyringError, RuntimeError) as e: print( "We need a passphrase to encrypt your access token before we can save it." ) print( "Warning: Your access token passphrase must contain enough randomness to be resistent to hacking. You can read this for more info: https://blogs.dropbox.com/tech/2012/04/zxcvbn-realistic-password-strength-estimation/" ) while True: pass_ = getpass.getpass("Enter new access token passphrase: ") pass2_ = getpass.getpass( "Enter new access token passphrase (again): ") if pass_ != pass2_: print("Passphrases didn't match, please re-enter") else: del pass2_ break config.pop('keyring_user', None) config['access_token_privy'] = privy.hide( access_token.encode('utf-8'), pass_, server=False) del pass_ save_config = True else: config.pop('access_token_privy', None) config['keyring_user'] = keyring_user save_config = True if not config.get("asked_send_error_reports", False): if yes_no_input( "Would you like to help us improve %s by providing anonymous error reports?" % (APP_NAME, ), default_yes=True): config['send_error_reports'] = True config['asked_send_error_reports'] = True save_config = True if not os.path.exists(mount_point): if yes_no_input( "Mount point \"%s\" doesn't exist, do you want to create it?" % (mount_point, ), default_yes=True): try: os.makedirs(mount_point, exist_ok=True) except OSError as e: print("Unable to create mount point: %s" % (e, )) return -1 if save_access_token and yes_no_input( "Do you want \"%s\" to be the default mount point?" % (mount_point, ), default_yes=True): config['mount_point'] = mount_point save_config = True if save_config: with open(config_file, "w") as f: json.dump(config, f) log.info("Starting %s...", APP_NAME) if config.get('send_error_reports', False): try: version = pkg_resources.require("dbxfs")[0].version except Exception: log.warning("Failed to get version", exc_info=True) version = '' try: sentry_sdk.init( "https://[email protected]/1293235", release='%s@%s' % (APP_NAME, version), with_locals=False) except Exception: log.warning("Failed to initialize sentry", exc_info=True) cache_folder = os.path.join(appdirs.user_cache_dir(APP_NAME), "file_cache") try: os.makedirs(cache_folder, exist_ok=True) except OSError: log.warning( "Failed to create cache folder, running without file cache") cache_folder = None def create_fs(): fs = CachingFileSystem(DropboxFileSystem(access_token), cache_folder=cache_folder) if sys.platform == 'darwin': fs = DisableQuickLookFileSystem(fs) return fs if safefs_wrap_create_fs is not None: create_fs = safefs_wrap_create_fs(create_fs, encrypted_folders) return userspacefs.simple_main(mount_point, "dbxfs", create_fs, args)
def storePwd(pwd, username): keyring.set_password(SPIDER_NAME, username, pwd)
def main(): import getpass import argparse try: import keyring except ImportError: keyring = None # Parse command-line arguments {{{ cmdline = argparse.ArgumentParser() cmdline.add_argument('email', nargs='?', default=None, help='The e-mail address for your Mint.com account') cmdline.add_argument('password', nargs='?', default=None, help='The password for your Mint.com account') home = os.path.expanduser("~") default_session_path = os.path.join(home, '.mintapi', 'session') cmdline.add_argument( '--session-path', nargs='?', default=default_session_path, help='Directory to save browser session, including cookies. ' 'Used to prevent repeated MFA prompts. Defaults to ' '$HOME/.mintapi/session. Set to None to use ' 'a temporary profile.') cmdline.add_argument('--accounts', action='store_true', dest='accounts', default=False, help='Retrieve account information' '(default if nothing else is specified)') cmdline.add_argument('--budgets', action='store_true', dest='budgets', default=False, help='Retrieve budget information') cmdline.add_argument('--budget_hist', action='store_true', dest='budget_hist', default=None, help='Retrieve 12-month budget history information') cmdline.add_argument('--net-worth', action='store_true', dest='net_worth', default=False, help='Retrieve net worth information') cmdline.add_argument('--credit-score', action='store_true', dest='credit_score', default=False, help='Retrieve current credit score') cmdline.add_argument('--credit-report', action='store_true', dest='credit_report', default=False, help='Retrieve full credit report') cmdline.add_argument('--extended-accounts', action='store_true', dest='accounts_ext', default=False, help='Retrieve extended account information (slower, ' 'implies --accounts)') cmdline.add_argument('--transactions', '-t', action='store_true', default=False, help='Retrieve transactions') cmdline.add_argument( '--extended-transactions', action='store_true', default=False, help='Retrieve transactions with extra information and arguments') cmdline.add_argument( '--start-date', nargs='?', default=None, help='Earliest date for transactions to be retrieved from. ' 'Used with --extended-transactions. Format: mm/dd/yy') cmdline.add_argument('--include-investment', action='store_true', default=False, help='Used with --extended-transactions') cmdline.add_argument('--skip-duplicates', action='store_true', default=False, help='Used with --extended-transactions') # Displayed to the user as a postive switch, but processed back # here as a negative cmdline.add_argument( '--show-pending', action='store_false', default=True, help='Exclude pending transactions from being retrieved. ' 'Used with --extended-transactions') cmdline.add_argument('--filename', '-f', help='write results to file. can ' 'be {csv,json} format. default is to write to ' 'stdout.') cmdline.add_argument('--keyring', action='store_true', help='Use OS keyring for storing password ' 'information') cmdline.add_argument( '--headless', action='store_true', help='Whether to execute chromedriver with no visible window.') cmdline.add_argument('--mfa-method', default='sms', choices=['sms', 'email'], help='The MFA method to automate.') cmdline.add_argument('--imap-account', default=None, help='IMAP login account') cmdline.add_argument('--imap-password', default=None, help='IMAP login password') cmdline.add_argument('--imap-server', default=None, help='IMAP server') cmdline.add_argument('--imap-folder', default="INBOX", help='IMAP folder') cmdline.add_argument('--imap-test', action='store_true', help='Test imap login and retrieval.') cmdline.add_argument( '--no_wait_for_sync', action='store_true', default=False, help=('By default, mint api will wait for accounts to sync with the ' 'backing financial institutions. If this flag is present, do ' 'not wait for them to sync.')) cmdline.add_argument( '--wait_for_sync_timeout', type=int, default=5 * 60, help=('Number of seconds to wait for sync. Default is 5 minutes')) cmdline.add_argument( '--attention', action='store_true', help='Display accounts that need attention (None if none).') options = cmdline.parse_args() if options.keyring and not keyring: cmdline.error('--keyring can only be used if the `keyring` ' 'library is installed.') try: # python 2.x from __builtin__ import raw_input as input except ImportError: # python 3 from builtins import input except NameError: pass # Try to get the e-mail and password from the arguments email = options.email password = options.password if not email: # If the user did not provide an e-mail, prompt for it email = input("Mint e-mail: ") if keyring and not password: # If the keyring module is installed and we don't yet have # a password, try prompting for it password = keyring.get_password('mintapi', email) if not password: # If we still don't have a password, prompt for it password = getpass.getpass("Mint password: "******"MFA CODE:", mfa_code) sys.exit() data = None if options.accounts and options.budgets: try: accounts = make_accounts_presentable( mint.get_accounts(get_detail=options.accounts_ext)) except Exception: accounts = None try: budgets = mint.get_budgets() except Exception: budgets = None data = {'accounts': accounts, 'budgets': budgets} elif options.budgets: try: data = mint.get_budgets() except Exception: data = None elif options.budget_hist: try: data = mint.get_budgets(hist=12) except Exception: data = None elif options.accounts: try: data = make_accounts_presentable( mint.get_accounts(get_detail=options.accounts_ext)) except Exception: data = None elif options.transactions: data = mint.get_transactions( include_investment=options.include_investment) elif options.extended_transactions: data = mint.get_detailed_transactions( start_date=options.start_date, include_investment=options.include_investment, remove_pending=options.show_pending, skip_duplicates=options.skip_duplicates) elif options.net_worth: data = mint.get_net_worth() elif options.credit_score: data = mint.get_credit_score() elif options.credit_report: data = mint.get_credit_report(details=True) # output the data if options.transactions or options.extended_transactions: if options.filename is None: print(data.to_json(orient='records')) elif options.filename.endswith('.csv'): data.to_csv(options.filename, index=False) elif options.filename.endswith('.json'): data.to_json(options.filename, orient='records') else: raise ValueError('file extension must be either .csv or .json') else: if options.filename is None: print(json.dumps(data, indent=2)) elif options.filename.endswith('.json'): with open(options.filename, 'w+') as f: json.dump(data, f, indent=2) else: raise ValueError('file type must be json for non-transaction data') if options.attention: attention_msg = mint.get_attention() if attention_msg is None or attention_msg == "": attention_msg = "no messages" if options.filename is None: print(attention_msg) else: with open(options.filename, 'w+') as f: f.write(attention_msg)
import keyring keyring.set_password('on', 'for', 'secret') keyring.get_password('on', 'for')
def set_mfa_secret(self, user: str, mfa_secret: str): keyring.set_password(FIGGY_KEYRING_NAMESPACE, f'{user}-mfa', mfa_secret)
def _login(self, username=None, store_password=False, reenter_password=False): """ Login to the NRAO archive Parameters ---------- username : str, optional Username to the NRAO archive. If not given, it should be specified in the config file. store_password : bool, optional Stores the password securely in your keyring. Default is False. reenter_password : bool, optional Asks for the password even if it is already stored in the keyring. This is the way to overwrite an already stored passwork on the keyring. Default is False. """ # Developer notes: # Login via https://my.nrao.edu/cas/login # # this can be added to auto-redirect back to the query tool: ?service=https://archive.nrao.edu/archive/advquery.jsp if username is None: if not self.USERNAME: raise LoginError("If you do not pass a username to login(), " "you should configure a default one!") else: username = self.USERNAME # Check if already logged in loginpage = self._request("GET", "https://my.nrao.edu/cas/login", cache=False) root = BeautifulSoup(loginpage.content, 'html5lib') if root.find('div', class_='success'): log.info("Already logged in.") return True # Get password from keyring or prompt if reenter_password is False: password_from_keyring = keyring.get_password( "astroquery:my.nrao.edu", username) else: password_from_keyring = None if password_from_keyring is None: if system_tools.in_ipynb(): log.warning("You may be using an ipython notebook:" " the password form will appear in your terminal.") password = getpass.getpass("{0}, enter your NRAO archive password:"******"\n".format(username)) else: password = password_from_keyring # Authenticate log.info("Authenticating {0} on my.nrao.edu ...".format(username)) # Do not cache pieces of the login process data = { kw: root.find('input', {'name': kw})['value'] for kw in ('lt', '_eventId', 'execution') } data['username'] = username data['password'] = password data['execution'] = 'e1s1' # not sure if needed data['_eventId'] = 'submit' data['submit'] = 'LOGIN' login_response = self._request("POST", "https://my.nrao.edu/cas/login", data=data, cache=False) authenticated = ('You have successfully logged in' in login_response.text) if authenticated: log.info("Authentication successful!") self.USERNAME = username else: log.exception("Authentication failed!") # When authenticated, save password in keyring if needed if authenticated and password_from_keyring is None and store_password: keyring.set_password("astroquery:my.nrao.edu", username, password) return authenticated
def read_config(config_file: pathlib.Path) -> dict: if not config_file.exists(): raise ConfigurationError("Configuration file %s does not exist." % config_file) config = configparser.ConfigParser() config.optionxform = str # do not lowercase the aliases section! config.read(config_file) if not config.has_section('gtimelog2jira'): raise ConfigurationError( "Section [gtimelog2jira] is not present in %s config file." % config_file) url = config.get('gtimelog2jira', 'jira') username = config.get('gtimelog2jira', 'username') password = config.get('gtimelog2jira', 'password') timelog = config.get('gtimelog2jira', 'timelog') jiralog = config.get('gtimelog2jira', 'jiralog') projects = config.get('gtimelog2jira', 'projects') midnight = config.get('gtimelog', 'virtual_midnight', fallback='06:00') if not url: raise ConfigurationError( "Jira URL is not specified, set Jira URL via gtimelog2jira.jira setting." ) if not username: raise ConfigurationError( "Jira username is not specified, set Jira username via gtimelog2jira.username setting." ) if not projects: raise ConfigurationError( "List of projects is not specified, set Jira projects via gtimelog2jira.projects setting." ) projects = set(projects.split()) if config.has_section('gtimelog2jira:aliases'): aliases = dict(config.items('gtimelog2jira:aliases')) else: aliases = {} if not timelog: timelog = config_file.parent / 'timelog.txt' timelog = pathlib.Path(timelog).expanduser().resolve() if not timelog.exists(): raise ConfigurationError("Timelog file %s does not exist." % timelog) jiralog = pathlib.Path(jiralog).expanduser().resolve() try: jiralog.open('a').close() except OSError as e: raise ConfigurationError("Jira log file %s is not writable: %s." % (jiralog, e)) if not url.endswith('/'): url += '/' api = url + 'rest/api/2' session = requests.Session() if not password: try: password = keyring.get_password(url, username) except NoKeyringError as err: print("keyring:", err) attempts = range(3) for attempt in attempts: if attempt > 0 or not password: password = getpass.getpass('Enter Jira password for %s at %s: ' % (username, url)) try: keyring.set_password(url, username, password) except NoKeyringError: print("Failed to save the password in the system keyring.") else: print("Saved the password in the system keyring.") session.auth = (username, password) resp = session.get('%s/myself' % api) if resp.ok: break elif resp.status_code == 401: try: keyring.delete_password(url, username) except NoKeyringError: pass else: print( "Removed the saved incorrect password from the system keyring." ) raise ConfigurationError("Error: Incorrect password or username.") elif resp.status_code == 403: raise ConfigurationError( "Jira credentials seems to be correct, but this user does " "not have permission to log in.\nTry to log in via browser, " "maybe you need to answer a security question: %s" % url) else: raise ConfigurationError( "Something went wrong, Jira gave %s status code." % resp.status_code) return { 'url': url, 'api': api, 'credentials': (username, password), 'self': resp.json(), 'timelog': timelog, 'jiralog': jiralog, 'projects': projects, 'aliases': aliases, 'session': session, 'midnight': midnight, }
def set_password(self, user: str, password: str) -> None: keyring.set_password(FIGGY_KEYRING_NAMESPACE, user, password)
def set_password(*args): if not keyring is None: return keyring.set_password(*args) return False
def read_config(args, appname=None, authfile=None): appname = appname or APPNAME authfile = authfile or AUTHFILE username = "" password = "" # read if keyring: log.debug("Reading credentials from keyring") try: username, password = ( keyring.get_password(appname, appname).split('\n') + ['\n'])[:2] except AttributeError as e: # Check for old keyring format and migrate before throwing warning data = keyring.get_password(appname, '') if data: log.info("Migrating credentials to new keyring format") keyring.set_password(appname, appname, data) try: keyring.delete_password(appname, '') except AttributeError as e: log.warning( "Error deleting old keyring. Outdated library? (%s)", e) else: log.warning( "Credentials not found in keyring. First time usage?") except IOError as e: # keyring sometimes raises this log.error(e) else: log.debug("Reading credentials from '%s'" % authfile) try: with open(authfile, 'r') as fd: username, password = (fd.read().splitlines() + ['\n'])[:2] except IOError as e: if e.errno == 2: # No such file or directory log.warning("Credentials file not found. First time usage?") else: log.error(e) # save if args.username or args.password: log.info("Saving credentials") if keyring: keyring.set_password( appname, appname, '%s\n%s' % ( args.username or username, args.password or password, )) else: try: with open(authfile, 'w') as fd: fd.write("%s\n%s\n" % ( args.username or username, args.password or password, )) os.chmod(authfile, 0o600) except IOError as e: log.error(e) return dict( username=username, password=password, )
def encrypt_password(username, password): keyring.set_password(SERVICE_ID, username, password) return keyring.get_password()
def main(): with open(configfile, 'r') as f: jsonfile = json.load(f) #FIRST RUN if jsonfile["first_run"]: print(''' _____ __ _ / ____| / _(_) | | ___ _ __ | |_ _ __ _ | | / _ \| '_ \| _| |/ _` | | |___| (_) | | | | | | | (_| | \_____\___/|_| |_|_| |_|\__, | __/ | Developed by MemoriasIT |___/ ''') prompt = 'Would you like to be asked for credentials every run? ' askEveryRun = validAnswer(prompt) #Requires Mac OS X Keychain/Freedesktop Secret Service (requires secretstorage)/KWallet (requires dbus)/Windows Credential Locker prompt = 'Would you like to use the KeyRing feature? (see requirements in readme)' useKeyring = validAnswer(prompt) if not askEveryRun: prompt = 'What is your email? ' email = input(prompt) if useKeyring: YourPW = getpass.getpass("Introduce password: "******"MyBBScraper", email, YourPW) else: email = '' prompt = 'Would you like to use the SMTP notification feature?' useSMTP = validAnswer(prompt) if useSMTP: SMTP = input('Introduce SMTP:Port ') fromaddr = input('From: ') toaddrs = input('To: ') else: SMTP = '' fromaddr = '' toaddrs = '' prompt = 'How often would you like to refresh the data? (s)' RefreshRate = input(prompt) first_run = False data = { 'first_run': False, 'askEveryRun': askEveryRun, 'email': email, 'RefreshRate': RefreshRate, 'useKeyring': useKeyring, 'useSMTP': useSMTP, 'fromaddr': fromaddr, 'toaddrs': toaddrs, 'version': 'V2.3' } # Writing JSON data with open(configfile, 'w') as f: json.dump(data, f) if jsonfile["askEveryRun"] and not jsonfile["first_run"]: print(""" _ ____ _____ _____ _ _ | | / __ \ / ____|_ _| \ | | | | | | | | | __ | | | \| | | | | | | | | |_ | | | | . ` | | |___| |__| | |__| |_| |_| |\ | |______\____/ \_____|_____|_| \_| - %s Written by MemoriasIT - """ % (jsonfile["version"])) askEveryRun = jsonfile["askEveryRun"] RefreshRate = jsonfile["RefreshRate"] useKeyring = jsonfile["useKeyring"] useSMTP = jsonfile["useSMTP"] fromaddr = jsonfile["fromaddr"] toaddrs = jsonfile["toaddrs"] email = ''