จะสร้างสตริงแบบสุ่มได้อย่างไร

ฉันต้องการสร้างสตริงแบบสุ่ม (เช่นรหัสผ่านชื่อผู้ใช้ ฯลฯ ) มันเป็นไปได้ที่จะระบุความยาวที่ต้องการ (เช่น 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:

แพ็คเกจนี้สร้างรหัสผ่านที่ออกเสียงได้ มันใช้สถิติของชุดค่าผสมสามตัวอักษร (trigraphs) ที่นำมาจากพจนานุกรมที่คุณป้อน

สร้าง 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 ตัวอักษร คุณสามารถปรับให้เหมาะสมด้วยการแทนที่ "fold" ด้วยเครื่องมือประมวลผลสตริงอื่น ๆ

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's -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 ตัวแรกของตัวอักษร ไม่ว่าจะเพียงพอหรือไม่นั้นขึ้นอยู่กับสิ่งที่คุณต้องการ

ได้รับแรงบันดาลใจจาก Pablo Repetto ฉันสิ้นสุดด้วยวิธีแก้ปัญหาที่ง่ายต่อการจดจำ

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

-z หลีกเลี่ยงเอาต์พุตหลายบรรทัด

-e echo ผลลัพธ์

- อนุญาตให้ตัวละครใด ๆ ที่จะปรากฏหลายครั้ง

-n20 สตริงสุ่มที่มีความยาว 20 อักขระ

{A..Z} {a..z} {0..9} ชั้นเรียนถ่านที่ได้รับอนุญาต

shuf เป็นส่วนหนึ่งของ 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คำสั่งในการปราบปราม "... ระเบียนใน / ... บันทึก" เอาท์พุท

ฉันไม่ทราบถึงข้อดี / ข้อเสียที่สำคัญระหว่างสองวิธีนี้

ฉันมีปัญหากับทั้งสองวิธีในการtrร้องเรียนเกี่ยวกับอินพุต ฉันคิดว่านี้เป็นเพราะมันไม่ชอบที่ได้รับการป้อนข้อมูลไบนารีและด้วยเหตุนี้ปัญหาการกรองครั้งแรกด้วย/dev/random iconv -c -t USอย่างไรก็ตาม Gilles แนะนำการวินิจฉัยและการแก้ปัญหาที่แตกต่างกันซึ่งทำงานสำหรับฉัน:

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

APG ถูกรวมโดยดีฟอลต์ในการกระจาย Linux บางตัว

ในการสร้างรหัสผ่านจากขนาด 5 ถึง 10 ในชุดย่อยพิเศษ, ตัวเลข, ตัวพิมพ์ใหญ่และตัวพิมพ์เล็กคำสั่งคือ:

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 และ OS 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 ไปยัง 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% ของบิตสุ่มที่ได้รับ vs ~ 24% สำหรับวิธีแก้ปัญหาโดยตรงกับท่อ)
• ตัวอักษร 22 และ 44 จับคู่กันอย่างมาก (เหนือระดับแม้กระทั่ง) พลังร่วมของสองเบรกพอยต์
• สามารถเลือกและวางเอาต์พุตหรือพิมพ์และพิมพ์ซ้ำได้อย่างง่ายดายโดยมีอัตราความผิดพลาดน้อยที่สุด
• สั้นกว่า hex ที่เข้ารหัส (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

ลินุกซ์

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:]รหัสผ่านของฉัน

ฉันจะรักษาsecpwgenในอัลไพน์ลินุกซ์และให้แหล่งที่มาบน Github

มันสามารถสร้างสตริงสุ่มหรือวลี 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

ในการสร้างสตริงสุ่ม 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}

หรืออีกวิธีหนึ่งในการสร้างรหัสผ่านหลายรายการ:

cat / dev / urandom | tr -cd [: กราฟ:] | 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 เครื่องหมายวรรคตอนหรือชุดค่าผสมอื่น ๆ