¿Cómo generar una cadena aleatoria?

209

Me gustaría generar una cadena aleatoria (por ejemplo, contraseñas, nombres de usuario, etc.). Debería ser posible especificar la longitud necesaria (por ejemplo, 13 caracteres).

¿Qué herramientas puedo usar?

(Por razones de seguridad y privacidad, es preferible que las cadenas se generen fuera de línea, en lugar de en línea en un sitio web).

Landroni
fuente
1
Ya hay buenas respuestas en AskUbuntu . (Yo uso apgpersonalmente.)
Sparhawk
1
@Sparhawk Las preguntas / respuestas de AskUbuntu son más sobre herramientas de listado. Considere agregar una respuesta aquí que muestre cómo usar apgpara generar una cadena aleatoria.
landroni
1
Tenga cuidado al usar la generación de números aleatorios en las computadoras. Algunos son mucho menos aleatorios de lo que parecen, pero decir la diferencia entre la generación de números aleatorios 'buenos' y 'malos' es bastante difícil.
Sobrique
@Sobrique Excelente punto sobre generadores de números pseudoaleatorios (p /dev/urandom. Ej .). Sería bueno tener algunas respuestas utilizando verdaderos generadores de números aleatorios, basados ​​en, por ejemplo, random.org .
landroni
25
Respuesta de broma: Para generar una cadena verdaderamente aleatoria, coloque un nuevo usuario frente a Emacs (o Vim) y pídales que salgan. ;)
Comodín del

Respuestas:

186

Mi forma favorita de hacerlo es usarlo /dev/urandomjunto con trpara eliminar caracteres no deseados. Por ejemplo, para obtener solo dígitos y letras:

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

Alternativamente, para incluir más caracteres de la lista de caracteres especiales de contraseña de OWASP :

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

Si tiene algunos problemas para trquejarse de la entrada, intente agregarLC_ALL=C así:

LC_ALL=C tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~' </dev/urandom | head -c 13 ; echo
Herbert
fuente
15
O haga esto: head /dev/urandom | tr -dc A-Za-z0-9 | head -c10- Esta manera es más precisa. Obtienes 10 caracteres que son mayúsculas, minúsculas o dígitos
Brandin
8
El primer headcomando puede ser problemático. Producirá las primeras 10 líneas /dev/urandom, lo que significa que se detendrá una vez que haya visto la décima línea nueva. Entonces, la longitud de la salida enviada al trcomando es aleatoria. Es posible que haya menos de 13 caracteres en la salida de tr. No he calculado la probabilidad de que esto suceda, los cálculos son un poco complicados.
Kasperd
66
Mejor hacerlo así:<dev/urandom tr -dc "$charset" | head -c "$length"
PSkocik
3
+1 Aquí hay un intento rápido de incluir los otros caracteres de la página de caracteres especiales de contraseña de OWASP , escapado para la línea de comando bash:tr -dc A-Za-z0-9\!\"#$\&\'\(\)\*+,-./\:\\\\\;\<=\>\?@[]^_`{\|}~
Rup
2
@Rup No estoy seguro de lo que no funciona con su tr ..comando, pero solo citar todo (excepto la comilla simple) funciona tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~'.
Kenny Evitt
144

Para generar una contraseña aleatoria puede usar pwgen:

pwgen genera contraseñas aleatorias, sin sentido pero pronunciables. Estas contraseñas contienen solo letras minúsculas o mayúsculas y minúsculas, o dígitos agregados. Las letras mayúsculas y los dígitos se colocan de manera que sea fácil recordar su posición al memorizar solo la palabra.

Genere 7 contraseñas de longitud 13:

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

Como se menciona en los comentarios, puede evitar reducir la entropía utilizando el -sargumento (es decir, generar contraseñas más seguras, completamente aleatorias pero difíciles de recordar):

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

Para generar nombres de usuario aleatorios, puede usar gpw:

Este paquete genera contraseñas pronunciables. Utiliza las estadísticas de combinaciones de tres letras (trigrafos) tomadas de los diccionarios que le proporcione.

Genere 7 contraseñas (nombres de usuario) de longitud 13:

geek@liv-inspiron:~$ gpw 7 13
sreepoidahsas
risadiestinge
ntodynesssine
deodstestress
natinglumperm
riasigentspir
enderiferback
Landroni
fuente
21
+1 por no reinventar la rueda. Si no desea la entropía reducida de la restricción "pronunciable", simplemente use pwgen -s.
Nate Eldredge
123

Estoy usando el opensslcomando, la navaja suiza de la criptografía.

openssl rand -base64 12

o

