Rasgele bir dize nasıl oluşturulur?

Rasgele bir dize (örneğin şifreler, kullanıcı adları, vb.) Oluşturmak istiyorum. İstenilen uzunluğu belirlemek mümkün olmalıdır (örneğin 13 karakter).

Hangi araçları kullanabilirim?

(Güvenlik ve gizlilik nedenleriyle, bir web sitesinde çevrimiçi olmanın aksine, dizgelerin çevrimdışı oluşturulması tercih edilir.)

En sevdiğim yol, istenmeyen karakterleri silmek için /dev/urandombirlikte kullanmaktır tr. Örneğin, yalnızca rakam ve harfleri almak için:

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

Alternatif olarak, OWASP şifresi özel karakterler listesinden daha fazla karakter eklemek için :

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

trGirdiyle ilgili şikayetlerde sorun yaşıyorsanız , şöyle eklemeyi deneyinLC_ALL=C :

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

Rasgele bir şifre oluşturmak için kullanabilirsiniz pwgen:

pwgen, rastgele, anlamsız ama belirgin şifreler üretir. Bu parolalar yalnızca küçük harfler veya büyük ve küçük harfler karışık veya içine atılan rakamlar içerir. Büyük harfler ve rakamlar, yalnızca kelimeyi ezberlerken konumlarını hatırlamayı kolaylaştıracak şekilde yerleştirilir.

13 uzunluğunda 7 şifre oluşturun:

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

Yorumlarda belirtildiği gibi, -sargümanı kullanarak entropiyi azaltmaktan kaçınabilirsiniz (yani daha güvenli, tamamen rasgele fakat hatırlanması zor şifreler oluşturabilirsiniz):

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

Rasgele kullanıcı adları oluşturmak için kullanabileceğiniz gpw:

Bu paket belirgin şifreler oluşturur. Beslediğiniz sözlüklerden alınan üç harfli kombinasyonların (trigraph) istatistiklerini kullanır.

13 uzunluğunda 7 şifre (kullanıcı adı) oluşturun:

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

Şifreyi kullanıyorum, opensslşifreli İsviçre çakısı.

openssl rand -base64 12

veya

openssl rand -hex 12

İşte böyle yapıyorum. 10 karakter rastgele dize oluşturur. "String" i başka dize işleme araçlarıyla değiştirerek optimize edebilirsiniz.

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

Kullandığım her dağıtımın içine yerleştirilmiş standart Linux araçlarıyla mümkün olan en yüksek entropiye sahip şifre oluşturmak için:

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

Bu, tüm ASCII yazdırılabilir karakterlerini çıktılar - 32 (boşluk) ile 126 (tilde, ~). Şifre uzunluğu head' -cflag ' ile kontrol edilebilir . İçinde başka olası karakter kümeleri de vardır tr(boşluk içermemesi, sadece 33-126 karakterleri kullanılması [:graph:]).

İstediğiniz rastgelelik seviyesine bağlı olarak, basitçe bash (ayrıca zshve kshmuhtemelen başkaları) yerleşik $RANDOMdeğişkenine gidebilirsiniz :

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

Doğrudan okuma yöntemleri /dev/urandomçok basittir, ancak tamamlama uğruna şunları da kullanabilirsiniz $RANDOM:

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

Önemli : Bu çözüm yalnızca alfabenin ilk 10 harfini kullanarak rasgele dizeler üretecektir. Bunun sizin için yeterli olup olmadığı, bunun için neye ihtiyacınız olduğuna bağlıdır.

Pablo Repetto'dan ilham aldım . Hatırlanması kolay bir çözümle geldim :

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

-z çoklu hat çıkışını önler

-e sonucu yankı

-r herhangi bir karakterin birden çok kez görünmesine izin verir

-n20 20 karakter uzunluğunda rasgele dize

{A..Z} {a..z} {0..9} char sınıflarına izin verildi

shuf linux coreutils'in bir parçasıdır ve yaygın olarak bulunur veya en azından port edilmiştir.

