The previous SF questions I've seen have lead to answers that produce MD5 hashed password.

Does anyone have a suggestion on to produce an SHA-512 hashed password? I'd prefer a one liner instead of a script but, if a script is the only solution, that's fine as well.


Replacing previous py2 versions with this one:

python3 -c "import crypt;print(crypt.crypt(input('clear-text pw: '), crypt.mksalt(crypt.METHOD_SHA512)))"
  • 5
    SHA and MD5 are not encryption. They're hashing algorithms. The crucial difference being that the hashed data is not recoverable. What do you need to do? Nov 11 '11 at 11:28
  • Thank you. Modified the question. man 5 shadow refers to it as "encrypted password" so I went along with that term. Nov 11 '11 at 12:22
  • 3
    Apologies if that was a bit snarky. Are you trying to manually generate shadow-compatible password hashes? If so, take a look at your /etc/shadow contents. You'll see $x$salt$hash. x denotes the algorithm used by crypt, with 6 being typical on modern linuxes, which is sha512 (see man 3 crypt). Either of the below answers will produce the same hash, so long as you give it the same salt. Nov 11 '11 at 13:20
  • 2
    Oh no, not snarky at all. You clarified something I was confused about so I am very thankful sir! Nov 11 '11 at 15:26
  • 2
    Thank you! The passlib-based one is the only one I've been able to make work on OS X. Sep 1 '15 at 15:49

18 Answers 18


Here's a one liner:

python -c 'import crypt; print crypt.crypt("test", "$6$random_salt")'

Python 3.3+ includes mksalt in crypt, which makes it much easier (and more secure) to use:

python3 -c 'import crypt; print(crypt.crypt("test", crypt.mksalt(crypt.METHOD_SHA512)))'

If you don't provide an argument to crypt.mksalt (it could accept crypt.METHOD_CRYPT, ...MD5, SHA256, and SHA512), it will use the strongest available.

The ID of the hash (number after the first $) is related to the method used:

  • 1 -> MD5
  • 2a -> Blowfish (not in mainline glibc; added in some Linux distributions)
  • 5 -> SHA-256 (since glibc 2.7)
  • 6 -> SHA-512 (since glibc 2.7)

I'd recommend you look up what salts are and such and as per smallclamgers comment the difference between encryption and hashing.

Update 1: The string produced is suitable for shadow and kickstart scripts.
Update 2: Warning. If you are using a Mac, see the comment about using this in python on a mac where it doesn't seem to work as expected.

On macOS you should not use the versions above, because Python uses the system's version of crypt() which does not behave the same and uses insecure DES encryption. You can use this platform independent one liner (requires passlib – install with pip3 install passlib):

python3 -c 'import passlib.hash; print(passlib.hash.sha512_crypt.hash("test"))'
  • 6
    Replace random_salt with an actual random salt. Jul 31 '14 at 13:44
  • 6
    I can't get this to work in Yosemite. This is what it spits out: $6asQOJRqB1i2 - that doesn't seem nearly long enough to be correct! Jul 12 '15 at 11:12
  • 5
    Let the crypt module make the salt for you: python -c 'import crypt; print crypt.crypt("test", crypt.mksalt(crypt.METHOD_SHA512))'
    – rrauenza
    Sep 14 '15 at 17:32
  • 2
    glibc by default only uses 5000 rounds which is fairly weak these days. You can specify the number of rounds by adding "$rounds=###", for instance: crypt.crypt("test", "$6$rounds=200000$random_salt"). 200000 takes around 100ms on my current laptop.
    – srparish
    Sep 14 '16 at 0:20
  • 2
    This should not be used, at least on a Mac. On a Mac (10.13.5) this returns the same incorrect result each time. Aug 1 '18 at 12:56

On Debian you can use mkpasswd to create passwords with different hashing algorithms suitable for /etc/shadow. It is included in the package whois (according to apt-file)

mkpasswd -m sha-512
mkpasswd -m md5

to get a list of available hashing algoritms type:

mkpasswd -m help 


  • 3
    What package provides it? There's a mkpasswd program (part of expect) under Fedora too, but it's useless for this purpose. Mar 2 '13 at 2:31
  • As he said, the version of mkpasswd he's talking about is for Debian/Ubuntu. The mkpasswd on Fedora (at least up to 14) is missing the -m switch.
    – slm
    May 19 '13 at 3:47
  • 4
    Curiously, it's the whois package, legacy from Debian. See dpkg -S /usr/bin/mkpasswd I couldn't believe it myself :D
    – Rbjz
    Jun 18 '14 at 21:23
  • 1
    To check a password, if the first digit is 6, use the part between the second and third dollar as salt. For example for root:$6$AbCdE$xyz:... you should use: mkpasswd -m sha-512 -S AbCdE. With the correct password, you should get the same hash.
    – Luc
    Dec 9 '16 at 13:18

Best Answer: grub-crypt

