Como gerar uma string aleatória?

Question

Eu gostaria de gerar uma string aleatória (por exemplo, senhas, nomes de usuário, etc.). Deve ser possível especificar o comprimento necessário (por exemplo, 13 caracteres).

Quais ferramentas posso usar?

(Por questões de segurança e privacidade, é preferível que as strings sejam geradas off-line, ao contrário de online em um site.)

    

Answer 1

Minha maneira favorita de fazer isso é usar /dev/urandom junto com tr para excluir caracteres indesejados. Por exemplo, para obter apenas dígitos e letras:

head /dev/urandom | tr -dc A-Za-z0-9 | head -c 13 ; echo ''

Como alternativa, para incluir mais caracteres do < a href="https://www.owasp.org/index.php/Password_special_characters"> lista de caracteres especiais da senha OWASP :

</dev/urandom tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_'{|}~' | head -c 13  ; echo

Se você tiver alguns problemas com tr reclamando sobre a entrada, tente adicionar LC_ALL=C assim:

LC_ALL=C tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_'{|}~' </dev/urandom | head -c 13 ; echo

    

Answer 2

Para gerar uma senha aleatória, você pode usar pwgen :

pwgen generates random, meaningless but pronounceable passwords. These passwords contain either only lowercase letters, or upper and lower case mixed, or digits thrown in. Uppercase letters and digits are placed in a way that eases remembering their position when memorizing only the word.

Gere 7 senhas de tamanho 13:

geek@liv-inspiron:~$ pwgen 13 7
Eu7Teadiphaec giepahl3Oyaiy iecoo9Aetaib4 phaiChae6Eivi athoo3igee8Co
Iphu4ufeDeelo aesoYi2lie9he 

Como mencionado nos comentários, você pode evitar reduzir a entropia usando o argumento -s (ou seja, gerar senhas mais seguras, completamente aleatórias, mas difíceis de lembrar):

geek@liv-inspiron:~$ pwgen -s 13 7
eAfycrPlM4cYv 4MRXmZmyIVNBp D8y71iqjG7Zq7 FQRHcserl4R8O yRCUtPtV3dsqV
0vJpp2h0OrgF1 QTp7MKtJyTrjz 

Para gerar nomes de usuário aleatórios, você pode usar gpw :

This package generates pronounceable passwords. It uses the statistics of three-letter combinations (trigraphs) taken from whatever dictionaries you feed it.

Gere 7 senhas (nomes de usuário) de tamanho 13:

geek@liv-inspiron:~$ gpw 7 13
sreepoidahsas
risadiestinge
ntodynesssine
deodstestress
natinglumperm
riasigentspir
enderiferback

    

Answer 3

Estou usando o comando openssl , o canivete suíço da criptografia.

openssl rand -base64 12

ou

openssl rand -hex 12

    

Answer 4

Aqui está como, eu faço isso. Ele gera uma string aleatória de 10 caracteres. Você pode otimizá-lo substituindo a "dobra" por outras ferramentas de processamento de string.

cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 10 | head -n 1

    

Answer 5

Para gerar a senha com a maior entropia possível com as ferramentas padrão do Linux que são incorporadas em todas as distribuições que eu uso:

< /dev/urandom tr -cd "[:print:]" | head -c 32; echo

Isso produz todos os caracteres imprimíveis ASCII - de 32 (espaço) a 126 (til, ~ ). O comprimento da senha pode ser controlado com o sinalizador head -c . Há também outros conjuntos de caracteres possíveis em tr (para não incluir o espaço, apenas os caracteres 33-126, use [:graph:] ).

    

Answer 6

Dependendo do nível de aleatoriedade desejado, você pode simplesmente usar a variável zsh do bash (também ksh e $RANDOM , possivelmente outros):

$ echo $RANDOM | tr '[0-9]' '[a-zA-Z]'
bfeci
$ echo $RANDOM | tr '[0-9]' '[a-zA-Z]'
cijjj

Os métodos que leem diretamente de /dev/urandom são muito mais simples, mas para fins de conclusão, você também pode usar $RANDOM :

echo $(for((i=1;i<=13;i++)); do printf '%s' "${RANDOM:0:1}"; done) | tr '[0-9]' '[a-zA-Z]'

    

Answer 7

@Brandin explicou em um comentário para outra resposta como obter no máximo 100 bytes de /dev/urandom usando head -c 100 . Outra maneira de fazer isso é com dd :

tr -dc A-Za-z0-9 < /dev/urandom | dd bs=100 count=1 2>/dev/null

