लिनक्स में मजबूत पासवर्ड कैसे बनाएं?

24

मुझे आश्चर्य है कि मैं लिनक्स (सामान्य और व्यवस्थापक दोनों उपयोगकर्ताओं के लिए) पर मजबूत पासवर्ड कैसे बना सकता हूं और अगर ऐसा करने के लिए विशिष्ट कार्यक्रम हैं।

security users password

— Gasuma
स्रोत

23

पासवर्ड उत्पन्न करने के लिए pwgen कई कार्यक्रमों में से एक है

— theotherreceive
स्रोत

16

व्यक्तिगत रूप से, मैं पासवर्ड जनरेटर का उपयोग नहीं करना पसंद करता हूं क्योंकि उत्पन्न पासवर्ड को याद रखना बहुत मुश्किल है, लेकिन एक पोर्टेबल समाधान का उपयोग करना है / देव / आयामी

यादृच्छिक पासवर्ड बनाना जिसमें कोई विशेष वर्ण नहीं है, 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फिर आवश्यकताओं को पूरा करने वाला पहला पासवर्ड प्राप्त करता है।

— हेमंत
स्रोत

1

तुम भी ( ) के [:print:]लिए उपयोग कर सकते हैं , अगर आप थोड़ा पागल हैं। समस्या तब आपके कीबोर्ड पर उपलब्ध प्रतीकों की होगी ...trtr -dc '[:print:]'

— lgeorget

11

मैंने इस छोटी सी स्क्रिप्ट को कुछ साल पहले लिखा था और तब से इसका इस्तेमाल कर रहा हूं। यदि कुछ भी हो, तो यह printfBASH की एक दिलचस्प विशेषता है और इसका उपयोग करता है जिसे मैं दुर्भाग्य से स्क्रिप्ट में शायद ही कभी देख पाऊं typeset:।

#!/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

— हारून बोकओवर
स्रोत

स्क्रिप्ट हारून के लिए धन्यवाद!

— गैसुमा

4

मैं KeePassX भी जोड़ूंगा जो आपको कुछ अच्छे फीचर्स के साथ मजबूत पासवर्ड बनाने के लिए सिस्टम एन्ट्रापी का उपयोग करने का विकल्प देता है - सभी GUI के साथ। यह आपको अपने पासवर्ड को प्रबंधित करने और उन्हें एन्क्रिप्टेड फ़ाइल में सहेजने का विकल्प भी देता है।

यह कैसे KPX पासवर्ड जनरेटर इंटरफ़ेस की तरह दिखता है:

यहाँ छवि विवरण दर्ज करें

— pootzko
स्रोत

3

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 अक्षर होना चाहिए।

— सरदारथियन - मोनिका को बहाल करना
स्रोत

2

मैं एक गैर यादृच्छिक का उपयोग करता हूं, लेकिन सभी हमले के उद्देश्यों के लिए पर्याप्त विविध है ... मास्टर पासवर्ड, और अन्य पासवर्ड उत्पन्न करने के लिए अंतिम पास । यहां बताया गया है कि मैंने मास्टर पासवर्ड कैसे बनाया।

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

और आउटपुट

H1sI Wpbj JE2P CdVJ A1qb 9B/e u7M=

अब बस कुछ वर्गों को चुनें और एक पासवर्ड बनाएं, उन्हें फिर से व्यवस्थित करें, कुछ को छोड़ दें, एक चरित्र या 2 जोड़ें, ताकि यह यादृच्छिक के रूप में अच्छा हो सके। जब तक आप अपने बीज को याद कर सकते हैं तब तक आप इसे पुन: प्राप्त कर सकते हैं, और अपना पासवर्ड पुनर्प्राप्त कर सकते हैं (जब तक आप बहुत अधिक संशोधन नहीं करते हैं)

— xenoterracide
स्रोत

1

pwgen एक अद्भुत छोटी सी cli उपकरण है जो आपको जटिलता, वर्ण वर्गों की संख्या, उत्पन्न करने के लिए पासवर्ड की संख्या, आदि निर्धारित करने के लिए कई मापदंडों को निर्दिष्ट करता है।

— Slashdot
स्रोत

1

