def parse(self, response):
"""
this method is called as a callback to start scraping
"""
email = generatemail()
first_name = names.get_first_name()
last_name = names.get_last_name()
password_generator_instance = PasswordGenerator()
password_generator_instance.minlen = 10
password = password_generator_instance.generate()
self.browser.visit(self.start_urls[0])
self.browser.fill('first_name', first_name)
self.browser.fill('last_name', last_name)
self.browser.fill('email', email)
self.browser.fill('password', password)
self.browser.find_by_xpath(
'/html/body/div[1]/div/div[2]/div[1]/div[2]/div/div/div/div[2]/div[1]/div/div[1]/form/button'
).click()
SafariAccount.objects.create(name=first_name + ' ' + last_name,
email=email,
password=password)
self.browser.quit()
def generate_random_string():
password = PasswordGenerator()
password.minlen = 8
password.maxlen = 10
password.excludeschars = "!$\"\'^()."
return password.generate()
def test_generate_with_different_length(self):
"""Test generate() for fixed length"""
pg = PasswordGenerator()
length = 16
pg.minlen = length
pg.maxlen = length
self.assertEqual(len(pg.generate()), length)
def random_password(self):
selected_item = self.get_selected_lw_item()
if selected_item:
pwo = PasswordGenerator()
pwo.minlen = 8 # (Optional)
pwo.maxlen = 16 # (Optional)
pwo = pwo.generate()
self.le_password.setText(pwo)
def gerarsenha(self):
pwo = PasswordGenerator()
pwo.minlen = 8
pwo.maxlen = 12
pw = pwo.generate()
return pw
def main(): pwo = PasswordGenerator() pwo.minlen = 16 # (Optional) pwo.maxlen = 16 # (Optional) pwo.minuchars = 4 # (Optional) pwo.minlchars = 4 # (Optional) pwo.minnumbers = 8 # (Optional) pwo.minschars = 0 # (Optional) passwd = pwo.generate()
def password(self):
"""Create & return a 16-30 char alphanumeric password."""
pwo = PasswordGenerator()
pwo.minlen = 16
pwo.maxlen = 30
pwo.minuchars = 1
pwo.minlchars = 1
pwo.minnumbers = 1
pwo.minschars = 1
return pwo.generate()
async def password(e):
if environ.get("isSuspended") == "True":
return
query = e.pattern_match.group(1)
size = re.findall(r'\d+', query)
pwo = PasswordGenerator()
pwo.minlen = int(size[0])
pwo.maxlen = int(size[0])
passw = pwo.generate()
await e.edit(f"`{passw}`")
def randoms():
pwo = PasswordGenerator()
pwo.minlen = 8 # (Optional)
pwo.maxlen = 8 # (Optional)
pwo.minuchars = 2 # (Optional)
pwo.minlchars = 3 # (Optional)
pwo.minnumbers = 1 # (Optional)
pwo.minschars = 1 # (Optional)
password_string = pwo.generate()
return password_string
def pass_generator():
pwo = PasswordGenerator()
pwo.minlen = 6 # (Minimum Length)
pwo.maxlen = 12 # (Maximum Length)
pwo.minuchars = 2 # (Minimum Upper Case Characters)
pwo.minlchars = 2 # (Minimum Lower Case Characters)
pwo.minnumbers = 2 # (Minimum Numbers)
pwo.minschars = 3 # (Minimum special characters)
pass_wd = pwo.generate()
print(f'Recommended Password : {pass_wd}')
print("-" * 100)
def generate_password():
pwo = PasswordGenerator(
) # pwo, a PasswordGenerator object, is in charge of generating a new random password
pwo.minlen = 15 # Sets the password length to 15 characters
pwo.maxlen = 15
new_password = pwo.generate() # Generates a random password
print("Newly generated password: {}".format(new_password))
print(
"NOTE: Make sure you copy this password before you create your new account"
)
return new_password # returns the generated password
def create_new_user(hashed_email: str) -> User:
random_username = generate_username(1)[0]
random_username = random_username.lower()
pwo = PasswordGenerator()
pwo.minlen = 30 # (Optional)
pwo.maxlen = 30 # (Optional)
pwo.minuchars = 2 # (Optional)
pwo.minlchars = 3 # (Optional)
pwo.minnumbers = 1 # (Optional)
pwo.minschars = 0 # (Optional)
pwo.excludeschars = "!$%^*:="
random_password = pwo.generate()
random_email = f'{random_username}@example.com'
return add_user(f'{random_username}', random_password, random_email, '', hashed_email, exitOnFailure=False)
def gerarsenha():
pwo= PasswordGenerator()
pwo.minlen = 8
pwo.maxlen = 12
pw = pwo.generate()
print(f'\33[1;35m A senha segura que o sistema gerou foi:\33[m \33[1;33m{pw} \33[m')
colar = input('\33[1;34m Deseja mandar a senha gerada a área de transferencia? S ou N :\33[m').lower()
if colar == 'n':
print('Ok')
elif colar == 's':
pyperclip.copy(pw)
print('\33[1;32m Senha copiada com sucesso!\33[m')
else:
print('\33[1;31m Digita S para sim e N para não\33[m')
def post(self, request):
regex = '^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$'
valid_emails = []
pwo = PasswordGenerator()
pwo.minlen = 20
pwo.maxlen = 20
pwo.minuchars = 3
pwo.minlchars = 3
pwo.minnumbers = 5
pwo.minschars = 3
pwo.excludeschars = ".,;:"
for email in request.data['list']:
if (re.search(regex, email)):
queryset = Organization.objects.filter(
id=request.data['org_id'])
org = get_object_or_404(queryset, )
password = pwo.generate()
store_invited_email = InvitedUser.objects.create(
email=email, password=password, organization_id=org)
send_mail(
'Login Credentials',
f'''
Good day!
You've been invited to join {org} at Connectico. Please use the given credentials to login at 127.0.0.1:4200.
Email: {email}
Password: {password}
Regards,
Connectico Team
''',
'Connectico Team',
[email],
fail_silently=False,
)
valid_emails.append(email)
else:
print('Discarded', email)
return Response(valid_emails)
def user_generator(n=10):
df = {
'username': [],
'email': [],
'password': [],
'first_name': [],
'last_name': [],
'is_active': [],
'is_superuser': [],
'is_staff': [],
'hr_id': [],
'sb_id': [],
'tg_id': [],
}
for i in range(n):
first_name = names.get_first_name()
last_name = names.get_last_name()
username = first_name + '_' + last_name
email = username + str(random.randint(10,
99)) + random.choice(email_end)
pw = PasswordGenerator()
pw.maxlen = 10
pw.minlen = 10
password = pw.generate()
df['username'].append(username)
df['email'].append(email)
df['password'].append(password)
df['first_name'].append(first_name)
df['last_name'].append(last_name)
df['is_active'].append(True)
df['is_superuser'].append(False)
df['is_staff'].append(False)
df['hr_id'].append(90000 + i)
df['sb_id'].append(10000 + i)
df['tg_id'].append(random.randint(10000000, 99999999))
return df
def forgotPassword():
"""Request temp password if forgotten"""
# User reached route via POST (as by submitting a form via POST)
if request.method == "POST":
username = request.form.get("username")
email = request.form.get("email")
# Query database for username
if not username:
flash("Username Required", 'danger')
return render_template("forgot_password.html")
user_info = db.execute(
"SELECT username, email FROM users WHERE username = ? AND email = ?",
username, email)
# Ensure account exists
if not user_info:
flash("Invalid username or email!", 'danger')
return render_template("forgot_password.html")
# create temporary password
pwo = PasswordGenerator()
# length of required password
pwo.minlen = 6
pwo.maxlen = 15
# generate temporary password
temp = pwo.generate()
# Update the hashed password in the database
hash_password = generate_password_hash(temp)
db.execute("UPDATE users SET hash = ? WHERE username = ?",
hash_password, username)
flash(
"Temporary password sent. Please use it to change your password!",
'success')
# send email notification with a temporary password (remains valid until the password is changed using the "Change Password" feature
# or another "Forgot Password" POST request is made in which case a new email is sent with a new temp password)
# to test this feature, you may create an account with a your own email or use the account information only used for this project
# weebtube username: cs50user
# email: [email protected]
# email password: weebtube#234
msg = Message("Forgot Password - WeebTube", recipients=[email])
msg.html = render_template("reset_password.html",
username=username,
temp=temp)
mail.send(msg)
# Redirect user to change password
return redirect("/new-password")
# User reached route via GET (as by clicking the Forgot Password button)
else:
return render_template("forgot_password.html")
import os
from password_generator import PasswordGenerator
pwo = PasswordGenerator()
pwo.minlen = 10 # (Optional)
pwo.maxlen = 30
def save_picture(location , form_picture):
hashed_caption = pwo.generate()
f_name,f_ext = os.path.splitext(form_picture.filename)
f_ext = str(f_ext)
print(f_ext)
if(f_ext not in ['.jpg' , '.jpeg' , '.png' , '.psd' , '.ai']):
return 0
fn = hashed_caption + f_name
picture_fn = fn + f_ext
picture_path = os.path.join(location , 'static/task_pictures_instructor' , picture_fn)
form_picture.save(picture_path)
return picture_fn
def save_picture_student(location , form_picture):
hashed_caption = pwo.generate()
f_name,f_ext = os.path.splitext(form_picture.filename)
if(f_ext not in ['.jpg' , '.jpeg' , '.png' , '.psd' , '.ai']):
return 0
fn = hashed_caption + f_name
picture_fn = fn + f_ext
picture_path = os.path.join(location , 'static/task_pictures_student' , picture_fn)
form_picture.save(picture_path)
return picture_fn
while True:
pw = input("Input password to access database (5 to quit application) ")
if pw == "5":
sys.exit()
try:
conn = psycopg2.connect(host="localhost",
database="password_manager",
user="******",
password=pw)
print("Correct password... Accessing database...")
break
except:
print("...Incorrect password input...")
pwgen = PasswordGenerator()
pwgen.minlen = 32
pwgen.maxlen = 32
pwgen.minuchars = 3
pwgen.minlchars = 3
pwgen.minschars = 3
#pwgen.excludeschars = "!$%^" # (if certain characters are typically not accepted)
cur = conn.cursor()
while True:
print("")
print("1: Generate and add password to password bank")
print("2: Access passwords")
print("3: See all registered applications")
print("4: See all registered data")
print("5: Quit application")
def generate_password():
pwo = PasswordGenerator()
pwo.minlen = app.config['PASSWORD_MIN_LEN']
pwo.maxlen = app.config['PASSWORD_MAX_LEN']
pwo.minschars = 0
return pwo.generate()
def id_generator():
pwo = PasswordGenerator()
pwo.minlen = 15
pwo.excludeschars = "^'"
return pwo.generate()
from password_generator import PasswordGenerator
from util import data_io
if __name__ == '__main__':
pwo = PasswordGenerator()
pwo.minlen = 9
pwo.maxlen = 9
def build_user(eid, user_name):
return {'name': user_name, 'password': pwo.generate(), 'id': eid}
data_io.write_jsonl('annotators.jsonl',
(build_user(k + 2, user_name) for k, user_name in
enumerate(['Salar', 'Vinicius', 'Tarcisio', 'Tilo'])))
'#hs_cos_wrapper_module_16158863021462 > table > tbody > tr > td > a')
verifyButton.click()
print("Verify Button Clicked!")
browser.switch_to.default_content()
print("Switched Back")
time.sleep(7)
browser.switch_to.window(browser.window_handles[2])
nameButton = browser.find_element_by_css_selector('#mat-input-1')
nameButton.send_keys(names.get_full_name())
pwo = PasswordGenerator()
pwo.minlen = 10
password = pwo.generate()
passButton = browser.find_element_by_css_selector('#mat-input-2')
passButton.send_keys(password)
confirmPassButton = browser.find_element_by_css_selector('#mat-input-3')
confirmPassButton.send_keys(password)
continueButton = browser.find_element_by_css_selector('#continue-button')
continueButton.click()
time.sleep(30)
print("Details Submitted!")
while num.isnumeric() == False:
print(
"That's not an integer. You can only input an integer! Please try again."
)
num = input(question)
return num
pwd = PasswordGenerator()
pwd_min_length = input_int(
"What do you want the password's minimum length to be? ")
pwd_max_length = input_int(
"What do you want the password's maximum length to be? ")
pwd_min_upper_case = input_int(
"How many characters at the minimum should be uppercase? ")
pwd_min_lower_case = input_int(
"How many characters at the minimum should be lowercase? ")
pwd_min_num = input_int(
"How many numbers at the minimum should the passowrd contain? ")
pwd_min_spec_char = input_int(
"How many characters at the minimum should be special? ")
pwd.minlen = int(pwd_min_length)
pwd.maxlen = int(pwd_max_length)
pwd.minuchars = int(pwd_min_upper_case)
pwd.minlchars = int(pwd_min_lower_case)
pwd.minnumbers = int(pwd_min_num)
pwd.minschars = int(pwd_min_spec_char)
print(pwd.generate())
def initDB(dbName="ama", roleName="attacker"):
"""
Database initialization
(creation of database, role, and initialization of default workspace)
"""
try:
#cmd2.Cmd.poutput(f"Creating {roleName} role")
print_status(f"Creating role: {ColorStr(roleName).StyleBRIGHT}")
password = getpass(
prompt=
f"Password for {ColorStr(roleName).StyleBRIGHT} role (empty for random generation): "
)
if not password:
passwd = PasswordGenerator()
passwd.minlen = 16
passwd.maxlen = 16
passwd.minnumbers = 2
passwd.minschars = 3
passwd.minuchars = 2
password = passwd.generate()
Bash.exec(
f"psql -U postgres -c \"CREATE ROLE {roleName} WITH LOGIN CREATEDB PASSWORD '{password}'\"",
quiet=True)
Bash.exec(
f"psql -U postgres -c \"CREATE DATABASE {roleName} OWNER {roleName}\"",
quiet=True)
#cmd2.Cmd.poutput(f"Role {roleName} has been created")
print_successful(
f"Role {ColorStr(roleName).StyleBRIGHT} has been created")
#cmd2.Cmd.poutput(f"Creating {dbName} database")
print_status(f"Creating {ColorStr(dbName).StyleBRIGHT} database")
Bash.exec(
f"psql -U {roleName} -c \"CREATE DATABASE {dbName} OWNER {roleName}\"",
quiet=True)
#cmd2.Cmd.poutput("Database {dbName} has been created")
# creation workspaces table
dbCredential = {
'host': 'localhost',
'database': dbName,
'user': roleName,
'password': password
}
workspace = "default"
tablesCreation = ("""
CREATE TABLE IF NOT EXISTS workspaces (
name VARCHAR (100) UNIQUE NOT NULL
)
""", f"""
CREATE TABLE IF NOT EXISTS hashes_{workspace} (
hash VARCHAR (128) UNIQUE NOT NULL,
type VARCHAR (20),
cracker VARCHAR (20) NOT NULL,
password VARCHAR (32) NOT NULL
)
""", f"""
CREATE TABLE IF NOT EXISTS services_{workspace} (
service VARCHAR (20) NOT NULL,
target VARCHAR (15) NOT NULL,
service_user VARCHAR (20) NOT NULL,
password VARCHAR (32) NOT NULL
)
""")
valueInsert = ("""
INSERT INTO workspaces (name)
VALUES (%s);
""")
conn = None
conn = psycopg2.connect(**dbCredential)
cur = conn.cursor()
# workspace table creation and
# hashes and services tables creation for "default" workspace
for cmdTable in tablesCreation:
cur.execute(cmdTable)
conn.commit()
# default workspace insertion
cur.execute(valueInsert, (workspace, ))
conn.commit()
cur.close()
print_successful(
f"Database {ColorStr(dbName).StyleBRIGHT} has been created")
#import pdb; pdb.set_trace()
# writing credential to AMA_HOME/db/database.json file
database_json_file = Path.joinpath(AMA_HOME, 'db/database.json')
with open(database_json_file, 'w') as db_credentials:
json.dump(dbCredential, db_credentials, indent=4)
print_successful(
f"Database credential file has been created: {ColorStr(database_json_file).StyleBRIGHT}"
)
del dbCredential
except (Exception, psycopg2.DatabaseError) as error:
print_failure(error)
# In[1]:
from password_generator import PasswordGenerator
# In[2]:
password=PasswordGenerator()
# In[3]:
password.minlen=6
password.maxlen=8
password.minuchars=2
password.minlchars=2
password.maxschars=0
password.minnumbers=2
# In[4]:
def create():
result=password.generate()
pw.insert(0,result)
async def generate(request):
pwo = PasswordGenerator()
# Получаем политику, если передали в запросе
if 'policy' in request.args and request.args['policy'][0]:
if request.args['policy'][0].upper() in app.config.POLICY:
# Есть в списке, выбираем ее
policy = request.args['policy'][0].upper()
else:
# Не нашли, выбираем политику по-умолчанию
policy = 'DEFAULT'
else:
# Политику не передали, выбираем политику по-умолчанию
policy = 'DEFAULT'
# Получаем список символов, которые нужно избегать при генерации пароля
# Большие буквы
if 'excludeuchars' in request.args and request.args['excludeuchars'][0]:
excludeuchars = request.args['excludeuchars'][0]
else:
# Не переданы, берем из выбранной политики
excludeuchars = app.config.POLICY[policy]['excludeuchars']
# Маленькие буквы
if 'excludelchars' in request.args and request.args['excludelchars'][0]:
excludelchars = request.args['excludelchars'][0]
else:
# Не переданы, берем из выбранной политики
excludelchars = app.config.POLICY[policy]['excludelchars']
# Цифры
if 'excludenumbers' in request.args and request.args['excludenumbers'][0]:
excludenumbers = request.args['excludenumbers'][0]
else:
# Не переданы, берем из выбранной политики
excludenumbers = app.config.POLICY[policy]['excludenumbers']
# Специальные символы
if 'excludeschars' in request.args and request.args['excludeschars'][0]:
excludeschars = request.args['excludeschars'][0]
else:
# Не переданы, берем из выбранной политики
excludeschars = app.config.POLICY[policy]['excludeschars']
# Проверяем, если не указана минимальная длина пароля
if 'minlen' in request.args and request.args['minlen'][0]:
minlen = int(request.args['minlen'][0]) if int(
request.args['minlen'][0]) > 0 else int(
app.config.POLICY[policy]['minlen'])
else:
# Не указана, берем из выбранной политики
minlen = int(app.config.POLICY[policy]['minlen'])
# Проверяем, если не указана максимальная длина пароля
if 'maxlen' in request.args and request.args['maxlen'][0]:
maxlen = int(request.args['maxlen'][0]) if int(
request.args['maxlen'][0]) > 0 else int(
app.config.POLICY[policy]['maxlen'])
else:
# Не указана, берем из выбранной политики
maxlen = int(app.config.POLICY[policy]['maxlen'])
# Если минимальная длина пароля больше максимальной, тогда приравниваем их
if minlen > maxlen:
maxlen = minlen
# Проверяем, если не указано минимальное число прописных символов в пароле
if 'minuchars' in request.args and request.args['minuchars'][0]:
minuchars = int(request.args['minuchars'][0])
else:
# Не указана, берем из выбранной политики
minuchars = int(app.config.POLICY[policy]['minuchars'])
# Проверяем, если не указано минимальное число строчных символов в пароле
if 'minlchars' in request.args and request.args['minlchars'][0]:
minlchars = int(request.args['minlchars'][0])
else:
# Не указана, берем из выбранной политики
minlchars = int(app.config.POLICY[policy]['minlchars'])
# Проверяем, если не указано минимальное число цифр в пароле
if 'minnumbers' in request.args and request.args['minnumbers'][0]:
minnumbers = int(request.args['minnumbers'][0])
else:
# Не указана, берем из выбранной политики
minnumbers = int(app.config.POLICY[policy]['minnumbers'])
# Проверяем, если не указано минимальное число специальных символов в пароле
if 'minschars' in request.args and request.args['minschars'][0]:
minschars = int(request.args['minschars'][0])
else:
# Не указана, берем из выбранной политики
minschars = int(app.config.POLICY[policy]['minschars'])
ret = {}
# Генерируем пароль
try:
pwo.minlen = minlen
pwo.maxlen = maxlen
pwo.minuchars = minuchars
pwo.minlchars = minlchars
pwo.minnumbers = minnumbers
pwo.minschars = minschars
pwo.excludelchars = excludelchars
pwo.excludeuchars = excludeuchars
pwo.excludenumbers = excludenumbers
pwo.excludeschars = excludeschars
newpass = pwo.generate()
ret = {
'status': 'success',
'password': newpass,
"policy": policy,
'length': len(newpass)
}
except ValueError as e:
ret = {'status': 'fail', 'password': '', "policy": policy, 'error': e}
return json(ret)
def gen_password(len=8):
pwo = PasswordGenerator()
pwo.minlen = len
pwo.maxlen = len
return pwo.generate()
#!/usr/bin/env python3 from password_generator import PasswordGenerator pwo = PasswordGenerator() pwo.minlen = 32 pwo.maxlen = 32 pwo.excludeschars = "!$%^.#()[]&<>," print(pwo.generate())
def password_generater():
pwo = PasswordGenerator()
pwo.minlen = 15
pwo.maxlen = 20
return pwo.generate()
def createUser(idUser=None):
data = request.get_json()
user = User.query.get(get_jwt_identity())
if not user:
return {
'status': 'error',
'message': 'Usuário Inexistente!',
'code': 'errors.invalidUser'
}, status.HTTP_400_BAD_REQUEST
dbSession.setSchema(user.schema)
roles = user.config[
'roles'] if user.config and 'roles' in user.config else []
if ('userAdmin' not in roles):
return {
'status': 'error',
'message': 'Usuário não autorizado',
'code': 'errors.unauthorizedUser'
}, status.HTTP_401_UNAUTHORIZED
if not idUser:
userEmail = data.get('email', None)
userName = data.get('name', None)
emailExists = User.findByEmail(userEmail) != None
if emailExists:
return {
'status': 'error',
'message': 'Já existe um usuário com este email!',
'code': 'errors.emailExists'
}, status.HTTP_400_BAD_REQUEST
newUser = User()
newUser.email = userEmail
newUser.name = userName
newUser.external = data.get('external', None)
newUser.active = bool(data.get('active', True))
newUser.schema = user.schema
pwo = PasswordGenerator()
pwo.minlen = 6
pwo.maxlen = 16
password = pwo.generate()
newUser.password = func.crypt(password, func.gen_salt('bf', 8))
if ('admin' in roles):
newUser.config = {'roles': data.get('roles', [])}
else:
newUserRoles = roles.copy()
#remove administration roles
try:
newUserRoles.remove('userAdmin')
newUserRoles.remove('admin')
newUserRoles.remove("suporte")
except ValueError:
pass
newUser.config = {'roles': newUserRoles}
db.session.add(newUser)
db.session.flush()
response, rstatus = tryCommit(db, newUser.id)
if rstatus == status.HTTP_200_OK:
sendEmail(
"Boas-vindas NoHarm: Credenciais", Config.MAIL_SENDER,
[userEmail],
render_template('new_user.html',
user=userName,
email=userEmail,
password=password,
host=Config.MAIL_HOST))
return response
else:
updatedUser = User.query.get(idUser)
if (updatedUser is None):
return {
'status': 'error',
'message': '!Usuário Inexistente!',
'code': 'errors.invalidUser'
}, status.HTTP_400_BAD_REQUEST
if (updatedUser.schema != user.schema):
return {
'status': 'error',
'message': 'Usuário não autorizado',
'code': 'errors.unauthorizedUser'
}, status.HTTP_401_UNAUTHORIZED
updatedUser.name = data.get('name', None)
updatedUser.external = data.get('external', None)
updatedUser.active = bool(data.get('active', True))
if ('admin' in roles):
if updatedUser.config is None:
updatedUser.config = {'roles': data.get('roles', [])}
else:
newConfig = updatedUser.config.copy()
newConfig['roles'] = data.get('roles', [])
updatedUser.config = newConfig
db.session.add(updatedUser)
db.session.flush()
return tryCommit(db, updatedUser.id)