Diğerinden en fazla 100 bayt nasıl cevap @Brandin yorumunda açıkladı /dev/urandomkullanarak head -c 100. Bunu yapmanın başka bir yolu ile dd:

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

2>/dev/nullSonunda ddkomuta çıkışı "/ ... kayıtları dışarı ... kayıtları" bastırmaktır.

Bu iki yöntem arasındaki önemli avantajların / dezavantajların farkında değilim.

trGirdiden şikayetçi olmak için iki yöntemde de bir sorun vardı . Ben ikili girdi alınmasını hoşuna gitmediği için bu düşünce ve dolayısıyla birinci filtreleme önerdi /dev/randomile iconv -c -t US. Ancak, Gilles benim için işe yarayan farklı bir teşhis ve çözüm önerdi:

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

APG bazı Linux dağıtımlarında varsayılan olarak bulunur.

Özel, Sayısal, Büyük ve Düşük alt gruplarında 5 ile 10 arasında parola oluşturmak için komut:

apg -MSNCL -m 5 -x 10

Ve döner

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

Yorumda @landroni tarafından söylendiği gibi.

md5Tam olarak bu amacı olan araçlardan birini kullanabilirsiniz . Tamamen rastgele bir şifre oluşturma durumunda kullanabilirsiniz md5pass. Kullanımı çok basit ve çok faydalı bir araçtır, çünkü "normal metni", bir "tuz" ile birlikte kullanıp aynı şifrenin daha sonra kurtaracağınız şifreyi atlamak veya alternatif olarak tamamen almak isteyebilirsiniz her zaman rastgele şifre. Genel kullanım:

md5pass [password] [salt]

nerede passwordrastgele dize yapımı için kullanılacak ve seçilmiş bir kelimedir saltkullanılacak byte atlamak demek. Bunun gibi, böyle:

md5pass word

$1$.MUittVW$j.XDTF1QRnxqFdXRUiSLs0

Bu, kullanmanız için "rastgele bir sıra" şifresi oluşturacaktır. Hayır kullanırsanız salt, daha sonra bu aynı dizgiyi yeniden oluşturamayabilirsiniz.

Ancak böyle bir şey kullanırsanız salt:

md5pass word 512

$1$512$.0jcLPQ83jgszaPT8xzds0

daha sonra, eğer kelimeyi başlangıçta tanımlanmışsa aynı tuzla (veya atlayarak) birlikte kullanırsanız, kurtarabileceğiniz bir dizi oluşturabilirsiniz.

xxdHem Linux hem de OS'de çalışan uzunluğu (via ile) belirtmek için komutu kullanın . https://www.howtoforge.com/linux-xxd-command/

xxd -l16 -ps /dev/urandom

Bu iki komut sırasıyla rasgele şifreler ve şifreler oluşturur.

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

Şifre üreticisi, şifrenin kullanmasını istediğiniz tüm karakterleri, satır başına bir karakter ve tam olarak birer kez içeren bir file_with_characters gerektirir. Dosya boş satırlar içermemeli ve satırlar yeni satır sonlandırılmalıdır.

Parola oluşturucu, parolanın kullanmasını istediğiniz tüm sözcükleri, satır başına bir kelime ve her biri tam olarak bir kez içeren bir file_with_words gerektirir. Dosya boş satırlar içermemeli ve satırlar yeni satır sonlandırılmalıdır.

--Head-count seçeneği, parolanın uzunluğunu - karakterlerde - veya parola - sözcüklerinde belirtir.

MakOS'ta tr tr / udrand boru tesisatının işe yaramadığını gördüm. İşte başka bir yol:

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

Kullanırım:

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

Bu bana 57 olası karakter verir. Dize, karakterleri ( ) ayırt etmek zor kopyalandığında yapıştırılabilir (kaldırılabilir +ve \) veya yazdırılabilir ve yeniden yazdırılabilir I1lO0.

• 44 karakter bana verir: log ₂ (57 ⁴⁴ )> 256.64 bit entropi
• 22 karakter bana verir: log ₂ (57 ²² )> 128.32 entropi

Bunu sevdim çünkü:

