Как сгенерировать случайную строку?

Я хотел бы создать случайную строку (например, пароли, имена пользователей и т. Д.). Должна быть возможность указать необходимую длину (например, 13 символов).

Какие инструменты я могу использовать?

(Из соображений безопасности и конфиденциальности желательно, чтобы строки генерировались в автономном режиме, а не в Интернете на веб-сайте.)

Мой любимый способ сделать это, используя /dev/urandomвместе с, trчтобы удалить нежелательных символов. Например, чтобы получить только цифры и буквы:

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

Также можно добавить больше символов из списка специальных символов пароля OWASP :

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

Если у вас есть проблемы с trжалобами на ввод, попробуйте добавитьLC_ALL=C вот так:

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

Для генерации случайного пароля вы можете использовать pwgen:

pwgen генерирует случайные, бессмысленные, но произносимые пароли. Эти пароли содержат либо только строчные буквы, либо смешанные прописные и строчные буквы, либо вставленные цифры. Заглавные буквы и цифры размещаются таким образом, чтобы их было легче запомнить, когда запоминаются только слова.

Сгенерируйте 7 паролей длиной 13:

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

Как упоминалось в комментариях, вы можете избежать уменьшения энтропии с помощью -sаргумента (то есть генерировать более безопасные, совершенно случайные, но трудно запоминающиеся пароли):

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

Для генерации случайных имен пользователей вы можете использовать gpw:

Этот пакет генерирует произносимые пароли. Он использует статистику трехбуквенных комбинаций (триграфов), взятых из любых словарей, которые вы используете.

Генерация 7 паролей (имен пользователей) длиной 13:

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

Я использую opensslкоманду, швейцарский армейский нож криптографии.

openssl rand -base64 12

или же

openssl rand -hex 12

Вот как я это делаю. Он генерирует 10 символов случайной строки. Вы можете оптимизировать его, заменив «свернуть» другими инструментами для обработки строк.

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

Чтобы создать пароль с максимально возможной энтропией с помощью стандартных инструментов Linux, которые встроены в каждый дистрибутив, который я использую:

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

Это выводит все печатные символы ASCII - от 32 (пробел) до 126 (тильда, ~). Длина пароля может управляться с headрусским -cфлагом. Есть также другие возможные наборы символов tr(чтобы не включать пробел, используйте только символы 33-126 [:graph:]).

В зависимости от уровня случайности, который вы хотите, вы можете просто использовать встроенную переменную bash (также zshи ksh, возможно, других) $RANDOM:

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

Методы, читающие непосредственно из /dev/urandom, намного проще, но для завершения вы также можете использовать $RANDOM:

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

Важно : это решение будет генерировать только случайные строки, используя первые 10 букв алфавита. Будет ли этого достаточно для вас, зависит от того, для чего вам это нужно.

Вдохновленный Пабло Репетто, я получил это легко запоминающееся решение:

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

-z избегает многострочного вывода

-e повторяем результат

-r разрешить любому персонажу появляться несколько раз

-n20 случайная строка длиной 20 символов

{A..Z} {a..z} {0..9} разрешенные классы символов

shuf является частью linux coreutils и широко доступна или, по крайней мере, портирована.

@Brandin объяснил в комментарии к другому ответу, как получить максимум 100 байтов от /dev/urandomиспользования head -c 100. Еще один способ сделать это с dd:

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

В 2>/dev/nullконце ddкоманды подавляется вывод «... records in / ... records out».

Я не знаю каких-либо существенных преимуществ / недостатков между этими двумя методами.

У меня была проблема с обоими методами trжаловаться на ввод. Я думал, что это потому, что ему не нравилось получать бинарный ввод, и поэтому предложил сначала выполнить фильтрацию /dev/randomс помощью iconv -c -t US. Однако Жиль предложил другой диагноз и решение, которое работает для меня:

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

APG включен по умолчанию в некоторых дистрибутивах Linux.

Чтобы сгенерировать пароли размером от 5 до 10 в подмножествах Special, Numeric, Capital и Lower, введите команду:

apg -MSNCL -m 5 -x 10

И возвращает

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

Как сказал @landroni в комментарии.

Вы можете использовать один из md5инструментов, который имеет именно эту цель. В случае создания совершенно случайного пароля вы можете использовать md5pass. Это очень простой в использовании и очень полезный инструмент, поскольку вы можете использовать «обычный текст» вместе с «солью» для создания скачкообразного кода того же пароля, который вы можете восстановить впоследствии, или, в качестве альтернативы, вы можете получить полностью случайный пароль все время. Общее использование:

md5pass [password] [salt]

где password- выбранное слово, которое будет использоваться для построения случайной строки, и saltпереход в байтах, который будет использоваться. Нравится:

md5pass word

$1$.MUittVW$j.XDTF1QRnxqFdXRUiSLs0

Это создаст для вас пароль с произвольной последовательностью. Если вы используете нет salt, то вы не сможете воссоздать эту же строку позже.

Однако, если вы используете saltкак это:

md5pass word 512

$1$512$.0jcLPQ83jgszaPT8xzds0