openssl rand -hex 12
400 el gato
fuente
10
rand -hexlimitará la salida a solo 16 caracteres, en lugar de los 90+ en mi teclado. base64 es mejor porque tiene 64 caracteres, pero no es aleatorio (por ejemplo, hay patrones de relleno predecibles y quizás algunos caracteres aparecen con más frecuencia que otros).
Martin Tournoij
@Carpetsmoker: tenga en cuenta que el ejemplo openssl rand -base64 12produce 16 caracteres de salida (porque 256 valores se asignan a 64). Y el ejemplo hexadecimal produce 24 caracteres. No hay pérdida en el caso del hexadecimal ya que es un mapeo simple 1: 2, pero puede haber un poco en el caso de base64 ya que se usa relleno. La raíz no afecta la aleatoriedad, es la forma en que uno se asigna a otro que sí. (y el recuento total de bits es mucho más importante).
Dennis Williamson
La pregunta era "Cómo generar una cadena aleatoria de una longitud específica" @DennisWilliamson, por lo que si bien su comentario es correcto como tal , no es correcto en el contexto de esta pregunta .
Martin Tournoij
@Carpetsmoker: en ese caso, tampoco es esta respuesta.
Dennis Williamson
44
Esta respuesta merece más votos a favor. urandom, pwgen, gpw, etc. pueden o no estar disponibles en su sistema; También en diferentes entornos, una política que funciona en uno puede no funcionar en otro. Sería una configuración bastante disfuncional no tener openssl. Aún mejor: openssl rand -base64 32 | tr -d / = + | corte -c -16 Eso le dará 32 caracteres menos los no alfanuméricos y recortados a 16 caracteres de longitud. Facilita el trato como administrador. Los usuarios solo tienen alfanum (que tienden a apreciar). La longitud es lo suficientemente larga como para que la eliminación de caracteres especiales no afecte demasiado la entropía. Dorado.
zentechinc
18

Así es como lo hago. Genera una cadena aleatoria de 10 caracteres. Puede optimizarlo reemplazando el "pliegue", con otras herramientas de procesamiento de cadenas.

cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 10 | head -n 1
x1b2j
fuente
1
+1 Esta respuesta es POSIXY correcta, menos el uso, /dev/urandompor supuesto
Harold Fischer
12

Para generar una contraseña con la mayor entropía posible con las herramientas estándar de Linux integradas en cada distribución que uso:

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

Esto genera todos los caracteres imprimibles ASCII, desde 32 (espacio) hasta 126 (tilde, ~). La longitud de la contraseña se puede controlar con la head's -cbandera. También hay otros conjuntos de caracteres posibles tr(para no incluir el espacio, solo los caracteres 33-126, use [:graph:]).

