Generating keys securely with the secrets and hashlib modules

1. Import Statements:

   • from secrets import choice: Imports the choice function from the secrets module. The choice function is used to make a random selection from a sequence.

   • from string import ascii_letters, ascii_uppercase, digits: Imports the sequences of ASCII letters (both lowercase and uppercase) and digits from the string module.

2. Character Set:

   • characters = ascii_letters + ascii_uppercase + digits: Creates a character set by concatenating ASCII letters (both lowercase and uppercase) and digits. This set is used to generate the random password.

3. Password Length:

   • length = 16: Specifies the length of the password to be generated. In this case, the password will have 16 characters.

4. Generating the Random Password:

   • random_password = ''.join(choice(characters) for character in range(length)):
     • Uses a generator expression to create a sequence of randomly chosen characters from the characters set.
     • The choice(characters) function is called length times to generate a sequence of random characters.
     • ''.join(...) concatenates these characters into a single string, forming the random password.

5. Print the Result:

   • print("The password generated is:", random_password): Prints the generated random password to the console.

1. Import Statements:

   • import secrets: Imports the secrets module, which provides functions for generating cryptographically secure random numbers and tokens.
   • import string: Imports the string module, which provides sequences of ASCII letters, digits, and punctuation.

2. Function Definition:

   • generateSecureURL(): This function generates a strong password and a secure URL token.

3. Character Set Initialization:

   • src = string.ascii_letters + string.digits + string.punctuation: Creates a character set (src) by concatenating ASCII letters (both lowercase and uppercase), digits, and punctuation.

4. Generate Strong Password:

   • The strong password is generated by:
     • Initializing the password variable with characters from different categories: lowercase letter, uppercase letter, digit, and punctuation.
     • Adding 16 additional characters randomly chosen from the src character set to the password.

5. Print the Strong Password:

   • print("Strong password:", password): Prints the generated strong password to the console.

6. Generate Secure URL Token:

   • secureURL = "https://www.domain.com/auth/reset=": Initializes the secureURL variable with a prefix for a secure URL.
   • secureURL += secrets.token_urlsafe(16): Appends a secure URL token of length 16 to the secureURL using the secrets.token_urlsafe() function.

7. Print the Secure URL Token:

   • print("Token secure URL:", secureURL): Prints the generated secure URL token to the console.

8. Main Execution:

   • if __name__ == "__main__":: Checks if the script is being run as the main program.
   • generateSecureURL(): Calls the generateSecureURL() function if the script is the main program.

1. hash_password(password) Function:

   • This function takes a plain-text password as input.
   • It generates a random salt using uuid.uuid4().hex.
   • It then concatenates the salt and password, hashes the result using SHA-256, and returns the hashed password with the salt as a string in the format: hashed_password:salt.

2. check_password(hashed_password, user_password) Function:

   • This function takes a hashed password (in the format hashed_password:salt) and a user-provided plain-text password.
   • It extracts the stored salt from the hashed password.
   • It hashes the user-provided password with the extracted salt using SHA-256.
   • It checks if the computed hash matches the stored hash, returning True if they match and False otherwise.

3. Usage:

   • The script prompts the user to enter a new password (new_pass).
   • It then hashes the entered password using hash_password and prints the hashed password.
   • The user is prompted to enter the same password again (old_pass) for verification.
   • The script uses check_password to compare the hashed version of the second input with the originally hashed password.

Compute hash digests for a given file using a variety of hashing algorithms

This Python script prompts the user to enter a file name, reads the content of the file, and then calculates the hash digest using various available hashing algorithms provided by the hashlib module. Here’s an explanation of the code:

1. User Input:

   file_name = input("Enter file name:")
   

   The user is prompted to enter the name of the file.

2. Read File Content:

   file = open(file_name, 'r')
   data = file.read().encode('utf-8')
   

   The specified file is opened in read mode ('r'), and its content is read. The content is then encoded as UTF-8 bytes.

3. Hash Calculation:

   print("-- %s --" % file_name)
   print(hashlib.algorithms_available)
   
   for algorithm in hashlib.algorithms_available:
       hash = hashlib.new(algorithm)
       hash.update(data)
       try:
           hexdigest = hash.hexdigest()
       except TypeError:
           hexdigest = hash.hexdigest(128)
       
       print("%s: %s" % (algorithm, hexdigest))
   

   • The script prints the name of the file and the available hashing algorithms.
   • It iterates over the available hashing algorithms.
   • For each algorithm, a new hash object is created (hashlib.new(algorithm)).
   • The content of the file is then fed into the hash object using the update() method.
   • The hex digest of the hash is calculated using hexdigest().
   • The result, including the algorithm name and hex digest, is printed to the console.