จะสร้างรหัสผ่านที่คาดเดายากใน Linux ได้อย่างไร?

ฉันสงสัยว่าฉันสามารถสร้างรหัสผ่านที่คาดเดายากบน Linux (สำหรับผู้ใช้ปกติและผู้ดูแลระบบ) ได้อย่างไรและหากมีโปรแกรมเฉพาะที่จะทำเช่นนั้น

pwgenเป็นหนึ่งในหลาย ๆ โปรแกรมสำหรับสร้างรหัสผ่าน

โดยส่วนตัวแล้วฉันไม่ต้องการใช้ตัวสร้างรหัสผ่านเนื่องจากรหัสผ่านที่สร้างนั้นยากต่อการจดจำ แต่โซลูชันแบบพกพาตัวหนึ่งคือการใช้/ dev / urandom

การสร้างรหัสผ่านแบบสุ่มซึ่งไม่มีตัวอักษรพิเศษมีความยาว 10 ตัวอักษร:

$ cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 10` 
dyxJRKldvp

งานนี้ด้วยการคว้าไบต์จาก / dev / urandom ลบคนที่ไม่พอดีกับรูปแบบที่ระบุไว้ในtrคำสั่งและการ จำกัด ต่อไปอีก 10 headตัวอักษรที่มี

การสร้างรหัสผ่านแบบสุ่มซึ่งมีอักขระพิเศษมีความยาว 10 ตัวอักษร:

$ cat /dev/urandom | tr -dc 'a-zA-Z0-9-_!@#$%^&*()_+{}|:<>?=' | fold -w 10 | grep -i '[!@#$%^&*()_+{}|:<>?=]' | head -n 1
MSF4wj@vP0

วิธีนี้ใช้เทคนิคที่แตกต่างกันเล็กน้อยหลังจากtrลบไบต์ที่ไม่ต้องการออกไปเนื่องจากความคิดคือการบังคับให้มีอักขระพิเศษอย่างน้อยหนึ่งตัว สิ่งนี้ทำงานโดยใช้foldคำสั่งเพื่อตัดบรรทัดเป็นกลุ่ม 10 จากนั้นใช้grepเพื่อดึงข้อมูลบรรทัดที่มีอักขระพิเศษเท่านั้น headจากนั้นเรียกรหัสผ่านแรกที่ตรงตามข้อกำหนด

ฉันเขียนสคริปเล็ก ๆ นี้เมื่อไม่กี่ปีที่ผ่านมาและใช้มันตั้งแต่นั้นมา หากมีสิ่งใดก็เป็นที่น่าสนใจของการล่วงละเมิดและใช้คุณลักษณะที่น่ารักของทุบตีว่าผมโชคไม่ดีที่ไม่ค่อยเห็นในสคริปต์:printftypeset

#!/usr/bin/env bash
# Released into public domain
# Aaron Bockover, 2005
# http://abock.org

typeset -i length; length=$1
typeset -i rounds; rounds=$2
[ $rounds -lt 1 ] && rounds=1
[ $length -lt 1 ] && {
    echo "Usage: $0 <length> [<rounds>]" 2>/dev/null; exit 1;
}
for ((i=0; i < $rounds; i++)); do
    for ((j=0; j < $length; j++)); do
        set=$(($RANDOM % 20))
        if   [ $set -le 6 ];  then o=65; l=26; # 35% uppercase
        elif [ $set -le 13 ]; then o=97; l=26; # 35% lowercase
        elif [ $set -le 17 ]; then o=48; l=10; # 20% numeric
        elif [ $set -le 18 ]; then o=58; l=7;  # 10% symbolic
        elif [ $set -le 19 ]; then o=33; l=15; fi
        ord=$(($o + $RANDOM % $l))
        printf \\$(($ord / 64 * 100 + $ord % 64 / 8 * 10 + $ord % 8))
    done
    echo
done

ฉันยังต้องเพิ่มKeePassXซึ่งให้ตัวเลือกในการใช้ระบบเอนโทรปีในการสร้างรหัสผ่านที่แข็งแกร่งพร้อมคุณสมบัติที่ดีเพียงไม่กี่อย่าง - ทั้งหมดใช้ GUI นอกจากนี้ยังให้ตัวเลือกในการจัดการรหัสผ่านของคุณและบันทึกเป็นไฟล์ที่เข้ารหัส

นี่คือลักษณะของตัวสร้างรหัสผ่าน KPX ที่มีลักษณะดังนี้:

apg ไม่ใช่ตัวเลือกที่แย่ถ้าคุณต้องการรหัสผ่านที่สามารถจดจำได้ง่าย

; apg -m 16 -a 0 -t
ByajNudgolIston9 (Byaj-Nud-gol-Ist-on-NINE)
Af}ockhuecUjrak8 (Af-RIGHT_BRACE-ock-huec-Uj-rak-EIGHT)
IakijKadmomIvgig (Iak-ij-Kad-mom-Iv-gig)
NutIlOsyahodBeef (Nut-Il-Os-ya-hod-Beef)
anMechOybekazell (an-Mech-Oyb-ek-az-ell)
VumushCummAd{fra (Vum-ush-Cumm-Ad-LEFT_BRACE-fra)

หมายเหตุว่าตามนี้ , รหัสผ่านของคุณควรมีอย่างน้อย 12 ตัวยาว

ฉันใช้แบบสุ่ม แต่มีความหลากหลายเพียงพอสำหรับการโจมตีทั้งหมด ... รหัสผ่านหลักและรหัสผ่านสุดท้ายเพื่อสร้างรหัสผ่านอื่น นี่คือวิธีที่ฉันสร้างรหัสผ่านหลัก

echo -n "some seed" |  openssl dgst -binary -sha1 | base64 | sed -e 's/.\{4\}/& /g'

และเอาท์พุท

H1sI Wpbj JE2P CdVJ A1qb 9B/e u7M= 

ตอนนี้เพียงเลือกบางส่วนจากนั้นทำรหัสผ่านจัดเรียงใหม่ออกบางส่วนเพิ่มตัวอักษรหรือ 2 เพื่อให้ดีสุ่ม ตราบใดที่คุณจำเมล็ดพันธุ์ของคุณได้คุณสามารถสร้างใหม่และกู้คืนรหัสผ่านของคุณ (ตราบใดที่คุณไม่ได้ทำการดัดแปลงมากเกินไป)

pwgen เป็นเครื่องมือ cli ที่ยอดเยี่ยมที่ให้คุณระบุจำนวนพารามิเตอร์เพื่อตั้งค่าความซับซ้อนจำนวนคลาสอักขระของรหัสผ่านเพื่อสร้างความยาวเป็นต้น

นี่เป็นสคริปต์ใช้ครั้งเดียวสำหรับการสร้างวลีรหัสผ่าน XKCD /usr/share/dict/wordsไม่ใช่พจนานุกรมที่ยอดเยี่ยมสำหรับสิ่งนี้เนื่องจากคำส่วนใหญ่มีความยาว แต่สามารถใช้งานได้ง่าย สำหรับวลีรหัสผ่านที่ดีกว่าคุณสามารถใช้พจนานุกรมคำสั้น ๆ เช่นS / คีย์ One-Time Password รายการคำ

dict="/usr/share/dict/words"
max="`wc -l <"$dict"`" \
    perl -e '$count=4;
        $/=\4; while (<>) {
            print unpack('L') % $ENV{max} + 1, qq(\n); last unless --$count
        }' /dev/urandom | 
    while read n ; do 
        tail -n "+$n" "$dict" | head -1
    done

หากคุณเป็นผู้ใช้ GNOME และคุณต้องเก็บรหัสผ่านสำหรับบัญชีต่างๆของคุณคุณสามารถลองใช้เครื่องมือจัดการรหัสผ่านของRevelationได้ มันมีคุณสมบัติตัวสร้างรหัสผ่านพื้นฐานโดยที่คุณจะตั้งค่าความยาวรหัสผ่านและเลือกว่าจะรวมอักขระเครื่องหมายวรรคตอนนอกเหนือจากตัวอักษรและตัวเลขหรือไม่

แก้ไขฉันถ้าฉันผิด แต่: เท่าที่ฉันเข้าใจแล้วมันไม่มีทางที่คอมพิวเตอร์จะสามารถสร้างสตริงสุ่มขึ้นมาได้อย่างสมบูรณ์ ดังนั้นฉันจึงคิดตาม [และหวังว่ามันจะไม่ได้โง่อย่างสมบูรณ์]:

หากมีใครโยนลูกเต๋า 26 หน้าโอกาสในการโยนกล่าวว่า 26 คือ 1:26 กล่าวอีกนัยหนึ่ง: โอกาสที่จะโยน 26 คือประมาณ 0.04% เพิ่มเติมลูกเต๋าไม่มีหน่วยความจำและไม่มีข้อบกพร่อง ฉันคิดตามแนวคิดต่อไปนี้:

• รับลูกเต๋า 26 ชิ้นโดยแต่ละด้านตรงกับตัวอักษรของตัวอักษร
• รับสิบลูกเต๋าด้านที่แต่ละด้านตรงกับตัวเลขระหว่าง 0 และ 9
• พลิกเหรียญ
• head หมายถึง: โยนลูกเต๋าตัวอักษร
• ก้อยหมายถึง: โยนลูกเต๋าหมายเลข

โมเดลกระดาษที่จะพิมพ์:

• 10 ลูกเต๋าเข้าข้าง: http://www.korthalsaltes.com/model.php?name_en=decahedron
• 26 ลูกเต๋าด้าน: http://www.korthalsaltes.com/model.php?name_en=rhombicuboctahedron

หมายเหตุ : ฉันไม่ใช่ Math Pro และฉันคิดเรื่องนี้หลังจากอ่านบทความในนิตยสาร 2,600 ฉบับที่อธิบายเรื่องนี้ ฉันเพิ่งเพิ่มความคิดของตัวเองลงบนแนวคิดพื้นฐาน

นอกจากนี้ : ฉันสงสัยว่านี่ไม่ใช่เพียงตัวอย่างที่สมบูรณ์แบบสำหรับ ' เขียนแคร็กรหัสผ่านกำลังเดรัจฉานแรกของคุณ ' แต่คำถามของคุณทำให้ฉันมีเหตุผลที่สมบูรณ์แบบในการนำแนวคิดนี้มาพูดคุย

ฉันได้เพิ่มชื่อแทนสองรายการในไฟล์. zshrc.local ของฉันเพื่อสร้างรหัสผ่านที่คาดเดายาก

ที่แรกก็คือ:

alias pw.graph="cat /dev/urandom | tr -dc '[:graph:]' | fold -w 1000 | perl -pe 's/(.)(?=.*?\1)//g' | head -n 5"

ผลลัพธ์ของการพิมพ์ pw.graph คือห้าบรรทัดของตัวละครทุกตัวที่สามารถพิมพ์ลงบนคีย์บอร์ดยกเว้นสเปซบาร์:

/d=|&mRq!g$QaNZ'L;CfEli,D3\)*h-jkerzv?{y"_Ic(0BtxJwF59:@G}KV1X2o>S~[#]s+W%A.<6bpTO^uP7U4HMYn`8
RIdW87{a4O3][?&rTn=m/:Y`_u*hqy2c%s@!ZPM$5to1f-.U9ClK,)'jDi0"pw>EzN^|gX~BSAJk\VFG(H<bx}+Q6#vL;e
s^H@yEo/X$|d?_jw7-n'l>m"Cb\W5.tTe0APB1D!#69[p+(8x}F&~RM`q3Q%vhfOiUZz]ucJk:)*agGV;=NY4{,K2SLrI<
$/t|!s}og5u:X~hcJUyYHf>;l<zDedL`.T*K8]CBSW[(xw+Mm^E3r16b-97%'@jVR{ZG#0p4AP=,I?\n&"a)vqNkQ2iO_F
,7n|^Y\%MpeBqvhI3mE<9zPS/~+sU`4ZoCWl&uxd'ft"kjcOy0X!{a-T_6RKiVg5Hb21D)w>@*N8;A[(rLG=$Q:.#]FJ?}

