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()
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 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 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 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 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)
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)
# In[5]:
from password_generator import PasswordGenerator
pwd_gen = PasswordGenerator()
pwd_gen.minuchars = 3 # Minimum Number of Upper Cased Letters
pwd_gen.minlchars = 3 # Minimum Number of Lower Cased Letters
pwd_gen.minnumbers = 3 # Minimum Number of Digits
pwd_gen.minschars = 2 # Minimum Number of Special Characters
pwd_gen.excludeschars = ",$._<>%?*" # Excluded Special Characters
if __name__ == "__main__":
while True:
choice = int(input("\n1.Add New / 2.View All / 3.Exit ? "))
if choice == 1:
with open("output.txt", "a+") as file:
pwd_num = input("\nSet Password Length : ")
place = input("Website/Application : ")
pwd_gen.maxlen = pwd_gen.minlen = int(pwd_num)
out = f"{place}:\t{pwd_gen.generate()}\n"
print(f"+++++++\n{out}+++++++")
file.write(out)
elif choice == 2:
with open("output.txt", "r") as outfile:
print("\n============================\n")
for line in outfile:
print(line)
print("============================")
elif choice == 3:
print("\n=======.Thank you.=======\n")
break
else:
print("invalid.")
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")
selected_option = input()
print("")
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)
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())
