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

Question 1

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

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

</div><div class="s-prose js-post-body" itemprop="text">

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

$ 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

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

</div><div class="s-prose js-post-body" itemprop="text">

pwgen, как и все другие, для паролей.

Только строчные буквы, безопасно, минимум 1 цифра, 8 символов, 1 результат

$ pwgen -snA 8 1
d14o5wgh

То же самое, но минимум 1 заглавная буква

$ pwgen -csn 8 1
bMxDxcr4

Кубиковая программа для имен пользователей и паролей, если хотите, для чего-то более удобного для запоминания; я использую pip пакет diceware, что вполне устраивает мои потребности.

3 слова и 2 символа

$ diceware -n3 -s2
DemandingWhimsical*a1iar

Я уверен, что есть как минимум 100 других, из которых 74% написаны на nodejs, потому что, ну… это то, что они делают. Какой бы вариант вы ни выбрали, я бы отдал приоритет встроенным функциям верхнего/нижнего регистра, потому что в какой-то момент у вас будут эти ограничения, и выполнение любого из этих действий занимает раздражающе много времени в оболочке posix.

Удачи

</div><div class="s-prose js-post-body" itemprop="text">

Я использовал grep:

grep -ao '[!-~]' < /dev/urandom | head -32 | tr -d '\n' ; echo ""

Без специальных символов:

grep -ao '[A-Za-z0-9]' < /dev/urandom | head -32 | tr -d '\n' ; echo ""

head определяет длину строки.

</div><div class="s-prose js-post-body" itemprop="text">

Универсальная философия “много маленьких инструментов, которые делают одно дело хорошо” очень вам помогает в данном случае.

/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, если вы не хотите этого.

Question 2

Я поддерживаю secpwgen в Alpine Linux и держу исходный код на своем Github.

Он может производить случайные строки или фразы diceware:

musl64 [~]$ secpwgen
USAGE: secpwgen <-p[e] | -A[adhsy] | -r | -s[e]> N

PASSPHRASE из N слов из словаря Diceware
  -p    генерировать фразу
  -pe   генерировать улучшенную (с символами) фразу

SKEY PASSWORD из N слов из словаря S/Key
  -s    генерировать фразу
  -se   генерировать улучшенную (с символами) фразу

ASCII RANDOM из N элементов (по крайней мере, один вариант ДОЛЖЕН быть представлен)
  -A    Каждая буква добавляет следующие случайные элементы в вывод:
    a    буквенно-цифровые символы
    d    десятичные цифры
    h    шестнадцатеричные цифры
    s    специальные символы
    y    слоги из 3-4 букв

RAW RANDOM
  -r    вывод кодированной BASE64 строки из N случайных БИТ
  -k    вывод кодировки koremutake из N случайных БИТ

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

musl64 [~]$ secpwgen -Aas 13
----------------
WK5#*V<]M3<CU ;ENTROPY=67.21 bits
----------------
INFO: уничтожение генератора случайных чисел.
INFO: обнуление памяти.

musl64 [~]$ secpwgen -Aa 13
----------------
GP0FIEBM9Y3BT ;ENTROPY=67.21 bits
----------------
INFO: уничтожение генератора случайных чисел.
INFO: обнуление памяти.

Для запоминания пароля используйте фразы diceware:

musl64 [~]$ secpwgen -p 5
----------------
wq seen list n8 kerr  ;ENTROPY=65.00 bits
----------------
INFO: уничтожение генератора случайных чисел.
INFO: обнуление памяти.

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

musl64 [~]$ secpwgen -r 512
----------------
h62lL7G4gwh3/j9c7YteQvVXoqJrQKKPWVR3Lt7az36DcfWZWtUgBT19iwmJBwP4UahNzPe7qYD7OcklUFpCzQ== ;ENTROPY=512.00 bits
----------------
INFO: уничтожение генератора случайных чисел.
INFO: обнуление памяти.

Question 3

Используя только head и md5sum для генерации шестнадцатеричных паролей длиной 22:

 head -c 2048 /dev/urandom | md5sum | head -c 22 ; echo

Ультрабезопасно? Может быть, нет. Легко? Да.

Question 4

С помощью короткого bash скрипта:

len=20
arr=( {33..126} ) arrcount=${#arr[@]}
for ((i=0; i<len; i++)); do
    printf \\$(printf '%03o' ${arr[RANDOM%arrcount]})
done; echo

Если вы предпочитаете без специальных символов, используйте:

arr=( {48..57} {65..90} {97..122} )

Это диапазоны кодов ASCII, смотрите man ascii

Question 5

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

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

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

jT@s_Nx]gH<wL~W}

Или, в качестве альтернативы, чтобы сгенерировать несколько паролей:

cat /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

Question 6

Ни один из ответов до сих пор не является по-настоящему кросс-ОС.

Основные недостатки связаны с определением локали (в случае MacOS) и тем, что tr не может распознать интервалы символов (в случае Solaris).

