Como gerar uma string aleatória?

Eu gostaria de gerar uma sequência 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 motivos de segurança e privacidade, é preferível que as strings sejam geradas off-line, em vez de on-line em um site.)

Minha maneira favorita de fazer isso é usando /dev/urandomjunto com trpara 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 da lista de caracteres especiais da senha do OWASP :

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

Se você tiver algum problema com a trreclamação sobre a entrada, tente adicionarLC_ALL=C assim:

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

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

O pwgen gera senhas aleatórias, sem sentido, mas pronunciáveis. Essas senhas contêm apenas letras minúsculas, ou maiúsculas e minúsculas mistas ou dígitos inseridos. Letras e dígitos maiúsculos são colocados de maneira a facilitar a lembrança de sua posição ao memorizar apenas a palavra.

Gere 7 senhas de comprimento 13:

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

Conforme mencionado nos comentários, você pode evitar reduzir a entropia usando o -sargumento (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:

Este pacote gera senhas pronunciáveis. Ele usa as estatísticas de combinações de três letras (trigrafs) retiradas dos dicionários que você alimenta.

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

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

Estou usando o opensslcomando, o canivete suíço da criptografia.

openssl rand -base64 12

ou

openssl rand -hex 12

Aqui está como, eu faço. Ele gera uma sequência 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

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

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

Isso gera todos os caracteres imprimíveis ASCII - de 32 (espaço) a 126 (til ~). O comprimento da senha pode ser controlado com o head's -cbandeira. Também existem outros conjuntos de caracteres possíveis tr(para não incluir o espaço, apenas os caracteres 33-126, use [:graph:]).

Dependendo do nível de aleatoriedade que você deseja, você pode simplesmente usar a variável interna do bash (também zshe ksh, possivelmente outras) $RANDOM:

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

Os métodos de leitura direta /dev/urandomsã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-z]'

Importante : esta solução produzirá apenas seqüências aleatórias usando as 10 primeiras letras do alfabeto. Se isso é suficiente ou não, depende do que você precisa.

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

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

-z evita saída de várias linhas

-e ecoar o resultado

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

-n20 sequência aleatória com um comprimento de 20 caracteres

{A..Z} {a..z} {0..9} permitiram classes de caracteres

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

A @Brandin explicou em um comentário para outra resposta como obter no máximo 100 bytes de /dev/urandomuso 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/nullfinal do ddcomando é suprimir a saída "... records in / ... records out".

Não conheço vantagens / desvantagens substanciais entre esses dois métodos.

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

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

APG é incluído por padrão em algumas distribuições Linux.

Para gerar senhas de tamanho 5 a 10 nos subconjuntos Especial, Numérico, Capital e Menor, o comando é:

apg -MSNCL -m 5 -x 10

E retorna

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

Como dito por @landroni no comentário.

Você pode usar uma das md5ferramentas que tem exatamente esse objetivo. No caso de criar uma senha completamente aleatória, você pode usar o md5pass. É uma ferramenta muito simples de usar e muito útil, já que você pode usar "texto normal" junto com um "salt" para dar um salto na construção da mesma senha que você pode recuperar posteriormente ou, alternativamente, você pode querer obter uma descrição completa. 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 sequência aleatória e salté o salto em bytes a ser usado. Como isso:

md5pass word

$1$.MUittVW$j.XDTF1QRnxqFdXRUiSLs0

Isso criará uma senha de "uma sequência aleatória" para você usar. Se você usar não salt, poderá não conseguir recriar essa mesma sequência posteriormente.

No entanto, se você usar um saltcomo este:

md5pass word 512

$1$512$.0jcLPQ83jgszaPT8xzds0

em seguida, você pode criar uma sequência que poderá recuperar se usar a palavra em conjunto com o mesmo sal (ou salto) se foi originalmente definida.

Use o xxdcomando para especificar o comprimento (via -l), que funciona no Linux e no SO. https://www.howtoforge.com/linux-xxd-command/

xxd -l16 -ps /dev/urandom

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 secreta requer um arquivo com palavras contendo todas as palavras que você deseja que a frase secreta use, 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.

