¿Cómo generar una cadena aleatoria?

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

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

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

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

openssl rand -base64 12

o

openssl rand -hex 12

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

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

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.

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.

@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

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.

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.

Use el xxdcomando para especificar la longitud (a través de -l) que funciona en Linux y OS. https://www.howtoforge.com/linux-xxd-command/

xxd -l16 -ps /dev/urandom

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.

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

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 ₂ (57 ⁴⁴ )> 256.64 bits de entropía
• 22 caracteres me dan: log ₂ (57 ²² )> 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.

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.

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

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.

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

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

Me gustaría este comando:

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

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.