Вам следует попробовать shlibs. Это свежая и действительно кросс-ОС.
Код для получения случайной строки – это shlibs str005 (./shlibs str005).

Получите случайную строку из 50 символов, включите знаки препинания, исключая цифры:

shlibs str005 50 -p -xd

Question 7

Для длин от 1 до 32 вы можете использовать uuidgen из libuuid или util-linux, просто замените <LENGTH> ниже:

uuidgen -r | tr -d '-' | head -c <LENGTH>

# или

random=$(uuidgen -r | tr -d '-') && echo "${random:0:<LENGTH>}"

Примечание: 6–7 из 128 бит предопределены и фиксированы.

Question 8

Этот ответ похож на метод /dev/urandom, но использует openssl rand.

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

Здесь я генерирую 1000 случайных байт для 10 алфавитно-цифровых символов a-zA-Z0-9:

LC_ALL=C tr -dc a-zA-Z0-9 < <(openssl rand 1000) | head -c10

Обратите внимание, что вышеуказанное использует подстановку процесса <(...). Если ваша оболочка этого не поддерживает, вы можете создать временный файл:

openssl rand 1000 > random.tmp
LC_ALL=C tr -dc a-zA-Z0-9 < random.tmp | head -c10

Question 9

Простая функция Bash, основанная на ответе @Gilles Quénot, которая использует SRANDOM и опцию grep -P для совместимых с Perl регулярных выражений.

Использование

randString;
# 4csibIlydNZxJGhV4cRWaeXvGC2XzVUUm58CJfDO1aUTELpA6c7X2YE2oBiosi99

randString 32;
# C1BIyf8TyxltBDKS207C8SOEjjfZDW1E

randString 48 '[abcd]{2}$';
# jsnVQpNDgfLy9BboryXmQYjxcSOh3YFWk6Xae3yxRdKrh6dc

Исходный код

randString()
(
    declare -r -- __length="${1-64}" __regex="$2";
    shift 2;

    declare -r -- c=(  
        {48..57}   # 0-9
        {65..90}   # A-Z
        {97..122}  # a-z
        # {33..47}   # !"#$%&'()*+,-./
        # {58..64}   # :;<=>?@
        # {91..96}   # [\]^_`
        # {123..126} # {|}~
    );

    declare -r -- cc="${#c[@]}";
    declare r="" i;

    while [[ "$r" == '' ]] || ! printf '%s' "$r" | grep -P -- "$__regex";
    do
        r="";

        for (( i=0; i < __length; i++ ));
        do
            declare h; h="$( printf -- '%x' "${c[RANDOM%cc]}"; )";
            printf -v t -- "\\x${h}";
            r+="$t";
        done
    done
)

Ответ или решение

Создание случайной строки, например, для паролей или имен пользователей, можно выполнить различными способами, используя стандартные инструменты Linux и Unix-подобных систем. В этой статье мы подробно рассмотрим несколько методов генерации случайных строк, включая указание необходимой длины строки, при этом уделяя внимание безопасности, поскольку важно, чтобы данные генерировались оффлайн, а не с использованием онлайн-сервисов.

Способы генерации случайных строк

Использование /dev/urandom и tr

Один из самых простых способов — это использование файла /dev/urandom, который предоставляет доступ к случайным байтам. С помощью команды tr можно отфильтровать ненужные символы. Например, для генерации строки длиной 13 символов, состоящей только из букв и цифр:
```
tr -dc A-Za-z0-9 < /dev/urandom | head -c 13; echo
```
Если вы хотите включить специальные символы, вы можете использовать следующий вариант:
```
tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~' < /dev/urandom | head -c 13; echo
```
Также можно указать использование локали для корректной обработки символов:
```
LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 13; echo
```
Использование openssl

Команда openssl предоставляет ещё один мощный способ генерации случайных строк:

Для случайной строки в формате base64:
```
openssl rand -base64 12
```
Или в формате hex:
```
openssl rand -hex 12
```
Использование pwgen

Если вам нужны легко запоминаемые пароли, команда pwgen является отличным вариантом. Например, для генерации 7 паролей длиной 13 символов можно выполнить:
```
pwgen 13 7
```
Для генерации более безопасных, менее запоминаемых паролей используйте параметр -s:
```
pwgen -s 13 7
```
Использование shuf

shuf также может быть полезным для создания случайных строк:
```
shuf -er -n20 {A..Z} {a..z} {0..9} | tr -d '\n'
```
Здесь -n20 указывает длину строки, и -r разрешает повторение символов.
Пользовательские скрипты на Bash

Вы можете создать пользовательский скрипт на Bash для генерации случайной строки фиксированной длины:
```
len=20
arr=( {33..126} ) arrcount=${#arr[@]}
for ((i=0; i<len; i++)); do
   printf \\$(printf '%03o' ${arr[RANDOM%arrcount]})
done; echo
```

Вывод

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

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

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

Вопрос или проблема

Использование

Исходный код

Ответ или решение

Способы генерации случайных строк

Вывод