Como gerar uma string aleatória?

209

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.)

landroni
fonte
1
Já existem boas respostas no AskUbuntu . (Eu uso apgpessoalmente).
Sparhawk
1
@Sparhawk A pergunta / respostas do AskUbuntu são mais sobre ferramentas de listagem. Considere adicionar uma resposta aqui exibindo como usar apgpara gerar uma sequência aleatória.
landroni
1
Seja cauteloso ao usar a geração aleatória de números em computadores. Alguns são muito menos aleatórios do que parecem, mas dizer a diferença entre geração de números aleatórios 'bom' e 'ruim' é bastante difícil.
Sobrique 21/09
@Sobrique Excelente argumento sobre geradores de números pseudo-aleatórios (por exemplo /dev/urandom). Seria bom ter algumas respostas usando verdadeiros geradores de números aleatórios, com base em, por exemplo, random.org .
landroni
25
Resposta da piada: Para gerar uma sequência verdadeiramente aleatória, coloque um novo usuário na frente do Emacs (ou Vim) e peça para ele sair. ;)
Curinga

Respostas:

186

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
Herbert
fonte
15
Ou faça o seguinte: head /dev/urandom | tr -dc A-Za-z0-9 | head -c10- Desta forma, é mais preciso. Você obtém 10 caracteres com letras maiúsculas, redutores ou dígitos
Brandin
8
O primeiro headcomando pode ser problemático. Ele produzirá as 10 primeiras linhas a partir de /dev/urandom, o que significa que será interrompido depois de ver a 10ª nova linha. Portanto, o comprimento da saída enviada para o trcomando é aleatório. É possível que haja menos de 13 caracteres na saída de tr. Não calculei a probabilidade disso acontecer, os cálculos são um pouco complicados.
precisa saber é o seguinte
6
Melhor fazer assim:<dev/urandom tr -dc "$charset" | head -c "$length"
PSkocik 20/09/2015
3
+1 Aqui está uma tentativa rápida de incluir os outros caracteres da página de caracteres especiais da senha do OWASP , escapados para a linha de comando do bash:tr -dc A-Za-z0-9\!\"#$\&\'\(\)\*+,-./\:\\\\\;\<=\>\?@[]^_`{\|}~
Rup
2
@Rup Não tenho certeza do que não está funcionando com seu tr ..comando, mas apenas citar tudo (exceto as aspas simples) funciona - tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~'.
precisa saber é o seguinte
144

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
landroni
fonte
21
+1 por não reinventar a roda. Se você não deseja a entropia reduzida da restrição "pronunciável", basta usar pwgen -s.
Nate Eldredge
123

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

openssl rand -base64 12

ou

openssl rand -hex 12
400 the Cat
fonte
10
rand -hexlimitará a saída a apenas 16 caracteres, em vez dos mais de 90 no meu teclado. base64 é melhor porque tem 64 caracteres, mas não é aleatório (por exemplo, existem padrões de preenchimento previsíveis e talvez alguns caracteres apareçam com mais frequência do que outros).
Martin Tournoij 27/08/16
@Carpetsmoker: Observe que o exemplo openssl rand -base64 12produz 16 caracteres de saída (porque 256 valores são mapeados para 64). E o exemplo hexadecimal produz 24 caracteres. Não há perda no caso do hexadecimal, pois é um mapeamento simples 1: 2, mas pode haver um pouco no caso base64 desde que o preenchimento seja usado. O radical não afeta a aleatoriedade, é o modo como um é mapeado para outro que afeta. (e a contagem total de bits é muito mais importante).
Dennis Williamson
A pergunta era "Como gerar uma seqüência aleatória de um comprimento específico" @DennisWilliamson, por isso, enquanto o seu comentário está correto , como tal , não é correto no contexto desta questão .
Martin Tournoij
@Carpetsmoker: Nesse caso, também não é esta resposta.
Dennis Williamson
4
Esta resposta merece mais votos. urandom, pwgen, gpw, etc, podem ou não estar disponíveis no seu sistema; também em ambientes diferentes, uma política que funcione em um pode não funcionar em outro. Seria uma configuração bastante disfuncional não ter openssl. Melhor ainda: openssl rand -base64 32 | tr -d / = + | cut -c -16 Isso resultará em 32 caracteres, exceto os não alfanumáticos, e cortados em 16 caracteres. Facilita o tratamento como administrador. Os usuários têm apenas alfanuméricos (que eles tendem a apreciar). O comprimento é longo o suficiente para que a remoção de caracteres especiais não tenha um impacto excessivo na entropia. Dourado.
Zentechinc
18

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
x1b2j
fonte
1
+1 Esta resposta está POSIXly correta, menos o uso /dev/urandomde, é claro
Harold Fischer
12

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:]).

