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)