O 2>/dev/null no final do comando dd é para suprimir a saída "... registros na saída / ... registra a saída".

Não tenho conhecimento de quaisquer vantagens / desvantagens substanciais entre esses dois métodos.

Eu tive um problema com os dois métodos de tr reclamando sobre a entrada. Eu pensei que isso era porque não gostava de receber entrada binária e, portanto, sugeriu a primeira filtragem /dev/random com iconv -c -t US . No entanto, Gilles sugeriu um diagnóstico e uma solução diferentes, o que funciona para mim:

LC_ALL=C tr -dc A-Za-z0-9 </dev/urandom | dd bs=100 count=1 2>/dev/null

    

Answer 8

Você pode usar uma das ferramentas md5 que tenha exatamente esse propósito. No caso de criar uma senha completamente aleatória, você pode usar o md5pass . É uma ferramenta muito simples de usar e muito útil, desde que você pode usar "texto normal" junto com um "sal" para construir a mesma senha que você pode recuperar depois, ou como alternativa você pode querer obter um completamente senha aleatória o tempo todo. O uso geral é:

md5pass [password] [salt]

onde password é uma palavra escolhida que será usada para a construção da string aleatória e salt é o salto em bytes a ser usado. Assim:

md5pass word

$1$.MUittVW$j.XDTF1QRnxqFdXRUiSLs0

Isso criará uma senha de "seqüência aleatória" para você usar. Se você não usar salt , talvez não seja possível recriar essa mesma sequência posteriormente.

No entanto, se você usar um salt como este:

md5pass word 512

$1$512$.0jcLPQ83jgszaPT8xzds0

então você pode criar uma seqüência que você pode recuperar se você usar a palavra em conjunto com o mesmo salt (ou salto) se tiver sido originalmente definido.

    

Answer 9

Esses dois comandos geram senhas e senhas aleatórias, respectivamente.

shuf --random-source=/dev/urandom --repeat --head-count=20 file_with_characters | tr --delete '\n'

shuf --random-source=/dev/urandom --repeat --head-count=7 file_with_words | tr '\n' ' '

O gerador de senhas requer um arquivo_com_caracteres contendo todos os caracteres que você deseja que a senha use, um caractere por linha e exatamente uma vez cada. O arquivo não deve conter linhas em branco e as linhas devem ser terminadas com nova linha.

O gerador de frase-senha requer um arquivo_com_words contendo todas as palavras que você deseja usar para a frase secreta, uma palavra por linha e exatamente uma vez cada. O arquivo não deve conter linhas em branco e as linhas devem ser terminadas com nova linha.

A opção --head-count especifica o tamanho da senha - em caracteres - ou senha - em palavras.

    

Answer 10

Inspirado por Pablo Repetto, acabei com a solução fácil de lembrar :

shuf -zer -n20  {A..Z} {a..z} {0..9}

-z evita saída de várias linhas

-e ecoa o resultado

-r permite que qualquer caractere apareça várias vezes

-n20 string aleatória com um comprimento de 20 caracteres

{A..Z} {a..z} {0..9} classes de char permitidas

shuf faz parte dos coreutils do Linux e está amplamente disponível ou pelo menos foi portado.

    

Answer 11

APG é o software padrão nas distribuições do Linux.

Para gerar senhas de tamanho 5 a 10 em subconjuntos especial, numérico, maiúsculo e pequeno, é:

apg -MSNCL -m 5 -x 10

Retorna

@OpVeyhym9
3:Glul
3DroomIc?
hed&Os0
NefIj%Ob3
35Quok}

Como dito por @landroni um comentário.

    

Answer 12

Eu uso:

base64 < /dev/urandom | tr -d 'O0Il1+\' | head -c 44

Isso me dá 57 personagens possíveis. A string pode ser copiada e colada (removida + e \ ) ou impressa e digitada novamente, pois os caracteres difíceis de distinguir ( I1lO0 ) foram removidos.

• 44 caracteres me dá: log ₂ (57 ⁴⁴ ) > 256.64 bits de entropia
• 22 caracteres me dá: log ₂ (57 ²² ) > 128,32 bits de entropia

Eu gosto disso porque:

• o comando é simples de digitar e memorável
• usa ferramentas de sistema padrão - sem binários extras
• não "desperdiça" muita aleatoriedade (usa 89% dos bits aleatórios que recebe contra ~ 24% para soluções diretamente direcionadas para tr)
• 22 e 44 caracteres emparelham muito bem (apenas acima do mesmo) poder comum de dois pontos de interrupção
• a saída pode ser facilmente selecionada e colada ou impressa e digitada novamente com taxas de erro humano mínimas
• menor que as soluções codificadas hexadecimais (32 e 64 em vez de 22 e 44), como md5sum / sha1sum, etc.

