Question

Part 1: Is this Crazy Password Valid?

A good password (in this strange system) should have the following properties:

Rule 1: The password should be between 4 and 25 characters inclusive, starting with a letter.

Rule 2. The password should not be contained in a list (selected by the user) that contains passwords commonly used by many people thus making these passwords easy to guess. Comparisons with passwords from the list of common passwords should be case insensitive. For example, if the password entered by the user is P@sSw0rD and there is a common password p@ssw0rd in the list, Rule 2 is not satisfied.

Rule 3. The password should have at least one of the following characters @ $ and no %.

Rule 4: The password should have at least one upper and one lower case character, or it should contain at least one of 1, 2, 3 or 4. If it contains upper and lower case characters, we don’t care about numbers 1, 2, 3, 4. If it contains 1, 2, 3 or 4, we don’t care about upper or lower case characters.

Rule 5: Each upper case character (if there is any) must be immediately followed by at least one underscore symbol (_).

Rule 6: Each numerical digit, if there is any, must be less than 5. (So, pa$$35 is not valid because of 5.) Note that in Rule 4 you checked the existence of at least one number in the 1-4 range, now you want to check that all numbers are in this range.

Write a program that validates a password entered by the user against this set of rules. The program should first determine the number of available lists with common passwords (as described below), prompt the user to enter a correct number to select the list, and then ask for a password. If the password is a valid one (satisfying all the above rules), print a corresponding message to the user. If the password is not valid but satisfies Rule 1, suggest a valid password by taking the first 3 and the last 3 characters and appending 42 between them (note the password constructed this way may not be valid with respect to the above rules, but randomness is always good for security). Otherwise, report the password as not valid.

In order to check the password against Rule 2, you will first need to determine how many lists with common passwords are available to you. Use function get_number_of_password_lists() provided in hw4_util module. Make sure you have your code for this part of the assignment, the hw4_util.py file, and two data files, password_list_top_25.txt and password_list_top_100.txt, all residing in the same directory. If everything is set up correctly, the following code:

import hw4_util

lists_count = hw4_util.get_number_of_password_lists() print(lists_count)

should print 2, indicating that you have 2 lists (numbered 0 and 1) with common passwords available to you. You can obtain any of these lists by using get_password_list() function from the hw4_util module and specifying the list number, as in the following example (we slice the list to only show the first 5 items for brevity):

import hw4_util

passwords = hw4_util.get_password_list(0) print(passwords[0:5])

which outputs ['123456', 'Password', '12345678', 'qwerty', '12345'].

Note that when you submit your code on Submitty we will be using lists of common passwords which are different from the ones we provide to you, and we will be using more than two lists. Your code should not hardcode the number of lists available or the contents of the lists. Instead, use functions get_number_of_password_lists() and get_password_list() from hw4_util.

Hint: A very good way to solve this problem is to use booleans to store whether each rule is satisfied or not. Start slowly, write and test each part separately. Rules 1, 3, and 4 do not require looping at all. For Rule 2, you will need to loop through all items in the list of common passwords. For Rule 5, the simplest solution involves looping through the string once. The same is true for Rule 6. To construct the suggested password, you only need one line of code by using slicing. There are some really useful string functions you can use: str.islower(), str.isupper() and of course str.count() and str.find(). Try help(str) to learn more about them. Here is an example solution that involves using booleans to store the result and building on them:

is_long_enough = len(word) <= 25 and len(word) >= 4

is_lowercase = word.islower()

if is_long_enough and is_lowercase:

print ("It is long enough and lower case")

Example:

Select the list of common passwords by entering a number between 0 and 1 => 0

0

Enter a password => this_is_#lowercase

this_is_#lowercase

Rule 1 is satisfied

Rule 2 is satisfied

Rule 3 is not satisfied

Rule 4 is not satisfied

Rule 5 is satisfied

Rule 6 is satisfied

A suggested password is: thi42ase

Answer 1

#validator.py

import hw4_util
def ruleOne(passwd):
   if(len(passwd) <=25 and len(passwd)):
       return True
   else:
       return False
def ruleTwo(passwd):
   passwd = passwd.lower()
   for common in passwds:
       if(common == passwd):
           return False
   return True

def ruleThree(passwd):
   if((passwd.find('@') == -1 and passwd.find('$') == -1) or passwd.find('%')!=-1):
       return False
   else:
       return True
def ruleFour(passwd):
   upper = False
   lower = False
   numRange = False
   valid = True
   for char in passwd:
       if(char.isupper()):
           upper = True
       elif(char.islower()):
           lower = True
       elif(char.isnumeric()):
           if(char >='1' and char <= '4'):
               numRange = True
           else:
               numRange = False
               valid = False
               break
   if(valid == False):
       return False
   elif(upper and lower):
       return True
   elif(numRange == True):
       return True
   else:
       return False

def ruleFive(passwd):
   pre = ''
   for char in passwd:
       if(pre !=''):
           if(char != '_'):
               return False
           else:
               pre = ''
       if(char.isupper()):
           pre = char
   if(pre.isupper()):
       return False
   return True

def ruleSix(passwd):
   for char in passwd:
       if(char.isnumeric()):
           if(char < '1' or char >'4'):
               return False
   return True

total_lists = hw4_util.get_number_of_password_lists() - 1
pos = int(input("Select the number of common passwords by entering a number between 0 and "+str(total_lists)+" => "))
if(pos > total_lists):
   print("Invalid input given")
   exit()
passwds = hw4_util.get_password_list(pos)

choice = ''
while(choice !='q'):
   passwd = input("Enter a password => ")
   print(passwd)
   one = ruleOne(passwd)
   two = ruleTwo(passwd)
   three = ruleThree(passwd)
   four = ruleFour(passwd)
   five = ruleFive(passwd)
   six = ruleSix(passwd)
  
   valid = one and two and three and four and six
   if(one):
       print("Rule 1 is satisifed")
   else:
       print("Rule 1 is not satisifed")
  
   if(two):
       print("Rule 2 is satisifed")
   else:
       print("Rule 2 is not satisifed")
  
   if(three):
       print("Rule 3 is satisifed")
   else:
       print("Rule 3 is not satisifed")
  
   if(four):
       print("Rule 4 is satisifed")
   else:
       print("Rule 4 is not satisifed")
  
   if(five):
       print("Rule 5 is satisifed")
   else:
       print("Rule 5 is not satisifed")
  
   if(six):
       print("Rule 6 is satisifed")
   else:
       print("Rule 6 is not satisifed")
  
   if(valid):
       print("password is valid")
   else:
       print("A suggested password is : "+passwd[:3] + "42" + passwd[-3:])
  
   choice = input("Enter q to quit, Any key to continue")

#hw4_util.py
pass_lists = ["top25.txt","top100.txt"]
def get_number_of_password_lists():
   return len(pass_lists)
def get_password_list(index):
   f = open(pass_lists[index],"r")
   line = f.readline()
   passwds = []
   while(line):
       line = line.strip().lower()
       passwds.append(line)
       line = f.readline()
   f.close()
   return passwds