def test_default(self):
'''Check if length of password is 30 by default and all character
types are used by default to generate password
'''
status = True
length = 30
password = generate_password()
password_list = generate_password().split()
ascii_range = self.uppercase + self.lowercase + self.numbers + self.symbols
if len(password) != length:
status = False
if len(password_list) != 1:
status = False
for letter in password:
if ord(letter) not in ascii_range:
status = False
self.assertTrue(
status,
"Password length or characters of password incorrect")
def test_password_request(request_message,
secret=STANDARD_SECRET,
pw_length=pg.MIN_PW_LENGTH,
hit_enter=True):
usb_comm.send_standard_pw_request(request_message,
hit_enter=hit_enter,
pw_length=pw_length)
recv_pw = input()
print(pg.generate_password(secret, request_message, pw_length))
assert recv_pw == pg.generate_password(secret, request_message, pw_length)
def fill_password():
global window2, nr_letters_entry, nr_symbols_entry, nr_numbers_entry
nr_letters = nr_letters_entry.get()
nr_symbols = nr_symbols_entry.get()
nr_numbers = nr_numbers_entry.get()
if len(nr_letters) == 0 or len(nr_symbols) == 0 or len(nr_numbers) == 0:
messagebox.showerror(
title="Empty Fields",
message="Please make sure you haven't left any fields empty")
return
if nr_letters.isdigit() != 1 or nr_symbols.isdigit(
) != 1 or nr_numbers.isdigit() != 1:
messagebox.showerror(
title="Not Digits",
message="Please make sure you entered only digits in the fields")
return
generated_password = password_generator.generate_password(
int(nr_letters), int(nr_symbols), int(nr_numbers))
pyperclip.copy(generated_password) # Copying the password to the clipboard
password_entry.delete(0, 'end')
password_entry.insert(END, generated_password)
window2.destroy()
def main(argv):
try:
opts, args = getopt(argv, 'h', LONG_OPTIONS)
length = 16
if len(args) and args[0].isdigit():
length = int(args[0])
opt_list = []
for opt, _ in opts:
if opt == '-h':
help()
exit()
else:
opt_list.append(opt[2:])
options = []
for option in LONG_OPTIONS:
if not option in opt_list:
options.append(option[3:])
if not len(options):
raise GetoptError('Can\'t generate password with no char type')
except GetoptError as err:
print(err)
help()
except:
print(exc_info())
help()
else:
print(generate_password(length, options))
def add_password(account):
"""
Add the account and password dictionary object to file or update an existing password.
Parameters:
account (string): Account name.
Returns:
None.
"""
fetched_data = get_data()
new_password = generate_password()
#if there is data, change existing dictionary item or create a new one.
# If there is no data, create a new file and write new item to it.
if fetched_data is not None:
if account in fetched_data:
print_template(
f"The password for your '{account}' account has been changed. \nPassword copied to clipboard..."
)
else:
print_template(
f"A password for your '{account}' account has been created. \nPassword copied to clipboard..."
)
write_to_file(account, new_password, fetched_data)
else:
write_to_file(account, new_password)
print_template(
f"Password file created. \nA password for your '{account}' account has been created. \nPassword copied to clipboard..."
)
pyperclip.copy(new_password)
def calculate(self):
'''Gets all the input from the user and generates password
Gets all input from the user in the gui and calls the function
to generate password
'''
self.clipboard_message.set("")
if IMPORT_CORRECTLY is False:
self.message.set("Code not found")
elif self.site.get() == "":
self.message.set("Please enter name of site")
elif self.username.get() == "":
self.message.set("Please enter username")
else:
try:
# get all input from gui
password = generator.generate_password(
self.length.get(),
self.upper_case_status.get(),
self.lower_case_status.get(),
self.number_status.get(),
self.symbol_status.get())
self.message.set("Password: "******"Password copied to clipboard")
generator.create_file(
self.site.get(), self.username.get(), password)
except TclError:
self.message.set("Please enter valid length")
def test_should_verify_password_level_one(self):
try:
self.assertEqual(
password_generator.check_password_level(
password_generator.generate_password(5, 1)), 1)
print("Level 1-PASS")
except BaseException:
print("Level 1-FAIL")
def test_should_verify_password_level_two(self):
try:
self.assertEqual(
password_generator.check_password_level(
password_generator.generate_password(7, 2)), 2)
print("Level 2-PASS")
except BaseException:
print("Level 2-FAIL")
def test_should_verify_password_level_three(self):
try:
self.assertEqual(
password_generator.check_password_level(
password_generator.generate_password(9, 3)), 3)
print("Level 3-PASS")
except BaseException:
print("Level 3-FAIL")
def test_should_verify_password_level_four(self):
try:
self.assertEqual(
password_generator.check_password_level(
password_generator.generate_password(13, 4)), 4)
print("Level 4-PASS")
except BaseException:
print("Level 4-FAIL")
def generate_pass(self):
symbols_selected = bool(self.symbols_val.get())
letters_selected = bool(self.letters_val.get())
numbers_selected = bool(self.numbers_val.get())
if symbols_selected or letters_selected or numbers_selected:
self.generated_pwd_val.set(
generate_password(symbols=symbols_selected,
letters=letters_selected,
numbers=numbers_selected,
password_length=self.pwd_length_val.get()))
else:
self.pop_up_msg()
def fetch_user() -> user:
generate_user = requests.get('https://randomuser.me/api/')
if generate_user.status_code == 200:
data = generate_user.json()
random_fullname = data['results'][0]['name']['first'] + \
' ' + data['results'][0]['name']['last']
random_email = data['results'][0]['email']
random_password = password_generator.generate_password(random.randint(6, 12), random.randint(1, 4))
new_user = user(random_fullname, random_email, random_password)
return new_user
else:
print(generate_user.status_code + '-Error')
def index():
options = {
"debug": None,
"language": "en",
"spaces": "0",
"symbol": "1",
"uppercase": "1"
}
if request.method == "POST":
resp = make_response("")
for k in options:
# Ensure invalid POST variables are not left unhandled
try:
resp.set_cookie(f"fp_{k}",
request.form.get(k),
max_age=60 * 60 * 24 * 7)
except KeyError:
pass
resp.headers["location"] = "./"
return resp, 302
else:
# Prioritize GET values over cookies
for k in options:
try:
# Set default to ensure existing options are not overridden
# if HTML query strings or POST variables are not defined
if request.args.get(k, default=None) is not None:
options[k] = request.args.get(k, '')
elif request.cookies.get(f"fp_{k}", default=None) is not None:
options[k] = request.cookies.get(f"fp_{k}")
except KeyError:
pass
password = generate_password(language=options["language"],
spaces=options["spaces"],
symbol=options["symbol"],
uppercase=options["uppercase"])
return render_template(
"index.html",
debug=options["debug"],
debug_data=options,
language=options["language"],
release=RELEASE,
spaces=options["spaces"],
symbol=options["symbol"],
uppercase=options["uppercase"],
theme="sea-blue",
title="Password Generator",
password=password,
year=dt.now().year,
)
def generate_button_clicked(self):
# Get generate options from Form
password_length_str = self.password_length_entry.get()
symbols = self.symbol_entry.get()
try:
password_length = int(password_length_str)
except ValueError as err:
self.set_result("length must be number")
return
# Generate password
try:
password = generate_password(password_length, symbols)
self.set_result(password)
except ValueError as err:
self.set_result(str(err))
def forgot_password(email):
user = User.find_user_by_email(email)
if user is None:
raise MyException('could not find email', status_code=404)
password = generate_password()
try:
msg = Message(subject="Reset Password", sender=os.environ.get('MAIL_USERNAME'),
recipients=[email])
msg.html = "<body><h1>"f"New password is {password}</h1>""</body>"
mail.send(msg)
except Exception:
print('message:- this are test emails you can also use real emails in a sender and recipients')
finally:
user.password = password_hashing(password)
db.session.commit()
return {'password': password}
def view_account(self, index):
"""View a specific account's details and actions."""
account_name = self.get_account_name(index - 1)
account = self.credentials.accounts[account_name]
self.banners.show_account(account_name)
# show choices
print(" 1. Add login credentials")
print(" 2. Check login credentials")
print(" 3. Go back")
# ask for input
choice = input("Enter one of the choices to proceed: ")
# respond to input
if int(choice) == 1:
print("\n* Add Login Credentials: *\n")
username = input("Enter your username: "******"Do you want a generated password? (yes/no): ")
if password_choice.lower() == 'yes':
password = password_gen.generate_password()
elif password_choice.lower() == 'no':
password = input("Enter your password: "******"\n* Check Login Credentials: *\n")
print(f"username: {self.credentials.accounts[account_name].username}")
print(f"password: {self.credentials.accounts[account_name].password}")
self.view_account(index)
elif int(choice) == 3:
print("* Going Back *")
def generate_password_endpoint():
return {"password": password_generator.generate_password()}
from password_generator import generate_password
user_login = input('What is your login? \n')
user_password = input('What is your main password? \n')
user = User(user_login, user_password)
file_io.read(user)
with_upper_case = True
keep_looping = True
while keep_looping:
service = input('For what service do you want a password? \n')
service_login = input('What is your login for said service? \n')
service_digits = int(
input('How many digits do you want for your password? (8-16) \n'))
generated_password = generate_password(service_digits, with_upper_case)
user.add_service_account(service, service_login, generated_password)
print(user.service_accounts)
loop = input('Do you want to add another service? [Y/N]')
if loop.upper() == 'N':
keep_looping = False
file_io.__write(user)
def fill_password():
new_password = generate_password()
entry_password.delete(0, END)
entry_password.insert(0, new_password)
pyperclip.copy(new_password)
def random_password():
field_password.delete(0, END)
password = generate_password()
field_password.insert(0, password)
pyperclip.copy(password)
def test_generate_password_number(self):
password = generate_password()
self.assertTrue(hasNumber(password))
def test_generate_password_character(self):
password = generate_password()
self.assertTrue(hasSpecialCharacter(password))
def test_generate_password(self):
test_result = generate_password(24)
for char in test_result:
self.assertIn(char, string.ascii_letters + string.digits)
self.assertEqual(len(test_result), 24)
def do_change_secret(self, args):
"""
Change the secret on the device. WARNING Be sure that you know what
you are doing!
The argument for this command can be either
* A 12 word mnemonic following BIP39 or
* A 128 bit integer in decimal or hex notation
If no argument is given, a new secret is created from the systems
randomness source.
"""
args = args.split()
if len(args) > 1:
m = args
# We assume a 12 word mnemonic
if len(m) < 12:
print(
'Error: Expected a 12 word mnemonic, got %d words instead.'
% len(m))
return
wordlist = mnemonic.read_word_list()
for word in m:
if not word in wordlist:
print('Error: Word %s not in wordlist.' % word)
return
secret = mnemonic.to_entropy(m)
elif len(args) == 1:
# We assume a 128 bit integer
try:
secret = self.int_str_to_secret(args[0])
m = self.to_mnemonic(secret)
except ArgError:
pass
else:
print('No secret given, new secret will be created from system.\n')
secret = os.urandom(16)
m = self.to_mnemonic(secret)
# Let's be sure nothing went wrong with all the fancy conversion
# routines
assert m == mnemonic.to_mnemonic(secret)
assert secret == mnemonic.to_entropy(m)
# Start of the actual secret change
print('\n\nStarting the secret update.')
print(
'Do not leave this window until the secret update is complete.\n\n'
)
print(
'Sent new secret to the device. (The red lamp should be blinking.)'
)
print(
'Press the Button for five consecutive seconds to continue with' +
'the secret update.')
print('The device will type \'ready\' into the console if everything' +
'is ok.')
print('DO NOT PRESS ANY KEY ON YOUR KEYBOARD.')
try:
usb_comm.send_new_secret(secret)
except usb_comm.DeviceNotFound:
print('\nError: USB device not connected.')
return
inp = input()
if inp != 'ready':
print('Device did not sent \'ready\'. Aborting secret update.')
usb_comm.send_shutdown_message()
return
print('Got \'ready\' message.')
print('\nTesting the device with a random password request.')
print('DO NOT PRESS ANY KEY ON YOUR KEYBOARD.')
print('Press the Button on the device when the red led is on.')
# We'll add a little delay so that the user can remove their finger
# from the button
time.sleep(.5)
random_request = requests.reduce_message(os.urandom(50))
usb_comm.send_standard_pw_request(random_request, 40, hit_enter=True)
inp = input('Response from device: ')
pw = generate_password(secret, random_request)
print('Expected response: ', pw)
if not pw == inp:
print('Something went wrong, the device sent the wrong password.')
print('Device will keep old secret.')
print('Aborting secret update.')
usb_comm.send_shutdown_message()
return
print('Device sent the correct password.')
print('The new secret on the device is now set!\n\n')
# Repeat the mnemonic for clarity
print(
'***************************************************************')
print('The mnemonic for the new secret is:')
print(' '.join(m))
print(
'***************************************************************')
usb_comm.send_empty_message()
def test_generate_password_upper(self):
password = generate_password()
self.assertTrue(hasUppercase(password))
from password_generator import generate_password
if __name__ == '__main__':
length_of_password = input("Length of password (between 4 and 20 characters): ")
print(generate_password(int(length_of_password)))
parser.add_argument(
"-c",
"--copy",
help="Loads the wanted password and copies it to clipboard",
type=str)
parser.add_argument("-s",
"--show",
help="Loads the wanted password and prints it",
type=str)
args = parser.parse_args()
if args.new:
master_password = getpass.getpass(prompt="Master Password: "******"Master Password: ")
if args.copy:
encrypted_password = storer.load_password(args.copy)