ประการที่สองคือ:

alias pw.alnum="cat /dev/urandom | tr -dc '[:alnum:]' | fold -w 1000 | perl -pe 's/(.)(?=.*?\1)//g' | head -n 5"

ผลลัพธ์ของการพิมพ์ pw.alnum คือตัวอักษรและตัวเลขที่พิมพ์ได้ทุกตัวทั้งตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก:

E6wgCfVBbXjyzYQ8USKl79LqPih0e5mvGrNHd3osaW2OxkJ1RM4nFTtcuZIpDA
GTvQON1dsZSpJmegBMK6bqnEciU7k0AoV2H4Wh53zr9YRfLlDxywXItu8CjPFa
6u1Db9MfyBApZdU7gqoV2PGwH5LcxWi3JNj8nkQCIThezSlYEXsOtrmF04KvaR
VFrsGwI9yAmabEnlRTKgZO23vUq4f6LHkzQP7tMjNW8ph1exuDoBCXSd50JciY
G3r6Em5tlfjQARJx9gWHes7bCVwkzcP48KaSIXyUFBMLqT0op1uDNdih2nYZOv

ฉันมักจะใช้ pw.graph และคัดลอกส่วนของบรรทัดแบบสุ่ม รหัสผ่านบางตัวไม่อนุญาตให้ใช้สัญลักษณ์ดังนั้นฉันจึงใช้ส่วนหนึ่งของ pw.alnum

ฉันใช้สิ่งนี้บันทึกเป็นไฟล์. html:

<script>
var keylist="abcdefghijklmnopqrstuvwxyzABCEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*_"
var temp=''

function generatepass(plength){
temp=''
for (i=0;i<plength;i++)
temp+=keylist.charAt(Math.floor(Math.random()*keylist.length))
return temp
}

function populateform(enterlength){
document.pgenerate.output.value=generatepass(enterlength)
}
</script>

<form name="pgenerate">
<input type="text" size=32 name="output">
<input type="button" value="Generate Password" onClick="populateform(this.form.thelength.value)"><br />
<b>Password Length:</b> <input type="text" name="thelength" size=3 value="32">
</form>