यहाँ XKCD- शैली पासफ़्रेज़ उत्पन्न करने के लिए एक-बंद स्क्रिप्ट है । /usr/share/dict/wordsअधिकांश शब्दों के लंबे होने के कारण इसके लिए एक बढ़िया शब्दकोश नहीं है, लेकिन यह आसानी से उपलब्ध है। अच्छे पासफ़्रेज़ के लिए आप कुछ शब्दों के शब्दकोश जैसे कि S / Key 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

— Jander
स्रोत

0

यदि आप एक गनोम उपयोगकर्ता हैं और आपको अपने विभिन्न खातों के लिए पासवर्ड स्टोर करने की आवश्यकता है, तो आप रहस्योद्घाटन पासवर्ड प्रबंधक की कोशिश कर सकते हैं। इसमें एक बुनियादी पासवर्ड जनरेटर सुविधा है, जिसमें आप केवल पासवर्ड की लंबाई निर्धारित करते हैं और चुनें कि क्या अक्षरों और अंकों के अलावा विराम चिह्न वर्णों को शामिल करना है।

— फ्रांसेस्को तुर्को
स्रोत

0

अगर मैं गलत हूं तो मुझे सुधारें, लेकिन: जहां तक मैंने इसे समझा, कोई तरीका नहीं है कि कंप्यूटर पूरी तरह से यादृच्छिक स्ट्रिंग के साथ आ सकता है। इसलिए मैं निम्नलिखित विचार के साथ आया [और उम्मीद है कि यह पूरी तरह से मूर्ख नहीं है]:

यदि एक 26-पक्षीय पासा फेंकता है, तो 26 को फेंकने का मौका 1:26 है। दूसरे शब्दों में: 26 को फेंकने का मौका लगभग 0.04% है। इसके अलावा, एक पासा में कोई स्मृति नहीं है और न ही कोई बग है। मैं निम्नलिखित विचार के साथ आया:

26 पक्षीय पासा प्राप्त करें, जहां प्रत्येक पक्ष वर्णमाला के एक अक्षर से मेल खाता है
दस पक्षीय पासा प्राप्त करें जहां प्रत्येक पक्ष 0 और 9 के बीच की संख्या से मेल खाता हो
सिक्का उछालो
सिर का अर्थ है: पत्र पासा फेंकना
पूंछ का अर्थ है: संख्या पासा फेंकना

पेपर मॉडल का प्रिंट आउट लेने के लिए:

10 पक्षीय पासा: http://www.korthalsaltes.com/model.php?name_en=decahedron
26 पक्षीय पासा: http://www.korthalsaltes.com/model.php?name_en=rhombicuboctahedron

नोट : मैं एक मैथ प्रो नहीं हूं और मैं 2600 मैगज़ीन में एक लेख पढ़ने के बाद इस विचार के साथ आया था जिसमें यह वर्णन किया गया था। मैंने मूल अवधारणा पर अपने स्वयं के विचारों को जोड़ा।

इसके अलावा : मुझे आश्चर्य है कि अगर यह ' अपना पहला जानवर बल पासवर्ड पटाखा लिखें ' के लिए सिर्फ एक आदर्श उदाहरण नहीं है । लेकिन आपके सवाल ने मुझे इस विचार को चर्चा में लाने के लिए एक सही कारण दिया।

— erch
स्रोत

1

वास्तव में पूरी तरह से यादृच्छिक बिट्स उत्पन्न करने के कुछ तरीके हैं। उदाहरण के लिए, आपके HDD से विद्युत चुम्बकीय शोर या IO दरों की भिन्नता का उपयोग करते हुए ... 'pseudorandom जनरेटर' नामक जनरेटर के साथ क्या आशा है कि उनके द्वारा उत्पादित अनुक्रम को किसी भी एल्गोरिथ्म द्वारा चल रहे सही यादृच्छिक अनुक्रम से अलग नहीं किया जा सकता है बहुपदी समय फलन।

— 13'13

1

आपको डाइवेयर सिस्टम में दिलचस्पी हो सकती है। यह एक समान विचार का अनुसरण करता है, लेकिन केवल छह-पक्षीय पासा का उपयोग करता है। world.std.com/~reinhold/diceware.html

— जेंडर

0

मजबूत पासवर्ड बनाने के लिए मेरे पास .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 के एक हिस्से का उपयोग करता हूं।

— J363
स्रोत

0

मैं इसे .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>

— माइकल प्रोकोपेक
स्रोत