How to create SHA512 password hashes on command line
In Linux I can create a SHA1 password hash using sha1pass mypassword . Is there a similar command line tool which lets me create sha512 hashes? Same question for Bcrypt and PBKDF2 .
There’s a sha512sum command that’s part of coreutils, and similarly openssl sha512 — but neither does the extra stuff that sha1pass does.
13 Answers 13
On any of the Red Hat distros such as Fedora, CentOS, or RHEL the command mkpasswd doesn’t include the same set of switches as the version typically included with Debian/Ubuntu.
NOTE: The command mkpasswd is actually part of the expect package, and should probably be avoided. You can find out what package it belongs to with either of these commands.
$ yum whatprovides "*/mkpasswd" -or- $ repoquery -q --file */mkpasswd Example
$ repoquery -q --file */mkpasswd expect-0:5.43.0-8.el5.x86_64 expect-0:5.43.0-8.el5.i386 Both of these methods are superior to using rpm since the packages do not have to be installed to locate */mkpasswd .
Workarounds
To work around this you can use the following Python or Perl one-liners to generate SHA-512 passwords. Take note that these are salted:
Python (>= 3.3)
$ python -c 'import crypt,getpass; print(crypt.crypt(getpass.getpass(), crypt.mksalt(crypt.METHOD_SHA512)))' $ python -c 'import crypt; print(crypt.crypt("somesecret", crypt.mksalt(crypt.METHOD_SHA512)))' Python (2.x or 3.x)
$ python -c "import crypt, getpass, pwd; \ print(crypt.crypt('password', '\$6\$saltsalt\$'))" $6$saltsalt$qFmFH.bQmmtXzyBY0s9v7Oicd2z4XSIecDzlB5KiA2/jctKu9YterLp8wwnSq.qc.eoxqOmSuNp2xS0ktL3nh/ Note: $6$ designates sha512. Support for this method of specifying the algorithm is dependent on support in OS level crypt(3) library function (usually in libcrypt). It is not dependent on python version.
Perl
$ perl -e 'print crypt("password","\$6\$saltsalt\$") . "\n"' $6$saltsalt$qFmFH.bQmmtXzyBY0s9v7Oicd2z4XSIecDzlB5KiA2/jctKu9YterLp8wwnSq.qc.eoxqOmSuNp2xS0ktL3nh/ In these examples the password is the string «password» and the salt is «saltsalt». Both examples are using $6$ which denotes that you want crypt to use SHA-512.
For the python one-liner, you can use crypt.mksalt(crypt.METHOD_SHA512) to generate the salt instead of using a fixed one.
Before typing a clear-text password at the command line make sure you have «ignorespace» set in HISTCONTROL (i.e., do this first on CentOS/RHEL: echo ‘export HISTCONTROL=»ignoredups:ignorespace»‘ > /etc/profile.d/histcontrol.sh && source /etc/profile.d/histcontrol.sh). Otherwise, it’ll get saved in your ~/.bash_history.
the perl (and presumably the python) use the system function «crypt». So they aren’t portable, they require a crypt function that understands the requested hash type. The OSX crypt doesn’t — it just gives me back an old-style DES-encrypted string.
Yes, you’re looking for mkpasswd , which (at least on Debian) is part of the whois package. Don’t ask why.
anthony@Zia:~$ mkpasswd -m help Available methods: des standard 56 bit DES-based crypt(3) md5 MD5 sha-256 SHA-256 sha-512 SHA-512 Unfortunately, my version at least doesn’t do bcrypt. If your C library does, it should (and the manpage gives a -R option to set the strength). -R also works on sha-512, but I’m not sure if its PBKDF-2 or not.
If you need to generate bcrypt passwords, you can do it fairly simply with the Crypt::Eksblowfish::Bcrypt Perl module.
$ openssl passwd --help Usage: passwd [options] Valid options are: . -6 SHA512-based password algorithm For consistent output you can specify the salt:
Output is something similar to:
$6$YOUR_SALT$q/oDR4twC1ik4RoxTJJtX.3MjenHVapkMaBbq2NcRHGQjqhIWRNcEVitYZhyIx98D7lF7qs0vLTq17X0nEr8I. with: 6 between «$» indicating the algorithm («-6» above), followed by YOUR_SALT and «$», finishing with the SHA512 sum.
You can use the doveadm utility, which is included in the dovecot package.
Result example:
$6$0JvQ1LLFESzA16.I$JVdKAIq0igudTq06BMqzT9rL1gRawMPwLr9U3/kBMKUqZdONfa0wubC89C35LKl3aE16CRH57BfGb4ygPLggL1 Just cut and you’ll get your SHA512 hashed string.
Doesn’t work for me as a regular user: doveadm(jotik): Fatal: Error reading configuration: stat(/etc/dovecot/dovecot.conf) failed: Permission denied (euid=1000(jotik) egid=100(users) missing +x perm: /etc/dovecot, we’re not in group 97(dovecot), dir owned by 0:97 mode=0750)
«Permission denied» is not related to the original question. The default dovecot setting is not to let end-user read any files in the /etc/dovecot subdirectory, particularily users (and password ) file. Become root, and then you can see those files.
The point is that doveadm cannot be run by a regular user, so this command is not a solution to the original question for someone who isn’t (or cannot become) root. That someone typically isn’t interested in reading any files in the /etc/dovecot directory, and shouldn’t need to just in order to generate a password hash.
then enter the word you want hashed.
I don’t believe grub is on c7 so you can use: python -c ‘import crypt,getpass; print(crypt.crypt(getpass.getpass(),crypt.mksalt(crypt.METHOD_SHA512)))’
To expand on @slm’s workarounds above, if you’re worried about someone getting a hold of your bash history and seeing the plain text password, you can insert raw_input() in the python statement where the salt and password fields go so it prompts you for them. The text isn’t masked while you’re typing, but it won’t show up in your bash history. You could also start the command with a leading space, but I always forget to do that.
python -c "import crypt, getpass, pwd; print crypt.crypt(raw_input(), '\$6\$' + raw_input() + '\$')" You can also configure bash to not record commands prefixed with a space adding HISTCONTROL=ignorespace to your .bashrc file. When you run a command you want to exclude from your history simply type a space then the actual command.
sha512 htpasswd
Command which asks for user and password and generates a regular htpasswd-file:
python -c 'import crypt,getpass; print(getpass.getpass("Name: ")+":"+crypt.crypt(getpass.getpass(),crypt.mksalt(crypt.METHOD_SHA512)))' >> htpasswd Works with all python versions > 2.5.
I did the same thing with NodeJs before:
echo "console.log(require('crypto').createHmac('sha512', 'nonbase64key').update('password').digest('hex'))" | node it’s equivalent in python is:
python3 -c 'import hashlib;import base64;import hmac;print(hmac.new(b"nonbase64key", "password".encode(), hashlib.sha512).hexdigest())' And the equivalent shell command is:
echo -n "password" | openssl sha512 -hmac "nonbase64key" All examples will be using SHA-512, as password placeholder and as salt placeholder.
mkpasswd
Note: mkpasswd binary is installed via the package whois on Debian / Ubuntu only. On other Linux distribution such as ArchLinux, Fedora, CentOS, openSUSE, etc. mkpasswd is provided by the expect package but is an totally different utility which is available as expect_mkpasswd on Debian / Ubuntu. whois of all other Linux distro doesn’t include mkpasswd but the source (C lang) can be found on the original repository https://github.com/rfc1036/whois.
# With a random password and random salt mkpasswd -m sha-512 # With a random random salt mkpasswd -m sha-512 '' # Choosing both password and salt mkpasswd -m sha-512 '' '' # Read password from stdin to avoid leaking it in shell command history mkpasswd -m sha-512 --stdin OpenSSL
# With a random random salt openssl passwd -6 '' # Choosing both password and salt openssl passwd -6 --salt '' '' # Read password from stdin to avoid leaking it in shell command history openssl passwd -6 -stdin openssl passwd -6 Ruby
# With a random password and random salt ruby -e 'require "securerandom"; puts SecureRandom.alphanumeric(20).crypt("$6$" + rand(36 ** 8).to_s(36))' # With a random random salt ruby -e 'puts "".crypt("$6$" + rand(36 ** 8).to_s(36))' # Choosing both password and salt ruby -e 'puts "".crypt("$6$")' # Read password from stdin to avoid leaking it in shell command history ruby -e 'require "io/console"; puts IO::console.getpass.crypt("$6$" + rand(36 ** 8).to_s(36))' Note: for those who complains that Random#rand is a PRNG, you can use the secure SecureRandom#rand but it’s not very important is rand is used only to generate the salt which is publicly available in the hash at the end.
ruby -e 'require "securerandom"; puts "".crypt("$6$" + SecureRandom.rand(36 ** 8).to_s(36))' Perl
# Choosing both password and salt perl -le 'print crypt "", "\$6\$\$"' Python
# With a random random salt python -c 'import crypt; print(crypt.crypt("", crypt.mksalt(crypt.METHOD_SHA512)))' # Choosing both password and salt python -c 'import crypt; print(crypt.crypt("", "$6$"))' # Read password from stdin to avoid leaking it in shell command history python -c 'import crypt,getpass; print(crypt.crypt(getpass.getpass(), crypt.mksalt(crypt.METHOD_SHA512))) grub-crypt
Note: The grub package doesn’t include grub-crypt in many distros.
# With a random random salt # Read password from stdin to avoid leaking it in shell command history grub-crypt --sha-512 Tech Monger
If you ever wondered where and how user passwords are stored in linux file system then this post will answer most of your questions. Below we will discuss password hashing in ubuntu but many other linux distributions follow this pattern. Below read assumes that you have basic familiarity with hash function like md5 or sha-256.
Hashed not Encrypted
In Linux Passwords are not stored by encrypting with some secret key rather hash of the password is stored. So you need not to worry about key getting compromised nor the file which actually stores password (Hashed Password) getting stolen.
To make storage more secure password are hashed with salt. Salt is just random string which is generated when you create password. This helps prevent rainbow table attacks.
Password File Location and Content
Ubuntu stores password content in file /etc/shadow . Only root user can write inside this file. Along with hashed password this file also stores content like username, password change date, expiry date etc. in colon (:) separated format. We will focus on the second field i.e salt with hashed password.
$ sudo cat /etc/shadow/ techmonger:$6$ABCD1234$JnCx/.NCi4315V0AONxuVpUIRvPivoQjLzY0M28iYkOJU/FwVhXE4Me2f72fldvGEOpnTAB7IuVrsVfwpT/XT/:38478:0:99999:5. This line stores salt along with password hash. Note that each string between $ sign represent following things.
$ 6 $ ABCD1234 $ JnCx/.NCi4315V0AONxuVpUIRvPivoQjLzY0M28iYkOJU/FwVhXE4Me2f72fldvGEOpnTAB7IuVrsVfwpT/XT/
| Value | Explanation |
|---|---|
| $6$ | Value between starting two $ sign represents algorithm used for hashing. Here number 6 suggests sha-512 been used. |
| $ABCD1234$ | Value between second and third $ sign represents string salt which is used for hashing.. |
| $JnCx/.NCi4315V0AON xuVpUIRvPivoQjLzY0M 28iYkOJU/FwVhXE4Me 2f72fldvGEOpnTAB7IuV rsVfwpT/XT/ | Value after the third $ sign represents actual hashed password. |
Regenerating Hashed Password in Python
Stored password hash is generated using crypt3 . You can use python crypt implementation to regenerate password. Note that the password used for the user techmonger is hunter2 .
>>> import crypt >>> password="hunter2" >>> hashing_scheme_with_salt="$6$ABCD1234$" >>> crypt.crypt(password, hashing_scheme_with_salt) '$6$ABCD1234$JnCx/.NCi4315V0AONxuVpUIRvPivoQjLzY0M28iYkOJU/FwVhXE4Me2f72fldvGEOpnTAB7IuVrsVfwpT/XT/' In above example you can see that hash value generated by hashing password hunter2 with salt ABCD1234 using sha-512 is same as that present in the file /etc/shadow .
Conclusion
Above we have seen how password is stored in Linux like system and how hashed password is generated with the help of python code. Storing password this way is very secure and finding actual password from the stored hash is impossible*.