drws
fonte
1
De que maneira isso é diferente das respostas existentes? Especificamente, Herbert vem à mente.
Fox
3
@Fox Sua solução usa uma lista de caracteres codificada, o que não é uma prática de programação incentivada devido à legibilidade, compacidade e limpeza do código. Além disso, alguns dos caracteres ASCII especiais imprimíveis podem ser interpretados pelo bash, sem mencionar a desvantagem mais óbvia de seu liner - se a entropia máxima for desejada, pode-se ter certeza de que todos os caracteres disponíveis estão incluídos na lista? E que não há duplicatas que possam alterar o comportamento do tr? Sua resposta deve ser substituída pela mina já que você perguntou :)
Drws
2
Muitos, se não a maioria dos sites, têm restrições quanto aos caracteres que podem estar em uma senha, portanto, a codificação codificada '[: print:]' não me parece melhor do que codificar a lista de caracteres especiais de senha da OWASP. Eu sinto que quase todas as respostas aqui poderia ser melhorada usando uma variável, mas isso é uma mudança tão pequena que eu só iria sugerir uma edição
Fox
1
< /dev/urandom tr -cd '[:graph:]'| tr -d '\\' | head -c 32; echose você não quiser ` characters in generated string. `porque é um caractere de escape em muitas línguas causa problemas
mzzzzb
< /dev/urandom tr -cd "[:print:]" | tr -d ' \\/\`\|' | head -c 32; echoexcluir | \ / `e espaço
Ryan Krage
9

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.

terdon
fonte
Como você controla o comprimento da string gerada?
landroni
@landroni Acho que você não pode usar um loop até obter o comprimento certo. $RANDOMimprimirá um número entre 0 e 32767.
terdon
Eu tentei executar o comando cerca de 20 vezes, e eu nunca pode obter algo mais do que 4-5 caracteres ...
landroni
2
@landroni obrigado, adicionei uma maneira de especificar o comprimento, mas não é muito bom. Eu apenas usaria algo parecido rand=$(head -c 100 /dev/urandom | tr -dc A-Za-z0-9 | head -c13).
terdon
1
@SkippyleGrandGourou muito bom ponto. Eu adicionei isso à resposta, obrigado.
terdon
8

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.

entwicklerseite
fonte
5

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
dubiousjim
fonte
Por alguma razão a iconvsolução maxes um núcleo da CPU e não produz uma saída (I esperou alguns 10s antes de matá-lo) ...
landroni
No meu sistema Ubuntu 14.04, o iconv é fornecido pela libc-bin2.19. Não tenho certeza se é o mesmo iconv ...
landroni 19/09/2015
trsuporta entrada binária. No entanto, um intervalo como esse A-Zpode ser influenciado pelas configurações de localidade. TenteLC_ALL=C tr …
Gilles
1
@ Gilles De acordo com a especificação POSIX, ele não "suporta entrada binária". Somente o GNU trsuporta porque não suporta multibyte (por exemplo, da última vez que verifiquei que a mudança de caso foi implementada simplesmente configurando o sexto bit de cada byte). Outros sistemas (por exemplo, BSD) suportam multibyte e isso falhará, pois a chance de um fluxo de entrada aleatório também ser um fluxo válido de multibyte é muito pequena na maioria das codificações. O GNU pode adicionar suporte multibyte a qualquer momento, momento em que isso falhará. Obviamente, a configuração LC_ALL=Ccorrigirá isso.
Martin Tournoij 27/08/16
O @Carpetsmoker POSIX requer o trprocessamento de entrada binária (no código de idioma C). (Bem, ok, ele diz apenas explicitamente que bytes nulos devem ser suportados, não diz que arquivos não vazios que não terminam com um caractere de nova linha devem ser suportados, mas na prática esse sempre é o caso também.)
Gilles
4

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.

Sandburg
fonte
1
Aqui estão as opções para gerar aleatório 14 carta senhas contendo lotes de caracteres especiais:apg -a1 -m14
Neuhaus
3

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.

Joke Sr. OK
fonte
Quando um saltestá sendo usado, isso soa semelhante à abordagem PasswordMaker ...
landroni
-Sim Pode parecer semelhante à senha de um fabricante, mas a diferença é que não é um programa comercial nem nada, porque o conjunto de ferramentas md5 "md5pass, md5sum, md5sum.textutils" tratadas aqui estão em causa e estão disponíveis no sistema sem nenhum custo alguns !!!
Joke Sr. OK
Na verdade, eu tinha em mente o PasswordMaker , que também é de código aberto e não comercial.
landroni
2

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.

Pablo Repetto
fonte
1

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
Jake
fonte
Veja o último exemplo da minha resposta. Não usa tr. Unix.stackexchange.com/a/494931/203075
Zibri
1

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 2 (57 44 )> 256,64 bits de entropia
  • 22 caracteres fornecem: log 2 (57 22 )> 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.

Iiridayn
fonte
Se você precisar números / caracteres especiais - normalmente haverá um número, se não você pode anexar com segurança 1sem reduzir a entropia (ao gerar um novo para obter um w / um número faz reduzir a entropia). Você também pode anexar com segurança um !sem reduzir a entropia. Nenhum esquema aumenta a entropia que vale nada, mas pode colocar a sequência gerada em conformidade com os requisitos de senha mais antigos.
Iiridayn
1

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.
Bruno Bronosky
fonte
1

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

Sharuzzaman Ahmat Raslan
fonte
0

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.
Stuart Cardall
fonte
0

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
Zibri
fonte
-1

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

camelCaseEnthusiast
fonte
3
Se tivesse o poder do Python, eu não o faria dessa maneira. Seria muito mais fácil usar uma junção em uma sequência contendo todos os caracteres válidos para uma senha e usando random para selecionar os caracteres.
Mike McMahon
melhor usar Python como esta code.activestate.com/recipes/578468-password-generator-mkpasswd
Grijesh Chauhan
-2

Eu gostaria deste comando:

date +%s | sha256sum | base64 | head -c 12
Eugen Konkov
fonte
1
Prefiro usar uma abordagem mais aleatória de nanossegundos: date +%N como se você gerar muitos usuários e senhas em um script, os segundos podem se tornar iguais para muitos ou mesmo para todos os comandos de data, produzindo senhas idênticas.
John Mayor
1
@ JohnMayor: essa abordagem é mais robusta dd if=/dev/random bs=512 count=1:?
Eugen Konkov
8
Esta resposta é altamente perigosa! Você gera as senhas a partir de uma semente conhecida que é fácil de prever. Eu pude gerar todas as senhas geradas usando esse método dos últimos anos e usar essa lista para fins de força bruta.
Flow
-4

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.

KrazyKyngeKorny
fonte
2
Esclarei a pergunta para explicitar que as seqüências geradas off-line são preferíveis. A geração de uma senha diretamente em um site, especialmente se a conexão não for HTTPS (como na sua resposta), não é segura.
landroni
1
Obter uma senha aleatória da Internet é espetacularmente estúpido e ingênuo. Alguém agora sabe a senha que você está usando para algum serviço ou site e detalhes pessoais exclusivos sobre você (endereço IP, informações sobre navegador / ambiente). Agora, este site pode fazer referência cruzada das informações com outros dados coletados sobre você. Por exemplo, uma vez que você postou em uma lista de e-mail, seu endereço IP está no cabeçalho do e-mail, agora temos uma senha, nome e endereço de e-mail ... Você está realmente confiando em estranhos aleatórios com suas senhas aqui.
Martin Tournoij 27/08/16