Usage: grub-crypt [OPTION]...
Encrypt a password.

-h, --helpPrint this message and exit
-v, --version           Print the version information and exit
--md5                   Use MD5 to encrypt the password
--sha-256               Use SHA-256 to encrypt the password
**--sha-512             Use SHA-512 to encrypt the password (default)**
  • 1
    Simple solution..worked for me on CentOS 6.
    – Banjer
    May 1 '13 at 12:15
  • 5
    On systems that have the grub-crypt command, this really is the most foolproof & convenient way to do it. No sense playing around with salts manually when you could screw it up. The problem is that more and more modern systems have GRUB2 and will thus not include this command.
    – rsaw
    Jul 3 '15 at 18:22

Here's a short C code to generate the SHA-512 password on various Unix type OSes.

File: passwd-sha512.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
  if ( argc < 3 || (int) strlen(argv[2]) > 16 ) {
    printf("usage: %s password salt\n", argv[0]);
    printf("--salt must not larger than 16 characters\n");

  char salt[21];
  sprintf(salt, "$6$%s$", argv[2]);

  printf("%s\n", crypt((char*) argv[1], (char*) salt));

to compile:

/usr/bin/gcc -lcrypt -o passwd-sha512 passwd-sha512.c


passwd-sha512 <password> <salt (16 chars max)>
  • This question is 3 years old...
    – Grumpy
    Feb 13 '14 at 10:47
  • This comment is not that old. Cute app you got there, that's only c answer there 1up even while it looks like man page example :) Sep 29 '16 at 21:20

Surprising that no answer suggests the simple openssl passwd command with the -6 option. Maybe it wasn't available yet in 2011?

If you don't care providing the password on the command-line (risking it staying in the command history), then you can do:

openssl passwd -6 YourPassword

It will generate the salt, and output a line like this:


With the stdin option, it can also read the password from STDIN (or a file), so you don't leave it behind in the history:

openssl passwd -6 -stdin
  • 2
    Yes, -6 (sha512crypt) and -5 (sha256crypt) were added by 1.1.1 in 2018-09. May 21 '20 at 2:00
  • Came here to bump this. Don't hurt your pinkies over this. ;-) Oct 5 at 6:28

Perl one-liner solution to generate SHA-512 hashed password:

perl -le 'print crypt "desiredPassword", "\$6\$customSalt\$"'

Worked on RHEL 6


Why not perform the following check and modification to Centos/RHEL machines to ensure that all password hashing for /etc/shadow is done with sha512. Then you can just set your passworkd normally with the passwd command

#Set stronger password hasing
/usr/sbin/authconfig --test | grep sha512 > /dev/null
if [ $? -ne 0 ]; then
echo "Configuring sha512 password hashing"
sudo /usr/sbin/authconfig --enableshadow --passalgo=sha512 --updateall

Here is a one-liner that uses shell commands to create a SHA-512 hashed password with a random salt:

[root@host] mkpasswd -m sha-512 MyPAsSwOrD $(openssl rand -base64 16 | tr -d '+=' | head -c 16)


  1. You may need to install the "whois" package (Debian, SuSE, etc.), which provides "mkpasswd".
  2. See crypt(3) for details on the format of lines in "/etc/shadow".
  • Unfortunately the whois package from Fedora 18 doesn't provide any mkpasswd. Mar 2 '13 at 2:38
  • 1
    In Arch Linux: /usr/bin/mkpasswd is owned by expect 5.45-3
    – Nowaker
    Nov 9 '13 at 21:18
  • Same on Fedora 20 and it does something else. Apr 17 '14 at 19:23
  • 2
    Unfortunately the suggested command has two problems: 1) The supplied password is now stored in your shell's history, and is visible to anyone with the 'history' command or similar. 2) You don't need to supply the random salt on the command line - and I think you should let mkpasswd do it for you instead of using funky openssl tricks. (Note that this is true at least on Ubuntu Quantal. You can test it by running 'mkpasswd -m sha-512 foo' multiple times. You will see the salt changes. The salt is the value between the 2nd and 3rd $ characters.) Jun 3 '14 at 8:40

Read the comment below to learn about security implications of this answer

For those of the Ruby mindset here is a one-liner:

'password'.crypt('$6$' + rand(36 ** 8).to_s(36))
  • 1
    This is incorrect: Ruby's rand function is not secure - it uses a PRNG, so this will generate results that can be reverse-engineered based on a guess of the time/state of the moment you ran this. Aug 1 '18 at 12:53

This script worked for me on Ubuntu 12.04 LTS: https://gist.github.com/JensRantil/ac691a4854a4f6cb4bd9

read -p "Enter username: " username
read -s -p "Enter password: " mypassword
echo -n $username:$mypassword | chpasswd -S -c SHA512

