Bagaimana cara menghasilkan string acak?

Saya ingin membuat string acak (misalnya kata sandi, nama pengguna, dll.). Seharusnya dimungkinkan untuk menentukan panjang yang dibutuhkan (mis. 13 karakter).

Alat apa yang bisa saya gunakan?

(Untuk alasan keamanan dan privasi, sebaiknya string dihasilkan secara off-line, sebagai lawan online di situs web.)

Cara favorit saya untuk melakukannya adalah dengan menggunakan /dev/urandombersama truntuk menghapus karakter yang tidak diinginkan. Misalnya, untuk mendapatkan hanya angka dan huruf:

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

Atau, untuk memasukkan lebih banyak karakter dari daftar karakter khusus kata sandi OWASP :

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

Jika Anda memiliki beberapa masalah dengan trmengeluh tentang input, coba tambahkanLC_ALL=C seperti ini:

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

Untuk menghasilkan kata sandi acak, Anda dapat menggunakan pwgen:

pwgen menghasilkan kata sandi acak, tidak berarti tetapi dapat diucapkan. Kata sandi ini hanya berisi huruf kecil, atau campuran huruf besar dan kecil, atau angka dilemparkan. Huruf besar dan digit ditempatkan dengan cara yang memudahkan mengingat posisi mereka ketika hanya menghafal kata.

Hasilkan 7 kata sandi dengan panjang 13:

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

Seperti yang disebutkan dalam komentar, Anda dapat menghindari pengurangan entropi dengan menggunakan -sargumen (yaitu menghasilkan kata sandi yang lebih aman, benar-benar acak tetapi sulit diingat):

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

Untuk menghasilkan nama pengguna acak, Anda dapat menggunakan gpw:

Paket ini menghasilkan kata sandi yang bisa diucapkan. Ini menggunakan statistik kombinasi tiga huruf (trigraph) yang diambil dari kamus apa pun yang Anda masukkan.

Hasilkan 7 kata sandi (nama pengguna) dengan panjang 13:

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

Saya menggunakan opensslperintah, pisau kriptografi tentara swiss.

openssl rand -base64 12

atau

openssl rand -hex 12

Begini caranya, saya melakukannya. Ini menghasilkan 10 karakter string acak. Anda dapat mengoptimalkannya dengan mengganti "lipatan", dengan alat pengolah string lainnya.

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

Untuk menghasilkan kata sandi dengan entropi setinggi mungkin dengan alat Linux standar yang dibangun ke dalam setiap distribusi yang saya gunakan:

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

Ini menghasilkan semua karakter ASCII yang dapat dicetak - dari 32 (spasi) hingga 126 (tilde, ~). Panjang kata sandi dapat dikontrol dengan bendera head's -c. Ada juga set karakter lain yang mungkin ada tr(tidak termasuk spasi, hanya karakter 33-126, gunakan [:graph:]).

Bergantung pada tingkat keacakan yang Anda inginkan, Anda bisa dengan variabel bawaan bash's (juga zshdan ksh, mungkin orang lain) $RANDOM:

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

Metode membaca langsung dari /dev/urandomjauh lebih sederhana, tetapi demi penyelesaian, Anda juga dapat menggunakan $RANDOM:

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

Penting : solusi ini hanya akan menghasilkan string acak menggunakan 10 huruf pertama dari alfabet. Apakah itu cukup atau tidak untuk Anda tergantung pada untuk apa Anda membutuhkannya.

Terinspirasi oleh Pablo Repetto Saya akhirnya dengan solusi yang mudah diingat ini :

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

-z menghindari multi-line output

-e gema hasilnya

-r izinkan karakter apa saja muncul beberapa kali

-n20 String acak dengan panjang 20 karakter

{A..Z} {a..z} {0..9} kelas char diizinkan

shuf adalah bagian dari coreutils linux dan banyak tersedia atau paling tidak porting.

@Brandin menjelaskan dalam komentar ke jawaban lain bagaimana cara mendapatkan paling banyak 100 byte dari /dev/urandompenggunaan head -c 100. Cara lain untuk melakukan ini adalah dengan dd:

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