Descobri que canalizar / 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

Eu uso:

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

Isso me dá 57 caracteres possíveis. A sequência pode ser copiada e colada (removida +e \) ou impressa e redigitada conforme os caracteres difíceis de distinguir ( I1lO0) foram removidos.

• 44 caracteres fornecem: log ₂ (57 ⁴⁴ )> 256,64 bits de entropia
• 22 caracteres fornecem: 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 vs ~ 24% para soluções diretamente canalizadas para tr)
• 22 e 44 caracteres emparelham muito bem (logo acima do par) o poder comum de dois pontos de interrupção
• a saída pode ser facilmente selecionada e colada ou impressa e redigitada com taxas mínimas de erro humano
• soluções menores que as codificadas em hexadecimal (32 e 64 em vez de 22 e 44), como md5sum / sha1sum etc.

Agradeço a https://unix.stackexchange.com/a/230676/9583 e, especialmente, os comentários para minha inspiração inicial.

A filosofia do Unix de "muitas pequenas ferramentas que fazem uma coisa bem" serve muito bem nesse caso.

• /dev/urandomé um fluxo de "bytes" aleatórios (que incluem caracteres não imprimíveis)
• base64 codifica dados de bytes em [A-Za-z0-9/+] (que é totalmente imprimível)
• dd copia entrada para saída aplicando modificadores dados como argumentos (que podem incluir tamanho e contagem de blocos)

OSX

base64     < /dev/urandom | dd bs=1k count=1

Linux

base64 -w0 < /dev/urandom | dd bs=1k count=1

Notas:

• Se você precisar de um subconjunto de caracteres, poderá inserir um modificador no canal.
  • Ex: tr -d '[A-Z/+]'para se livrar de letras maiúsculas e +e/
• Você pode definir o bs(tamanho do bloco) para o tamanho que precisar.
• No Linux, base64agrupa 76 colunas por padrão e deve ser redefinida com -w0menos que você queira.

Eu gostaria de contribuir com meu comando usual 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 recortar para o comprimento necessário, 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? Filtre-o com outrotr

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

Pessoalmente, nunca prefiro caracteres especiais na senha, é por isso que só escolho o [:alnum:]meu gerador de senhas

Eu mantenho secpwgenno Alpine Linux e mantenho as fontes no meu Github .

Pode produzir seqüências aleatórias ou frases de 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 sequência 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 que os usuários se lembrem de uma senha, use as frases de 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 de:

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

Meu caminho para uma senha muito segura (onde 16 é o comprimento pw):

cat /dev/urandom | tr -cd [:graph:]|head -c 16

Resultado de exemplo:

jT@s_Nx]gH<wL~W}

Ou, alternativamente, para gerar várias senhas:

cat / dev / urandom | tr -cd [: gráfico:] | dobra -w 16 | cabeça -6

Resultado de exemplo:

7ck%G7'|f&}_8(]s
<?*]E.CG[NB'gK#A
:tF-WPTOa3!i7S(h
2xy(>=%3=Kb1B$`6
*98Lf{d?Jzb}6q1\
E7uCEAN2Hz]]y|5*

Pouco menos seguro (conjunto de caracteres menor):

cat /dev/urandom |base64 -w 0|fold -w 16|head -6

Resultado de exemplo:

rJqYxYZLOTV+A45w
PUKQ+BoBf6yfZw5m
+LRfpsN9CsLRiN8V
yMS6zDpL6NHmG17s
yTUWPG7Rum97schi
cognvjVwaKaAyPRK

Uma maneira super fácil e simples (provavelmente mais simples do que você procura) 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: comentários adicionados e código adicionado para gerar várias senhas e gravá-las em um arquivo

Eu gostaria deste comando:

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

Eu vou, para http://passwordsgenerator.net/ , permite gerar seqüências de caracteres aleatórios de até 2048 caracteres, selecionando maiúsculas, minúsculas, dígitos de 0 a 9, sinais de pontuação ou qualquer combinação.