It has the following features which some of the other alternatives lack:

  • It generates its salt securely. Nobody should rely on doing this manually. Ever.
  • it doesn't store anything in shell history.
  • for clarity, it prints which user's password it generated which can be nice when generating many users' passwords.
  • 2
    Note this will only work if you have chpasswd on your system. Dec 17 '15 at 19:01
  • FYI: chpasswd doesn't support -S in shadow-utils-
    – Saustrup
    Jul 10 '18 at 11:32

HASH algos are for producing MESSAGE digests, they are never suitable for passwords, which should use some kind of HKDF ( http://tools.ietf.org/rfc/rfc5869.txt ) - see PBKDF2 or BCrypt

  • Good point, but man crypt tells me PBKDF2 is not supported.
    – Huygens
    Sep 15 '15 at 11:15
#!/usr/bin/env python

import getpass

from passlib.hash import sha512_crypt

if __name__ == "__main__":
    passwd = getpass.getpass('Password to hash: ')
    hash = sha512_crypt.encrypt(passwd)

    print hash

You can clone it from my github repo if you want: https://github.com/antoncohen/mksha


Its not a one liner, but it might help someone:

import crypt, getpass, pwd, string, sys, random
randomsalt = ""
password = getpass.getpass()
choices = string.ascii_uppercase + string.digits + string.ascii_lowercase
for _ in range(0,8):
    randomsalt += random.choice(choices)
print crypt.crypt(password, '$6$%s$' % randomsalt)
  • random is not cryptographically secure, os.urandom should be used. 8 characters from 56 character long dictionary is way too little too. Concatentating a sting over and over in python is bad form too (it has O(n^2) complexity) Nov 27 '17 at 16:14
$ htpasswd -c /tmp/my_hash user1
New password: 
Re-type new password: 
Adding password for user user1
$ cat /tmp/my_hash

Obviously, you just grab the 2nd field, and can delete the file once you're added it to shadow or for use with sudo (still most likely shadow).


Take a look at the man page for crypt (3) and I think that you will find that the crypt tool has been updated to use glibc and sha256 ($5) and sha512 ($6) , multiple rounds, much larger salt, and so on.

Clearly SHA512 is relevant to how /etc/shadow works.

That said, this web page was very helpful - in particular the MKPASSWD , as this solved MY problem.

Given a potentially "lost" password, I can use MKPASSWD and the salt, to generate the SHA512 hash, and confirm/deny a list of candidate passwords.

I would use John the ripper - but at least on my hardware (Raspberry Pi) and my budget (nothing) - John can't do it (it does not seem to support the advanced crypt/glibc stuff in the raspbian free version.

Mind you, since I have enough permission to read/write /etc/shadow, I COULD just overwrite the hash, and get on with life... this is an academic exercise.

NOTES Glibc notes The glibc2 version of this function supports additional encryp‐ tion algorithms.

   If salt is a  character  string  starting  with  the  characters
   "$id$" followed by a string terminated by "$":


   then instead of using the DES machine, id identifies the encryp‐
   tion method used and this then determines how the  rest  of  the
   password  string is interpreted.  The following values of id are

          ID  | Method
          1   | MD5
          2a  | Blowfish (not in mainline glibc; added in some
              | Linux distributions)
          5   | SHA-256 (since glibc 2.7)
          6   | SHA-512 (since glibc 2.7)

   So  $5$salt$encrypted  is  an  SHA-256  encoded   password   and
   $6$salt$encrypted is an SHA-512 encoded one.

If you need an alternative to one-liners written in perl/python, mkpasswd is a good match. While it is included in the Debian whois package, it is missing on CentOS/RHEL systems. I've modified the Debian version of mkpasswd and included a stronger salt generation mechanism based on OpenSSL. The resulting binary fully preserves all Debian's version command line parameters. The code is avaiable on github and should compile on any Linux flavor: mkpasswd


After the Customer changes the password, you can copy the encrypted password from /etc/shadow to the kickstart file. How to do it:

export CRYPTED_PASSWORD=$(grep root /etc/shadow | cut –d ”:” –f 2)
echo "s;rootpw -–iscrypted .*;rootpw –-iscrypted $CRYPTED_PASSWORD;" > sed_script
sed –i –f sed_script template.ks

I'm not sure how SHA-512 is related to /etc/shadow. These passwords are crypted.

But if you want a password hashed with SHA-512 you can do this by echo -n the_password | sha512sum. You can't use the output for /etc/shadow.

  • 2
    echo -n the_password so you're not hashing the newline. </pedant> Nov 11 '11 at 13:14
  • Passwords in shadow aren't crypt()ed any more since years. Modern systems use at least md5. Oct 3 '12 at 20:40
  • 6
    Actually passwords in shadow are still crypt()ed but the function has been updated to support several different algorithms. Regardless, the method described in this answer does not produce suitable hash for /etc/shadow. The algorithm is more complex than a single SHA-512 hash round.
    – snap
    Jan 5 '13 at 0:12

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.