Di 2>/dev/nullakhir ddperintah adalah untuk menekan output "... records in / ... records out".

Saya tidak mengetahui adanya keuntungan / kerugian substansial antara kedua metode ini.

Saya punya masalah dengan kedua metode trmengeluh tentang input. Saya pikir ini adalah karena tidak suka menerima masukan biner, dan karenanya disarankan penyaringan pertama /dev/randomdengan iconv -c -t US. Namun, Gilles menyarankan diagnosis dan solusi yang berbeda, yang bekerja untuk saya:

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

APG disertakan secara default pada beberapa distribusi Linux.

Untuk menghasilkan kata sandi dari ukuran 5 hingga 10 di himpunan bagian Khusus, Numerik, Modal dan Bawah, perintahnya adalah:

apg -MSNCL -m 5 -x 10

Dan kembali

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

Seperti yang dikatakan oleh @landroni dalam komentar.

Anda dapat menggunakan salah satu md5alat yang memiliki tujuan ini. Dalam hal membuat kata sandi yang sepenuhnya acak, Anda dapat menggunakan md5pass. Ini adalah alat yang sangat sederhana untuk digunakan dan sangat membantu, karena Anda dapat menggunakan "teks normal" bersama dengan "garam" untuk melompati konstruksi kata sandi yang sama yang dapat Anda pulihkan setelahnya, atau Anda mungkin ingin mendapatkan yang sepenuhnya kata sandi acak sepanjang waktu. Penggunaan umum adalah:

md5pass [password] [salt]

di mana passwordadalah kata yang dipilih yang akan digunakan untuk pembangunan string acak dan saltmerupakan lompatan byte yang akan digunakan. Seperti ini:

md5pass word

$1$.MUittVW$j.XDTF1QRnxqFdXRUiSLs0

Ini akan membuat kata sandi "urutan acak" untuk Anda gunakan. Jika Anda tidak menggunakan salt, maka Anda mungkin tidak dapat membuat ulang string yang sama ini setelahnya.

Namun jika Anda menggunakan saltseperti ini:

md5pass word 512

$1$512$.0jcLPQ83jgszaPT8xzds0

maka Anda dapat membuat urutan yang dapat Anda pulihkan jika Anda menggunakan kata tersebut dalam hubungannya dengan garam yang sama (atau lompatan) jika kata aslinya didefinisikan.

Gunakan xxdperintah untuk menentukan panjang (via -l) yang berfungsi di Linux dan OS. https://www.howtoforge.com/linux-xxd-command/

xxd -l16 -ps /dev/urandom

Kedua perintah ini masing-masing menghasilkan kata sandi dan kata sandi acak.

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

Pembuat kata sandi memerlukan file_with_characters yang berisi semua karakter yang Anda inginkan untuk menggunakan kata sandi, satu karakter per baris, dan masing-masing tepat satu kali. File tidak boleh mengandung baris kosong, dan baris harus diakhiri dengan baris baru.

Generator frasa sandi memerlukan file_with_words yang berisi semua kata yang Anda inginkan frasa sandi, satu kata per baris, dan masing-masing tepat satu kali. File tidak boleh mengandung baris kosong, dan baris harus diakhiri dengan baris baru.

Opsi --head-count menentukan panjang kata sandi - dalam karakter - atau frasa sandi - dalam kata-kata.

Saya telah menemukan bahwa pemipaan / dev / urandom ke tr di macOS tidak berfungsi. Inilah cara lain:

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

Saya menggunakan:

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

Ini memberi saya 57 kemungkinan karakter. String dapat disalin-tempel (dihapus +dan \) atau dicetak dan diketik ulang karena karakter yang sulit dibedakan ( I1lO0) telah dihapus.

• 44 karakter memberi saya: log ₂ (57 ⁴⁴ )> 256,64 bit entropi
• 22 karakter memberi saya: log ₂ (57 ²² )> 128,32 bit entropi

Saya suka ini karena:

