Como criar uma senha com hash SHA-512 para sombra?

Editar: Observe que esta resposta tem mais de 10 anos.

Aqui está um forro:

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

Python 3.3+ inclui mksaltem crypt , o que torna muito mais fácil (e mais seguro) de usar:

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

Se você não fornecer um argumento para crypt.mksalt(pode aceitar crypt.METHOD_CRYPT, ...MD5, SHA256e SHA512), ele usará o mais forte disponível.

O ID do hash (número após o primeiro $) está relacionado ao método utilizado:

• 1 -> MD5
• 2a -> Blowfish (não na glibc principal; adicionado em algumas distribuições Linux)
• 5 -> SHA-256 (desde glibc 2.7)
• 6 -> SHA-512 (desde glibc 2.7)

Eu recomendo que você procure o que são sais e tal e, de acordo com smallclammers, comente a diferença entre criptografia e hash.

Atualização 1: A string produzida é adequada para scripts shadow e kickstart.
Atualização 2: Aviso . Se você estiver usando um Mac, veja o comentário sobre como usar isso em python em um mac onde parece não funcionar conforme o esperado.

No macOS você não deve usar as versões acima, pois o Python usa a versão do sistema crypt()que não se comporta da mesma forma e usa criptografia DES insegura . Você pode usar este forro independente de plataforma (requer passlib – instalar com pip3 install passlib):

python3 -c 'import passlib.hash; print(passlib.hash.sha512_crypt.hash("test"))'

No Debian você pode usar mkpasswd para criar senhas com diferentes algoritmos de hash adequados para /etc/shadow. Está incluído no pacote whois (de acordo com o arquivo apt)

mkpasswd -m sha-512
mkpasswd -m md5

para obter uma lista de algoritmos de hash disponíveis, digite:

mkpasswd -m help 

HTH

Usandogrub-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)**

Aqui está um código C curto para gerar a senha SHA-512 em vários sistemas operacionais do tipo Unix.

Arquivo:passwd-sha512.c

#define _XOPEN_SOURCE
#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");
    return;
  }

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

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

compilar:

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

uso:

passwd-sha512 <password> <salt (16 chars max)>

Surpreendente que nenhuma resposta sugira o openssl passwdcomando simples com a -6opção. Talvez ainda não estivesse disponível em 2011?

Se você não se importa em fornecer a senha na linha de comando (arriscando-a permanecer no histórico de comandos), você pode fazer:

openssl passwd -6 YourPassword

Ele irá gerar o sal e produzir uma linha como esta:

$6$/57kpVAA/kuPUtzV$Ugxo0RTL2uXCvU7WH43c1qn0quMy2ve.qiBYJPG75tFgTN8gI5Jp/FYPXFOzIsASqVTqM42kjN2805VYLHKzm1

Com a stdinopção, ele também pode ler a senha do STDIN (ou de um arquivo), para que você não a deixe para trás no histórico:

openssl passwd -6 -stdin

Solução de uma linha Perl para gerar a senha com hash SHA-512:

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

Trabalhou no RHEL 6

Por que não executar a seguinte verificação e modificação nas máquinas Centos/RHEL para garantir que todo o hash de senha para /etc/shadow seja feito com sha512. Então você pode simplesmente definir seu passworkd normalmente com o comando passwd

#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
fi

Aqui está um one-liner que usa comandos shell para criar uma senha com hash SHA-512 com um sal aleatório:

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

Notas

1. Você pode precisar instalar o pacote "whois" (Debian, SuSE, etc.), que fornece "mkpasswd".
2. Veja crypt(3) para detalhes sobre o formato das linhas em "/etc/shadow".

Leia o comentário abaixo para saber mais sobre as implicações de segurança desta resposta

Para aqueles da mentalidade Ruby, aqui está uma frase:

'password'.crypt('$6$' + rand(36 ** 8).to_s(36))

Todos os exemplos usarão SHA-512, <password>como espaço reservado para senha e <salt>como espaço reservado para sal.

mkpasswd

Nota: mkpasswdo binário é instalado através do pacote somentewhois no Debian/Ubuntu . Em outras distribuições Linux como ArchLinux, Fedora, CentOS, openSUSE, etc. é fornecido pelo pacote, mas é um utilitário totalmente diferente que está disponível como no Debian / Ubuntu. de todas as outras distribuições Linux não inclui, mas a fonte (C lang) pode ser encontrada no repositório original https://github.com/rfc1036/whois .mkpasswdexpectexpect_mkpasswdwhoismkpasswd

# With a random password and random salt
mkpasswd -m sha-512
# With a random random salt
mkpasswd -m sha-512 '<password>'
# Choosing both password and salt
mkpasswd -m sha-512 '<password>' '<salt>'
# 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 '<password>'
# Choosing both password and salt
openssl passwd -6 --salt '<salt>' '<password>'
# Read password from stdin to avoid leaking it in shell command history
openssl passwd -6 -stdin
openssl passwd -6

Rubi

# 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 "<password>".crypt("$6$" + rand(36 ** 8).to_s(36))'
# Choosing both password and salt
ruby -e 'puts "<password>".crypt("$6$<salt>")'
# 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))'

Obs: para quem reclama que Random#randé um PRNG, pode usar o seguro SecureRandom#randmas não é muito importante é o rand é usado apenas para gerar o sal que fica publicamente disponível no hash no final.

ruby -e 'require "securerandom"; puts "<password>".crypt("$6$" + SecureRandom.rand(36 ** 8).to_s(36))'

Perl

# Choosing both password and salt
perl -le 'print crypt "<password>", "\$6\$<salt>\$"'

Pitão

Requer Python >= 3.3

# With a random random salt
python -c 'import crypt; print(crypt.crypt("<password>", crypt.mksalt(crypt.METHOD_SHA512)))'
# Choosing both password and salt
python -c 'import crypt; print(crypt.crypt("<password>", "$6$<salt>"))'
# 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