Agradecemos o link e especialmente os comentários para a minha inspiração inicial.

    

Answer 13

Uma maneira super fácil e simples (provavelmente mais simples do que você está procurando) de conseguir isso seria gerar um número aleatório em um determinado intervalo, converter esse número em seu caractere ASCII equivalente e anexá-lo ao final de uma string.

Aqui está um exemplo básico em Python:

import random # import random library  
passFile = open("passwords.txt", 'w') # create file passwords.txt
passNum = int(input("Number of passwords: ")) # get number of  passwords
passLength = int(input("Password length: ")) # get length of passwords  
for i in range(passNum):
    password = "" # reset password
    for i in range(passLength):
        num = random.randint(65, 122) # get random number
        while num in range(91, 97): # Don't include punctuation
            num = random.randint(65, 122)
        password += chr(num) # add character to current password 
    passFile.write(password + "\n") # add current password to file  
passFile.close() # close file

EDIT: adicionou comentários e adicionou código para gerar várias senhas e gravá-las em um arquivo

    

Answer 14

Eu mantenho secpwgen no Alpine Linux & guarde as fontes no meu Github .

Pode produzir strings aleatórias ou frases diceware:

musl64 [~]$ secpwgen
USAGE: secpwgen <-p[e] | -A[adhsy] | -r | -s[e]> N

PASSPHRASE of N words from Diceware dictionary
  -p    generate passphrase
  -pe   generate enhanced (with symbols) passphrase

SKEY PASSWORD of N words from S/Key dictionary
  -s    generate passphrase
  -se   generate enhanced (with symbols) passphrase

ASCII RANDOM of N elements (at least one option MUST be present)
  -A    Each letter adds the following random elements in output:
    a    alphanumeric characters
    d    decimal digits
    h    hexadecimal digits
    s    special characters
    y    3-4 letter syllables

RAW RANDOM
  -r    output BASE64 encoded string of N random BITS
  -k    output koremutake encoding of N random BITS

Para gerar uma string aleatória de 13 caracteres, você usaria:

musl64 [~]$ secpwgen -Aas 13
----------------
WK5#*V<]M3<CU ;ENTROPY=67.21 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

musl64 [~]$ secpwgen -Aa 13
----------------
GP0FIEBM9Y3BT ;ENTROPY=67.21 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

Para os usuários lembrarem uma senha, use as frases diceware:

musl64 [~]$ secpwgen -p 5
----------------
wq seen list n8 kerr  ;ENTROPY=65.00 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

Eu pessoalmente gosto:

musl64 [~]$ secpwgen -r 512
----------------
h62lL7G4gwh3/j9c7YteQvVXoqJrQKKPWVR3Lt7az36DcfWZWtUgBT19iwmJBwP4UahNzPe7qYD7OcklUFpCzQ== ;ENTROPY=512.00 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

    

Answer 15

Descobri que piping / dev / urandom para tr no macOS não funcionou. Aqui está outra maneira:

set="abcdefghijklmonpqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
n=6
rand=""
for i in 'seq 1 $n'; do
    char=${set:$RANDOM % ${#set}:1}
    rand+=$char
done
echo $rand

    

Answer 16

Gostaria de contribuir com o meu comando habitual para gerar uma senha

$ cat /dev/urandom | base64 | head -n 1 |tr -dc '[:alnum:]' |cut -c -13
b0R55751vWW9V

Para configurar o comprimento da senha, altere o número no comando cut para o comprimento que você precisa, por exemplo, 24 caracteres

$ cat /dev/urandom | base64 | head -n 1 |tr -dc '[:alnum:]' |cut -c -24
WFBhVHuKbrnRhd5kdWXPzmZG

Não quer confundir 0 ou O, 1 ou l? Filtrar com outro tr

$ cat /dev/urandom | base64 | head -n 1 |tr -dc '[:alnum:]' | tr -d '0O1l'|cut -c -24
JuCphwvhrhppD9wVqfpP2beG

Eu pessoalmente nunca prefiro um caracter especial em senha, é por isso que escolho apenas [:alnum:] para meu gerador de senhas

    

Answer 17

Eu gostaria desse comando:

date +%s | sha256sum | base64 | head -c 12

    

Answer 18

eu vou, para link permite gerar strings de caracteres aleatórios até 2048 caracteres, selecionando maiúsculas, minúsculas, dígitos de 0 a 9, sinais de pontuação ou qualquer combinação.