• perintahnya mudah diketik dan mudah diingat
• menggunakan alat sistem standar - tidak ada binari tambahan
• tidak "membuang" banyak keacakan (menggunakan 89% dari bit acak yang diterimanya vs ~ 24% untuk solusi yang langsung disalurkan ke tr)
• 22 dan 44 karakter berpasangan dengan cukup baik (tepat di atas genap) kekuatan umum dari dua breakpoints
• output dapat dengan mudah dipilih dan ditempelkan atau dicetak dan diketik ulang dengan tingkat kesalahan manusia minimal
• lebih pendek dari hex solusi yang dikodekan (32 dan 64 bukannya 22 dan 44) seperti md5sum / sha1sum, dll.

Penghargaan untuk https://unix.stackexchange.com/a/230676/9583 dan terutama komentar untuk inspirasi awal saya.

Filosofi Unix tentang "banyak alat kecil yang melakukan satu hal dengan baik" sangat membantu Anda dalam hal ini.

• /dev/urandomadalah aliran acak "byte" (yang termasuk karakter yang tidak dapat dicetak)
• base64 mengkodekan data byte ke [A-Za-z0-9/+] (yang sepenuhnya dapat dicetak)
• dd menyalin input ke output yang menerapkan pengubah yang diberikan sebagai argumen (yang dapat mencakup ukuran blok dan jumlah blok)

OSX

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

Linux

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

Catatan:

• Jika Anda membutuhkan subset karakter, Anda dapat memasukkan pengubah ke dalam pipa.
  • Mis: tr -d '[A-Z/+]'untuk menghilangkan huruf kapital dan +dan/
• Anda dapat mengatur bs(ukuran blok) dengan panjang berapa pun yang Anda butuhkan.
• Di Linux, base64bungkus menjadi 76 kolom secara default dan harus diatur ulang -w0kecuali Anda menginginkannya.

Saya ingin berkontribusi perintah biasa saya untuk menghasilkan kata sandi

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

Untuk mengkonfigurasi panjang kata sandi, ubah angka dalam perintah potong dengan panjang yang Anda perlukan, misalnya, 24 karakter

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

Tidak ingin membingungkan 0 atau O, 1 atau l? Saring dengan yang laintr

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

Saya pribadi tidak pernah memilih karakter khusus dalam kata sandi, itu sebabnya saya hanya memilih [:alnum:]untuk pembuat kata sandi saya

Saya memelihara secpwgendi Alpine Linux & menyimpan sumber di Github saya .

Ini dapat menghasilkan string acak atau frasa 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

Untuk menghasilkan string acak 13 karakter, Anda akan menggunakan:

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.

Bagi pengguna untuk mengingat kata sandi, gunakan frasa diceware:

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

Saya pribadi suka:

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

Cara saya untuk kata sandi yang sangat aman (di mana 16 adalah panjang pw):

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

Contoh hasil:

jT@s_Nx]gH<wL~W}

Atau sebagai alternatif, untuk menghasilkan banyak kata sandi:

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

Contoh hasil:

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*

Sedikit kurang aman (rangkaian karakter yang lebih kecil):

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

Contoh hasil:

rJqYxYZLOTV+A45w
PUKQ+BoBf6yfZw5m
+LRfpsN9CsLRiN8V
yMS6zDpL6NHmG17s
yTUWPG7Rum97schi
cognvjVwaKaAyPRK

Cara super mudah dan sederhana (mungkin lebih sederhana daripada yang Anda cari) untuk mencapai ini adalah dengan menghasilkan angka acak dalam rentang yang diberikan, mengonversi angka itu ke karakter ASCII yang setara, dan menambahkannya ke akhir string .

Berikut ini contoh dasar dalam 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: menambahkan komentar, dan menambahkan kode untuk menghasilkan banyak kata sandi dan menulisnya ke file

Saya ingin perintah ini:

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

Aku pergi, ke http://passwordsgenerator.net/ ia memungkinkan menghasilkan string karakter acak hingga 2048 karakter, memilih huruf besar, huruf kecil, angka 0 hingga 9, tanda baca, atau kombinasi apa pun.