drws
fuente
1
¿De qué manera es esto diferente de las respuestas existentes? En concreto, Herbert viene a la mente.
Fox
3
@Fox Su solución utiliza una lista codificada de caracteres, lo cual no es una práctica de programación recomendada debido a la legibilidad, compacidad y limpieza del código. Además, algunos de los caracteres ASCII imprimibles especiales podrían ser interpretados por bash, sin mencionar el inconveniente más obvio de su único revestimiento: si se desea la máxima entropía, ¿puede uno estar seguro de que todos los caracteres disponibles están incluidos en la lista? ¿Y que no hay duplicados que puedan alterar el comportamiento del tr? Su respuesta debería ser reemplazada por la mía ya que usted preguntó :)
drws
2
Muchos, si no la mayoría de los sitios web tienen restricciones sobre los caracteres que pueden estar en una contraseña, por lo que codificar '[: print:]' no me parece mejor que codificar la lista de caracteres especiales de contraseña de OWASP. Siento que casi cada respuesta aquí podría mejorarse mediante el uso de una variable, sino que es un cambio menor que yo sólo te sugeriría una edición
Fox
1
< /dev/urandom tr -cd '[:graph:]'| tr -d '\\' | head -c 32; echosi no quiere ` characters in generated string. `porque un carácter de escape en muchos idiomas causa problemas
mzzzzb
< /dev/urandom tr -cd "[:print:]" | tr -d ' \\/\`\|' | head -c 32; echoexcluir | \ / `y espacio
Ryan Krage
9

Dependiendo del nivel de aleatoriedad que desee, simplemente puede ir con la variable integrada de bash (también zshy ksh, posiblemente, otros) $RANDOM:

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

Los métodos para leer directamente /dev/urandomson mucho más simples, pero para completar, también puedes usar $RANDOM:

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

Importante : esta solución solo producirá cadenas aleatorias utilizando las primeras 10 letras del alfabeto. Si eso es suficiente para usted o no, depende de para qué lo necesite.

terdon
fuente
¿Cómo controlas la longitud de la cadena generada?
landroni
@landroni No creo que puedas usar un bucle hasta que obtengas la longitud correcta. $RANDOMimprimirá un número entre 0 y 32767.
terdon
He tratado de ejecutar el comando unas 20 veces, y nunca puedo conseguir nada más de 4-5 caracteres ...
landroni
2
@landroni gracias, he agregado una forma de especificar la longitud pero no es muy buena. Simplemente usaría algo como en su rand=$(head -c 100 /dev/urandom | tr -dc A-Za-z0-9 | head -c13)lugar.
terdon
1
@SkippyleGrandGourou muy buen punto. Agregué esto a la respuesta, gracias.
terdon
8

Inspirado por Pablo Repetto, terminé con esta solución fácil de recordar :

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

-z evita la salida multilínea

-e echo el resultado

-r permite que cualquier personaje aparezca varias veces

-n20 cadenas aleatorias con una longitud de 20 caracteres

{A..Z} {a..z} {0..9} clases de caracteres permitidas

shuf es parte de los Linux Coreutils y está ampliamente disponible o al menos ha sido portado.

Entwicklerseite
fuente
5

@Brandin explicó en un comentario a otra respuesta cómo obtener como máximo 100 bytes del /dev/urandomuso head -c 100. Otra forma de hacer esto es con dd:

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

El 2>/dev/nullfinal del ddcomando es suprimir la salida "... registros de entrada / ... registros de salida".

No conozco ninguna ventaja / desventaja sustancial entre estos dos métodos.

Tuve un problema con ambos métodos de trqueja sobre la entrada. Pensé que esto se debía a que no le gustaba recibir entradas binarias y, por lo tanto, sugerí primero filtrar /dev/randomcon iconv -c -t US. Sin embargo, Gilles sugirió un diagnóstico y una solución diferentes, que funcionan para mí:

LC_ALL=C tr -dc A-Za-z0-9 </dev/urandom | dd bs=100 count=1 2>/dev/null
dubiousjim
fuente
Por alguna razón la iconvsolución maxes un núcleo CPU y no produce una salida (Esperé unos 10 segundos antes de matar a ella) ...
landroni
En mi sistema Ubuntu 14.04, iconv es proporcionado por libc-bin2.19. No estoy seguro de si es el mismo iconv ...
landroni
tradmite entrada binaria. Sin embargo, un rango como A-Zpuede estar influenciado por la configuración regional. PruebaLC_ALL=C tr …
Gilles
1
@Gilles Según la especificación POSIX, no "admite entrada binaria". Solo GNU lo trhace porque no admite multibyte en absoluto (por ejemplo, la última vez que lo verifiqué, el cambio de mayúsculas y minúsculas se implementó simplemente configurando el sexto bit de cada byte). Otros sistemas (por ejemplo, BSD) admiten multibyte y esto fallará allí, ya que la posibilidad de que un flujo de entrada aleatorio sea también un flujo multibyte válido es muy pequeña en la mayoría de las codificaciones. GNU puede agregar soporte multibyte en cualquier momento dado, momento en el cual esto fallará. Por supuesto, la configuración LC_ALL=Clo arreglará.
Martin Tournoij
@Carpetsmoker POSIX requiere trprocesar la entrada binaria (en la configuración regional C). (Bueno, está bien, solo dice explícitamente que los bytes nulos deben ser compatibles, no dice que los archivos no vacíos que no terminan con un carácter de nueva línea deben ser compatibles, pero en la práctica ese también es siempre el caso)
Gilles
4

APG se incluye por defecto en algunas distribuciones de Linux.

Para generar contraseñas de tamaño 5 a 10 en subconjuntos Especial, Numérico, Capital e Inferior, el comando es:

apg -MSNCL -m 5 -x 10

Y vuelve

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

Como dijo @landroni en el comentario.

Sandburg
fuente
1
Estas son las opciones para generar contraseñas aleatorias de 14 letras que contienen muchos caracteres especiales:apg -a1 -m14
neuhaus
3

Puede usar una de las md5herramientas que tiene precisamente este propósito. En el caso de crear una contraseña completamente aleatoria, puede usar el md5pass. Es una herramienta muy simple de usar y muy útil, ya que puede usar "texto normal" junto con una "sal" para saltar la construcción de la misma contraseña que puede recuperar después, o alternativamente puede querer obtener una contraseña aleatoria todo el tiempo El uso general es:

md5pass [password] [salt]

donde passwordes una palabra elegida que se utilizará para la construcción de la cadena aleatoria y saltes el salto en bytes que se utilizará. Me gusta esto:

md5pass word

$1$.MUittVW$j.XDTF1QRnxqFdXRUiSLs0

Esto creará una contraseña de "secuencia aleatoria" para que la use. Si usa no salt, es posible que no pueda volver a crear esta misma cadena después.

Sin embargo, si usas algo saltasí:

md5pass word 512

$1$512$.0jcLPQ83jgszaPT8xzds0

entonces puede crear una secuencia que puede recuperar si usa la palabra junto con la misma sal (o salto) si se definió originalmente.

Broma Sr. OK
fuente
Cuando una saltse está utilizando, esto suena similar al enfoque PasswordMaker ...
landroni
-Puede sonar similar a la contraseña de un creador, pero la diferencia es que no es un programa comercial ni nada, porque el conjunto de herramientas md5, "md5pass, md5sum, md5sum.textutils" que se tratan aquí están relacionadas y están disponibles para el sistema. sin costo alguno !!!
Broma Sr. OK
De hecho, tenía en mente PasswordMaker , que también es de código abierto y no comercial.
landroni
2

Estos dos comandos generan contraseñas y frases de contraseña aleatorias, 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' ' '

El generador de contraseñas requiere un archivo con caracteres que contenga todos los caracteres que desea que use la contraseña, un carácter por línea y exactamente una vez cada uno. El archivo no debe contener líneas en blanco, y las líneas deben estar terminadas en nueva línea.

El generador de frase de contraseña requiere un archivo_con_palabras que contenga todas las palabras que desea que use la frase de contraseña, una palabra por línea y exactamente una vez cada una. El archivo no debe contener líneas en blanco, y las líneas deben estar terminadas en nueva línea.

La opción --head-count especifica la longitud de la contraseña, en caracteres, o frase de contraseña, en palabras.

Pablo Repetto
fuente
1

Descubrí que piping / dev / urandom to tr en macOS no funcionaba. Aquí hay otra forma:

set="abcdefghijklmonpqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
n=6
rand=""
for i in `seq 1 $n`; do
    char=${set:$RANDOM % ${#set}:1}
    rand+=$char
done
echo $rand
Jake
fuente
Mira el último ejemplo de mi respuesta. No usa tr. unix.stackexchange.com/a/494931/203075
Zibri
1

Yo suelo:

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

Esto me da 57 personajes posibles. La cadena se puede copiar-pegar (eliminar +y \) o imprimir y volver a escribir a medida que se eliminan los caracteres difíciles de distinguir ( I1lO0).

  • 44 caracteres me dan: log 2 (57 44 )> 256.64 bits de entropía
  • 22 caracteres me dan: log 2 (57 22 )> 128.32 bits de entropía

Me gusta esto porque:

  • el comando es simple de escribir y memorable
  • utiliza herramientas de sistema estándar, sin binarios adicionales
  • no "desperdicia" mucha aleatoriedad (utiliza el 89% de los bits aleatorios que recibe frente al ~ 24% para soluciones que se canalizan directamente a tr)
  • 22 y 44 caracteres se combinan bastante bien (justo por encima) de la potencia común de dos puntos de interrupción
  • la salida se puede seleccionar y pegar fácilmente o imprimir y volver a escribir con tasas mínimas de error humano
  • soluciones más cortas que las codificadas en hexadecimal (32 y 64 en lugar de 22 y 44) como md5sum / sha1sum, etc.

Crédito a https://unix.stackexchange.com/a/230676/9583 y especialmente los comentarios para mi inspiración inicial.

Iiridayn
fuente
Si necesita los números / caracteres especiales - normalmente habrá un número, si no se puede añadir con seguridad 1sin reducir la entropía (mientras se genera uno nuevo para obtener una w / un número que hace reducir la entropía). También puede agregar con seguridad un !sin reducir la entropía. Ninguno de los esquemas aumenta la entropía que valga la pena, pero podría hacer que la cadena generada cumpla con los requisitos de contraseña anteriores.
Iiridayn
1

La filosofía de Unix de "muchas herramientas pequeñas que hacen una cosa bien" le sirve muy bien en este caso.

  • /dev/urandomes una secuencia de "bytes" aleatorios (que incluyen caracteres no imprimibles)
  • base64 codifica datos de bytes en [A-Za-z0-9/+] (que es totalmente imprimible)
  • dd copia la entrada a la salida aplicando modificadores dados como argumentos (que pueden incluir el tamaño y el recuento de bloques)

OSX

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

Linux

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

Notas:

  • Si necesita un subconjunto de los caracteres, puede insertar un modificador en la tubería.
    • Ej: tr -d '[A-Z/+]'para deshacerse de letras mayúsculas y +y/
  • Puede establecer el bs(tamaño del bloque) a la longitud que necesite.
  • En Linux, se base64ajusta a 76 columnas de forma predeterminada y debe reiniciarse a -w0menos que lo desee.
Bruno Bronosky
fuente
1

Me gustaría contribuir con mi comando habitual para generar una contraseña

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

Para configurar la longitud de la contraseña, cambie el número en el comando de corte a la longitud que necesita, por ejemplo, 24 caracteres

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

¿No quieres confundir 0 u O, 1 o l? Filtrarlo con otrotr

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

Personalmente, nunca prefiero caracteres especiales en la contraseña, es por eso que solo elijo [:alnum:]mi generador de contraseña

Sharuzzaman Ahmat Raslan
fuente
0

Mantengo secpwgenen Alpine Linux y mantener las fuentes en mi Github .

Puede producir cadenas aleatorias o frases de dados:

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 generar una cadena aleatoria de 13 caracteres usaría:

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 los usuarios recuerden una contraseña, use las frases del diceware:

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

Personalmente me gusta:

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

Mi camino para una contraseña muy segura (donde 16 es la longitud de la contraseña):

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

Resultado de ejemplo:

jT@s_Nx]gH<wL~W}

O, alternativamente, para generar múltiples contraseñas:

cat / dev / urandom | tr -cd [: graph:] | fold -w 16 | head -6

Resultado de ejemplo:

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*

Poco menos seguro (juego de caracteres más pequeño):

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

Resultado de ejemplo:

rJqYxYZLOTV+A45w
PUKQ+BoBf6yfZw5m
+LRfpsN9CsLRiN8V
yMS6zDpL6NHmG17s
yTUWPG7Rum97schi
cognvjVwaKaAyPRK
Zibri
fuente
-1

Una manera súper fácil y simple (probablemente más simple de lo que está buscando) de lograr esto sería generar un número aleatorio en un rango dado, convertir ese número a su carácter ASCII equivalente y agregarlo al final de una cadena .

Aquí hay un ejemplo básico en 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

EDITAR: comentarios agregados y código agregado para generar múltiples contraseñas y escribirlas en un archivo

camelCaseEntusiasta
fuente
3
Si tuviera el poder de Python, NO lo haría de esta manera. Sería mucho más fácil usar una unión en una cadena que contenga todos los caracteres válidos para una contraseña y usar aleatorio para seleccionar los caracteres.
Mike McMahon
mejor usar Python como este código.activestate.com
recipes
-2

Me gustaría este comando:

date +%s | sha256sum | base64 | head -c 12
Eugen Konkov
fuente
1
Preferiría usar un enfoque de nanosegundos más aleatorio: date +%N dado que si genera muchos usuarios y contraseñas en un script, los segundos podrían ser los mismos para muchos o incluso para todos los comandos de fecha, produciendo contraseñas idénticas.
John Mayor
1
@JohnMayor: ¿este enfoque es más robusto dd if=/dev/random bs=512 count=1:?
Eugen Konkov
8
¡Esta respuesta es muy peligrosa! Genera las contraseñas a partir de una semilla conocida que es fácil de predecir. Podría generar todas las contraseñas generadas usando este método de los últimos años y usar esta lista para propósitos de fuerza bruta.
Flujo
-4

Voy a http://passwordsgenerator.net/ que permite generar cadenas de caracteres aleatorios de hasta 2048 caracteres, seleccionando mayúsculas, minúsculas, dígitos del 0 al 9, signos de puntuación o cualquier combinación.

KrazyKyngeKorny
fuente
2
He aclarado la pregunta para hacer explícito que las cadenas generadas fuera de línea son preferibles. Generar una contraseña directamente en un sitio web, especialmente si la conexión no es HTTPS (como en su respuesta), no es seguro.
landroni
1
Obtener una contraseña aleatoria de Internet es espectacularmente estúpido e ingenuo. Alguien ahora sabe una contraseña que está utilizando para algún servicio o sitio y detalles personales únicos sobre usted (dirección IP, información del navegador / entorno). Este sitio ahora puede hacer referencias cruzadas de la información con otros datos recopilados sobre usted. Por ejemplo, una vez que publicó en una lista de correo, su dirección IP está en el encabezado del correo, por lo que ahora tenemos una contraseña, un nombre y una dirección de correo electrónico ... Aquí realmente está confiando en extraños al azar con sus contraseñas.
Martin Tournoij