затем вы можете создать последовательность, которую вы можете восстановить, если вы используете слово в сочетании с той же солью (или прыжком), если оно было первоначально определено.

Используйте xxdкоманду для указания длины (через -l), которая работает как в Linux, так и в ОС. https://www.howtoforge.com/linux-xxd-command/

xxd -l16 -ps /dev/urandom

Эти две команды генерируют случайные пароли и парольные фразы соответственно.

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' ' '

Генератору паролей требуется файл file_with_characters, содержащий все символы, которые вы хотите использовать в качестве пароля, по одному символу в строке и ровно по одному разу каждый. Файл не должен содержать пустых строк, а строки должны заканчиваться символом новой строки.

Генератору парольной фразы требуется файл file_with_words, содержащий все слова, которые вы хотите использовать для парольной фразы, по одному слову в строке и ровно по одному разу каждое. Файл не должен содержать пустых строк, а строки должны заканчиваться символом новой строки.

Опция --head-count указывает длину пароля - в символах - или пароль - в словах.

Я обнаружил, что передача / dev / urandom to tr на macOS не работает. Вот еще один способ:

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

Я использую:

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

Это дает мне 57 возможных символов. Строка может быть скопирована (удалена +и \) или напечатана и перепечатана, так как трудно различимые символы ( I1lO0) были удалены.

• 44 символа дают мне: log ₂ (57 ⁴⁴ )> 256,64 бит энтропии
• 22 символа дает мне: log ₂ (57 ²² )> 128,32 бит энтропии

Мне это нравится, потому что:

• команда проста для ввода и запоминается
• он использует стандартные системные инструменты - без дополнительных двоичных файлов
• не «тратит» много случайности (использует 89% случайных битов, которые он получает, по сравнению с ~ 24% для решений, напрямую передаваемых в tr)
• 22 и 44 символа соединяются довольно хорошо (чуть выше даже) общая сила двух точек останова
• вывод может быть легко выбран и вставлен или напечатан и перепечатан с минимальными человеческими ошибками
• короче, чем шестнадцатеричные (32 и 64 вместо 22 и 44) решения, такие как md5sum / sha1sum и т. д.

Благодарим https://unix.stackexchange.com/a/230676/9583 и особенно комментарии для моего первоначального вдохновения.

Философия Unix, заключающаяся в том, что «множество небольших инструментов хорошо справляются с одной задачей», очень хорошо вам подходит в этом случае.

• /dev/urandomэто поток случайных «байтов» (которые включают непечатаемые символы)
• base64 кодирует байтовые данные [A-Za-z0-9/+] (которые полностью печатаются)
• dd копирует ввод в вывод, применяя модификаторы, заданные в качестве аргументов (которые могут включать размер блока и количество блоков)

OSX

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

Linux

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

Примечания:

• Если вам нужно подмножество символов, вы можете вставить модификатор в трубу.
  • Пример: tr -d '[A-Z/+]'избавиться от заглавных букв и +и/
• Вы можете установить bs(размер блока) на любую длину, которая вам нужна.
• В Linux base64по умолчанию переносится на 76 столбцов и должен быть сброшен, -w0если вы этого не хотите.

Я хотел бы добавить свою обычную команду для создания пароля

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

Чтобы настроить длину пароля, измените число в команде cut на требуемую длину, например, 24 символа.

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

Не хотите путать 0 или O, 1 или L? Отфильтруйте это с другимtr

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

Лично я никогда не предпочитаю специальный символ в пароле, поэтому я выбираю только [:alnum:]для своего генератора паролей

Я поддерживаю secpwgenAlpine Linux и сохраняю исходники на своем Github .

Может генерировать случайные строки или фразы для двусмысленности:

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

Для генерации случайной строки из 13 символов вы должны использовать:

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.

Чтобы пользователи запомнили пароль, используйте фразы diceware:

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

Мне лично нравится:

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

Мой путь для очень безопасного пароля (где 16 - длина pw):

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

Пример результата:

jT@s_Nx]gH<wL~W}

Или, альтернативно, для создания нескольких паролей:

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

Пример результата:

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*

Немного менее безопасно (меньший набор символов):

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

Пример результата:

rJqYxYZLOTV+A45w
PUKQ+BoBf6yfZw5m
+LRfpsN9CsLRiN8V
yMS6zDpL6NHmG17s
yTUWPG7Rum97schi
cognvjVwaKaAyPRK

Сверхлегкий и простой (возможно, более простой, чем вы ищете) способ добиться этого состоит в том, чтобы сгенерировать случайное число в заданном диапазоне, преобразовать это число в эквивалентный ему символ ASCII и добавить его в конец строки. ,

Вот основной пример в 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

РЕДАКТИРОВАТЬ: добавлены комментарии и добавлен код для создания нескольких паролей и записи их в файл

Я хотел бы эту команду:

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

Я захожу на http://passwordsgenerator.net/, он позволяет генерировать строки случайных символов длиной до 2048 символов, выбирать верхний регистр, нижний регистр, цифры от 0 до 9, знаки пунктуации или любую комбинацию.