def generate_password(config): wordfile = xp.locate_wordfile() words = xp.generate_wordlist(wordfile) return xp.generate_xkcdpassword( words, numwords=config["DEFAULT"].get("NumWords", 6), delimiter=config["DEFAULT"].get("Delimiter", "-"))
def run(self, username, password=None): with self.app_context(): if not password: wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=5, max_length=8) password = xp.generate_xkcdpassword(mywords, acrostic="ambit") print("generated password: '******'" % password) assert not User.query.filter_by( username=username).scalar(), "user already exists" user = User(username=username) user.password = self.app_bcrypt.generate_password_hash( password, 10) if user.password is not str: user.password = user.password.decode('utf-8') user.active = True db.session.add(user) db.session.commit() print("created user '%s' in '%s'" % (user.username, db.engine.url))
def __init__(self): wordfile = xkcd_password.locate_wordfile() mywords = xkcd_password.generate_wordlist(wordfile=wordfile, min_length=5, max_length=8) self.name = xkcd_password.generate_xkcdpassword(mywords, acrostic="server")
def get_pass(word_len, min_len, max_len): words = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=words, min_length=min_len, max_length=max_len) raw_password = xp.generate_xkcdpassword(mywords, numwords=word_len) return passgen(raw_password, word_len)
def print_poem(): """ Called on a short press of the button, in main(). Selects a poem based on the day of the month, looks for the corresponding file in the poems directory, formats the author and title, and prints it. """ PRINTER.wake() PRINTER.println("Password For: __________________") PRINTER.feed(1) from xkcdpass import xkcd_password as xp wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=5, max_length=8) passwd = xp.generate_xkcdpassword(mywords, numwords=4, delimiter="-") PRINTER.feed(3) PRINTER.println(passwd) PRINTER.feed(6) PRINTER.sleep()
def generate_user_password(): """Generate passwords from the xkcd library for user level accounts""" # generate password for a user level app wordfile = xkcd_password.locate_wordfile() mywords = xkcd_password.generate_wordlist(wordfile=wordfile) return xkcd_password.generate_xkcdpassword(mywords, acrostic='rock')
def run(self, terms, variables=None, **kwargs): if not HAS_XKCDPASS: raise AnsibleLookupError( "Python xkcdpass library is required. " 'Please install using "pip install xkcdpass"') self.set_options(var_options=variables, direct=kwargs) method = self.get_option("case") delimiter = self.get_option("delimiter") max_length = self.get_option("max_length") min_length = self.get_option("min_length") numwords = self.get_option("numwords") words = xp.locate_wordfile() wordlist = xp.generate_wordlist(max_length=max_length, min_length=min_length, wordfile=words) values = xp.generate_xkcdpassword(wordlist, case=method, delimiter=delimiter, numwords=numwords) return [values]
def generate_new_port_password_pair(current_ports): global MIN_PORT_NUMBER, MIN_PORT_NUMBER global MIN_PASSWORD_LENGTH, MAX_PASSWORD_LENGTH ############################################################################### # 1. generate the new port ############################################################################### possible_ports = set(range(MIN_PORT_NUMBER, MAX_PORT_NUMBER + 1)) - set(current_ports) if not possible_ports: raise ValueError("Didn't have any ports to choose from!") # could also do ## new_port = possible_ports.pop() # but I was concerned that would make the port number too predictable new_port = random.choice(list(possible_ports)) ############################################################################### # 2. generate the new password ############################################################################### xkcd_wordfile = xp.locate_wordfile() xkcd_wordlist = xp.generate_wordlist(wordfile=xkcd_wordfile, max_length=5) new_password = xp.generate_xkcdpassword(xkcd_wordlist, numwords=4, delimiter='-') #new_password = xp.generate_xkcdpassword(xkcd_wordlist, acrostic="ethvpn") return str(new_port), str(new_password)
def generatePassphrase(wordscount=4): wordfile = xp.locate_wordfile('eff-long') mywords = xp.generate_wordlist(wordfile=wordfile, min_length=4, max_length=8) return xp.generate_xkcdpassword(mywords, numwords=wordscount, delimiter='+')
def mkpasswd(): words = xp.locate_wordfile() mywords = xp.generate_wordlist( wordfile=words, min_length=5, max_length=8 ) pwd = xp.generate_xkcdpassword(mywords) return pwd.lower()
def __get_authenticated_code__(): wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=3, max_length=8) return xp.generate_xkcdpassword(mywords, acrostic=chr(random.randrange(97, 122)) + chr(random.randrange(97, 122)))
def gen_pswrd(): word_file = xp.locate_wordfile() my_words = xp.generate_wordlist(wordfile=word_file, min_length=5, max_length=7) return xp.generate_xkcdpassword(my_words, numwords=4, delimiter="-", case='random')
def __generate_password(self): wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=4, max_length=5) new_pass = xp.generate_xkcdpassword(mywords, delimiter=".", numwords=4) return new_pass
def getxkcdpass(): wordfile = xp.locate_wordfile() config = xp.generate_wordlist(wordfile=wordfile, min_length=5, max_length=8) return (xp.generate_xkcdpassword(config, acrostic=False, delimiter="-", numwords=4))
def password_generator(request): wordfile = xp.locate_wordfile() words = xp.generate_wordlist(wordfile=wordfile, min_length=2, max_length=8) generated = xp.generate_xkcdpassword( words, acrostic=request.user.first_name.lower()) messages.info( request, 'Your randomly generated password is: <strong>{}</strong>'.format( generated)) return redirect('/')
def generate_password(member): from xkcdpass import xkcd_password as xp wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=8, max_length=10) password = xp.generate_xkcdpassword(mywords, numwords=2, delimiter='').lower().translate( None, ' -_') return (password)
def suggest_password(cls): from xkcdpass import xkcd_password as xp xp_wordfile = xp.locate_wordfile() xp_wordlist = xp.generate_wordlist( wordfile=xp_wordfile, min_length=4, max_length=6, valid_chars='[a-z]' ) suggested_password = xp.generate_xkcdpassword( xp_wordlist, numwords=4, acrostic='wild', delimiter=' ' ) return suggested_password
def __init__(self, wordfile=None, min_length=5, max_length=9, valid_chars="."): self.wordfile = xp.locate_wordfile(wordfile) self.words = xp.generate_wordlist(wordfile=wordfile, min_length=min_length, max_length=max_length, valid_chars=".") add_frequency_lists({"words": self.words})
def _generate_passwd(length=4): """ Create an XKCD style (correct-horse-battery-staple) password. Keyword arguments: length -- Number of words to have in password """ wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=5, max_length=8) return xp.generate_xkcdpassword(mywords, delimiter="-", numwords=length)
def passphrase_generator(len=12): """ Generates a random passphrase :param len: :return: """ from xkcdpass import xkcd_password as xp wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=5, max_length=8) return xp.generate_xkcdpassword(mywords, numwords=len)
def _get_words(self, options): """Locate a word file and parse it to get a list of words from which xkcdpass module will randomly choose a passphrase. The word file may be specified in the configuration file specific to a particular deployment. Otherwise the algorithm will try to locate a standard word file from well known locations. :param options: contains options for xkcdpass configuring the type of words to include. :returns: list of words """ wordfile = CONFIG['wordfile'] or xp.locate_wordfile() try: min_length = options['min_length'] except (TypeError, KeyError): min_length = 5 try: max_length = options['max_length'] except (TypeError, KeyError): max_length = 9 try: valid_chars = options['valid_chars'] except (TypeError, KeyError): valid_chars = "." # Sanity validation msg = "Invalid password generation options!" if min_length < 1 or min_length > 15: desc = ("For sanity's sake, minimum length must be " "a positive number less than or equal to 15.") raise bh.OppError(msg, desc) if max_length < 5 or max_length > 20: desc = ("For sanity's sake, maximum length must" " be a number between 5 and 20.") raise bh.OppError(msg, desc) if min_length > max_length: desc = "Minimum length cannot be larger than maximum length." raise bh.OppError(msg, desc) try: return xp.generate_wordlist(wordfile=wordfile, min_length=min_length, max_length=max_length, valid_chars=valid_chars) except Exception: raise bh.OppError("Exception during password generation!", None, 500)
def generate_password(length=4, delimiter="-", easy_mode=False): """returns a xkcd-style password""" if easy_mode == True: return generate_easy_password() wordfile = xp.locate_wordfile("ger-anlx") mywords = xp.generate_wordlist(wordfile=wordfile, min_length=3, max_length=16, valid_chars="[a-z]") password = xp.generate_xkcdpassword(mywords, numwords=length, delimiter=delimiter, case="capitalize") return password
def generate_password(unique=False): """Generate an XKCD style password""" # create a wordlist from the default wordfile # use words between 5 and 8 letters long wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=5, max_length=8) # Chose a random four-letter word for acrostic acword = random.choice( # nosec xp.generate_wordlist(wordfile=wordfile, min_length=4, max_length=4)) # create a password with acrostic word pword = xp.generate_xkcdpassword(mywords, acrostic=acword) return pword
def generate_password(self): def capitalize_first_letter(s): new_str = [] s = s.split(" ") for i, c in enumerate(s): new_str.append(c.capitalize()) return "".join(new_str) words = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=words, min_length=5, max_length=8) raw_password = xp.generate_xkcdpassword(mywords) return capitalize_first_letter(raw_password)
def handle_creator_password(self, message): number_of_words = message.data.get("NumberOfWords") number_of_words = extract_number( number_of_words) if number_of_words else 6 acrostic = message.data.get("Acrostic") acrostic = acrostic if acrostic else False wordfile = xp.locate_wordfile() words = xp.generate_wordlist(wordfile=wordfile) # Can modify password = xp.generate_xkcdpassword(words, number_of_words, acrostic=acrostic) # Can modify self.speak_dialog('creator.password', data={'password': password})
async def start_quiz(self, data: Dict): print("Quiz registration was called") game_name = data["game_name"] participants = data["players"] participants_list = [] con = await self.pool.acquire() cur = await con.cursor() await cur.execute("SELECT id from roles WHERE name=%s", ("mobile-client", )) user_role_id = await cur.fetchone() user_role_id = user_role_id[0] game_id = await self.get_tag_id(game_name) time_stmp = datetime.datetime.now() try: await cur.execute("INSERT INTO games VALUES(%s, %s)", (game_id, time_stmp)) except Exception: print("Warning! Game was initiated before") finally: full_game_name = "com." + game_name wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=5, max_length=5) for user_name in participants: secret = xp.generate_xkcdpassword(mywords, acrostic="hi", delimiter=":") # secret = string.capwords(secret) await cur.execute( "INSERT INTO users(name, secret, role_id) VALUES(%s, %s, %s) RETURNING id", (user_name, secret, user_role_id)) # self.cur.execute("SELECT last_insert_rowid()") cur_user_id = await cur.fetchone() cur_user_id = cur_user_id[0] participants_list.append(cur_user_id) await cur.execute("INSERT INTO user_game VALUES(%s, %s)", (cur_user_id, game_id)) cur_game = await self.subscribe( lambda question: self.on_question_posted(game_name, question), full_game_name + ".questions") self.games[game_name] = Dbase.Game(cur_game, game_id) self.games[game_name].participants_list = participants_list print("subscribed") print(self.pool.freesize) await self.pool.release(con) return True
def get_password(): acrostic_term = request.json['text'] min_length = int(request.json['min_length']) max_length = int(request.json['max_length']) print('term', acrostic_term) # create a wordlist from the default wordfile # use words between 5 and 8 letters long wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=min_length, max_length=max_length, valid_chars='.') # create a password with the acrostic "face" print(xp.generate_xkcdpassword(mywords, acrostic=acrostic_term)) return xp.generate_xkcdpassword(mywords, acrostic=acrostic_term)
def run(self, username, password=None): with self.app_context(): if not password: wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=5, max_length=8) password = xp.generate_xkcdpassword(mywords, acrostic="ambit") print("generated password: '******'" % password) assert not User.query.filter_by(username=username).scalar(), "user already exists" user = User(username=username) user.password = self.app_bcrypt.generate_password_hash(password, 10) user.active = True db.session.add(user) db.session.commit() print("created user '%s' in '%s'" % (user.username, db.engine.url))
def __init__(self, server_socket, client_socket): self.MIN_PORT_NUMBER, self.MAX_PORT_NUMBER = 1024, 2048 self.MAX_PASSWORD_LENGTH = 28 self.PASSWORD_NUMBER_OF_WORDS = 4 #self.SOCKET_BUFFER_SIZE = 1506 self.SOCKET_BUFFER_SIZE = 4096 self.xkcd_wordfile = xp.locate_wordfile() self.xkcd_wordlist = xp.generate_wordlist(wordfile=self.xkcd_wordfile, max_length=5) # keep track of all of the ports currently in use self.ports_in_use = set([]) self.data_used = dict([]) self.sock = None self.server_address = server_socket self.client_address = client_socket if not os.path.exists(self.server_address): raise ValueError("server socket %s did not exist." % self.server_address) if os.path.exists(self.client_address): raise ValueError("client socket %s already exists." % self.client_address) # Datagram (udp) socket try: self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) print('Socket created.') self.sock.bind(self.client_address) print("Bound client to socket", self.client_address, '.') self.sock.connect(self.server_address) print("Connected to socket", self.server_address, '.') except socket.error as err: print('Failed to create socket. Error Code : ' + str(err[0]) + ' Message ' + err[1]) sys.exit()
def create_ethereum_account(): ac = Account.create() wf = xp.locate_wordfile() words = xp.generate_wordlist(wordfile=wf, min_length=5, max_length=8) password_str = xp.generate_xkcdpassword(words) print( cyan( "password string to decrypt private key -- please store in safe location:" )) print() print(yellow(password_str)) print() print(cyan("address:")) print(yellow(ac.address)) ks = json.dumps(Account.encrypt(ac.privateKey, password_str), indent=2) print(red(ks))
def random_password(user_id): """Sends a new password after generating it.""" try: user = User.objects.get(id=user_id) wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=5, max_length=10) password = xp.generate_xkcdpassword(mywords) user.password = password user.save() msg = create_message('Your new password', user.email) context = {'user': user.to_dict(), 'password': password} msg.body = render_template('emails/pass.txt', **context) mail.send(msg) except (db.DoesNotExist): app.logger.warning( 'Attempted to send new password to non existing user.')
def json_password_generator(request): # Example Django view to generate passphrase suggestions via xkcd library # Called with optional params e.g. # /json_password_generator/?tc=true&separator=|&acrostic=face if request.method == 'GET': acrostic = request.GET.get("acrostic", None) titlecase = request.GET.get("tc", None) wordfile = xp.locate_wordfile() words = xp.generate_wordlist( wordfile=wordfile, min_length=3, max_length=8) suggestion = xp.generate_xkcdpassword(words, acrostic=acrostic) if titlecase: # Convert "foo bar" to "Foo Bar" suggestion = suggestion.title() return JsonResponse({ 'suggestion': suggestion} )
import random import xkcdpass.xkcd_password as xp def random_capitalisation(s, chance): new_str = [] for i, c in enumerate(s): new_str.append(c.upper() if random.random() < chance else c) return "".join(new_str) def capitalize_first_letter(s): new_str = [] s = s.split(" ") for i, c in enumerate(s): new_str.append(c.capitalize()) return "".join(new_str) words = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=words, min_length=5, max_length=8) raw_password = xp.generate_xkcdpassword(mywords) for i in range(5): print(random_capitalisation(raw_password, i/10.0)) print(capitalize_first_letter(raw_password))
def mkpasswd(): words = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=words, min_length=5, max_length=8) pwd = xp.generate_xkcdpassword(mywords) return pwd.lower()
def generate_password(member): from xkcdpass import xkcd_password as xp wordfile = xp.locate_wordfile() mywords = xp.generate_wordlist(wordfile=wordfile, min_length=8, max_length=10) password = xp.generate_xkcdpassword(mywords, numwords=2, delimiter='').lower().translate(None, ' -_') return(password)