• komut yazmak için basit ve unutulmaz
• standart sistem araçlarını kullanır - fazladan ikili dosya yok
• fazla rastgelelik "israfı" yapmaz (doğrudan tr'e bağlanan çözümler için ~% 24 - aldığı rastgele bitlerin% 89'unu kullanır)
• 22 ve 44 karakter, iki sınır değerin ortak gücünü oldukça iyi eşler
• çıktı, minimum insan hata oranlarıyla kolayca seçilebilir ve yapıştırılabilir veya yazdırılabilir ve yeniden yazdırılabilir
• md5sum / sha1sum, vb. gibi hex kodlu kodlardan (22 ve 44 yerine 32 ve 64) daha kısa çözümler

Kredi https://unix.stackexchange.com/a/230676/9583 ve benim ilk ilham özellikle yorumlar.

"Bir şeyi iyi yapan birçok küçük araç" un Unix felsefesi bu durumda size çok iyi hizmet ediyor.

• /dev/urandom(yazdırılamaz karakterleri içeren) rastgele bir "bayt" akışıdır.
• base64 Bayt verilerini kodlar [A-Za-z0-9/+] (tamamen yazdırılabilir)
• dd argüman olarak verilen değiştiricileri uygulayarak girdiyi çıktıya kopyalar (blok boyutu ve blok sayısını içerebilir)

OSX

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

Linux

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

Notlar:

• Bir karakter alt kümesine ihtiyacınız varsa, boruya bir değiştirici ekleyebilirsiniz.
  • Ör: tr -d '[A-Z/+]'büyük harflerden kurtulmak için +ve/
• İhtiyacınız olan bsuzunlukta (blok ebadını) ayarlayabilirsiniz .
• Linux'ta base64varsayılan olarak 76 sütuna kaydırılır ve -w0bunu istemediğiniz sürece sıfırlanması gerekir .

Her zamanki şifremi bir şifre oluşturmak için katkıda bulunmak istiyorum

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

Şifrenin uzunluğunu yapılandırmak için, cut komutundaki sayıyı istediğiniz uzunluğa, örneğin 24 karaktere değiştirin.

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

0 ya da O, 1 ya da l'yi karıştırmak istemiyor musunuz? Başka biriyle filtreleyintr

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

Kişisel olarak şifreyi asla özel bir karakterde seçmem, bu yüzden sadece [:alnum:]şifre oluşturucum için seçiyorum

secpwgenAlpine Linux’ta bakım yapıyorum ve kaynakları Github'ımda tutuyorum .

Rasgele dizeler üretebilir veya ifadeleri biter:

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 karakter rastgele bir dize oluşturmak için kullanacağınız:

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.

Kullanıcıların bir şifreyi hatırlamaları için diceware ifadelerini kullanın:

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

Ben şahsen:

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

Çok güvenli bir şifre yolum (pw uzunluğu 16'dır):

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

Örnek sonuç:

jT@s_Nx]gH<wL~W}

Veya alternatif olarak, birden çok şifre oluşturmak için:

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

Örnek sonuç:

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*

Biraz daha az güvenli (daha küçük karakter kümesi):

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

Örnek sonuç:

rJqYxYZLOTV+A45w
PUKQ+BoBf6yfZw5m
+LRfpsN9CsLRiN8V
yMS6zDpL6NHmG17s
yTUWPG7Rum97schi
cognvjVwaKaAyPRK

Bunu başarmanın süper kolay ve basit (muhtemelen aradığınızdan daha basit) yolu, belirli bir aralıkta rastgele bir sayı oluşturmak, bu sayıyı eşdeğer ASCII karakterine dönüştürmek ve onu bir dizenin sonuna eklemek olacaktır. .

İşte Python'da temel bir örnek:

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: yorum ekledi ve birden çok şifre oluşturmak ve bunları bir dosyaya yazmak için kod ekledi

Bu komutu istiyorum:

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

Http://passwordsgenerator.net/ adresine gidip 2048 karaktere kadar rastgele karakter dizileri oluşturmaya, büyük harf, küçük harf, 0 - 9 rakamlar, noktalama işaretleri veya herhangi bir kombinasyon seçmeye izin verir.