Search for:
  • Home/
  • Bash/
  • Creating Secure Passwords with Linux Shell Scripting

Creating Secure Passwords with Linux Shell Scripting

Hello, everyone! Today, let’s delve into an essential skill for any Linux enthusiast or system administrator: creating secure, random passwords using shell scripting. This skill is crucial for automating account setups, enhancing security, and just making life a bit easier. Here’s a step-by-step guide to creating a script that generates strong, random passwords.

Starting Simple: Generating a Random Number

First, let’s start with the basics. The simplest form of a random password can be a random number. In bash, you can generate a random number using the $RANDOM variable.



This script will output a random number each time you run it. However, this isn’t very secure, so let’s improve it.

Improving Security: Combining Random Numbers

To create a longer password, concatenate multiple $RANDOM values:



This approach provides a longer string of numbers, but we can do better in terms of complexity.

Using Date and Time: A More Complex Approach

A more complex password can be generated using the current date and time. This ensures that the password changes every second, making it more secure.


PASSWORD=$(date +%s) echo $PASSWORD

Here, %s outputs the number of seconds since the Unix Epoch, providing a unique value.

Adding Nanoseconds: For Extra Complexity

For even more complexity, add nanoseconds to the mix:


PASSWORD=$(date +%s%N) echo $PASSWORD

This script uses both the seconds and the nanoseconds, creating a very complex password.

Hash for Complexity: Using SHA256

For a highly secure password, you can hash the date and time using SHA256:


PASSWORD=$(date +%s%N | sha256sum | head -c32) echo $PASSWORD

This command generates a SHA256 hash of the current date and time, then uses head to truncate the hash to the first 32 characters, creating a strong password.

Final Touch: Adding Special Characters

Adding special characters further enhances security. Let’s generate a random special character and append it to our password:


SPECIAL_CHAR=$(echo '!@#$%^&*()_-+=' | fold -w1 | shuf | head -c1) PASSWORD="${PASSWORD}${SPECIAL_CHAR}" echo $PASSWORD

This command picks a random special character from the provided list and appends it to our password.

Putting It All Together: The Complete Script

Here’s the a script combining the above elements:


#!/bin/bash # Generate a password using a random number, date, time, and a special character PASSWORD="${RANDOM}${RANDOM}${RANDOM}$(date +%s%N | sha256sum | head -c32)" SPECIAL_CHAR=$(echo '!@#$%^&*()_-+=' | fold -w1 | shuf | head -c1) PASSWORD="${PASSWORD}${SPECIAL_CHAR}" echo "Your new secure password is: $PASSWORD"

Let’s next elevate our script with even more robust and unpredictable password generation techniques. I’ll introduce you to a more advanced method for creating highly secure passwords that include a mix of alphanumeric and special characters.

An Even Better Password Creation Method

We’ll start by creating a base password using a combination of the current time (in seconds and nanoseconds), random numbers, and a SHA256 hash. We’ll then append a special character to it:


# Base password generation using date, time, and random numbers SPECIAL_CHARS='£$%^&*()~#<>-_+=' SPECIAL=$(echo "$SPECIAL_CHARS" | fold -w1 | shuf | head -c1) PASSWORD=$(date +%s%N${RANDOM}${RANDOM}${RANDOM} | sha256sum | cut -d ' ' -f 1 | head -c48) echo "${PASSWORD}${SPECIAL}"

In this script, SPECIAL_CHARS holds a string of potential special characters. We use fold, shuf, and head to pick one random special character from this string. The PASSWORD is a combination of the current date and time, random numbers, and a SHA256 hash, truncated to 48 characters.

Adding a Random Number of Special Characters

Next, we enhance our password by adding a random number of special characters (between 1 and 5) to it:


# Decide on a random number of special characters to add NUM_SPECIAL_CHARS=$(( RANDOM % 5 + 1 )) # Generate a string of random special characters RANDOM_SPECIALS=$(echo "$SPECIAL_CHARS" | fold -w1 | shuf | head -c$NUM_SPECIAL_CHARS) # Combine the base password and the random special characters NEWPASSWORD="${PASSWORD}${RANDOM_SPECIALS}"

Here, NUM_SPECIAL_CHARS determines how many special characters to add. We then generate a string of random special characters of that length and append it to our base password.

Shuffling for Unpredictability

Finally, we shuffle this combined password to mix the special characters throughout, ensuring even more unpredictability:


# Shuffle the combined string to mix special characters within FINAL_PASSWORD=$(echo "$NEWPASSWORD" | fold -w1 | shuf | tr -d '\n') # Output the final password echo "$FINAL_PASSWORD"

The FINAL_PASSWORD is a shuffled version of NEWPASSWORD, ensuring that the special characters are not just appended at the end but distributed throughout the password.


This advanced script showcases the true power and flexibility of Linux shell scripting. By combining various commands and techniques, we’ve created a script that generates highly secure, complex, and unpredictable passwords. This level of scripting not only enhances security but also demonstrates how shell scripting can be an invaluable tool in your Linux toolkit.

Remember, in the realm of cybersecurity, the strength of your password can make all the difference. Happy scripting and stay secure!

Leave A Comment

All fields marked with an asterisk (*) are required