it-swarm.com.de

So überprüfen Sie die Kennwortstärke

Ich habe dieses Skript geschrieben, aber [:alnum:] funktioniert nicht. Jemand helfen?

echo -n "Enter a password : "
read password

LEN=$(echo ${#password})

if [ $LEN -lt 10 ]; then

       echo "$password is smaller than 10 characters"
else
     if ! [ -z `echo $password | tr -d "[:alnum:]"` ]; then
        echo "$password is a weak password"
     else
        echo "$password is a strong password"
     fi
fi
echo 
5
Panos Mikael

Wenn Sie die Kennwortstärke wirklich überprüfen möchten, sollten Sie cracklib-check aus dem Paket cracklib-runtime verwenden (sollte standardmäßig installiert sein):

$ echo foo | cracklib-check
foo: it is WAY too short
$ echo foobar | cracklib-check
foobar: it is based on a dictionary Word
$ echo foobared | cracklib-check
foobared: it is based on a dictionary Word
$ echo foobared123 | cracklib-check
foobared123: it is too simplistic/systematic
$ echo '!'foobared123 | cracklib-check
!foobared123: OK
15
muru

Oberflächliche Probleme

Es gibt verschiedene Probleme mit Ihrem Skript. Es bricht ab, wenn das Passwort eine Reihe von Sonderzeichen enthält. Versuchen Sie Eingaben wie:

a space
two  spaces
a * star                            ← try this one in different directories
bbbbbbbbbb                          ← try this one in a directory containing a file called a
endswithabackslash\

Read Warum verschluckt sich mein Shell-Skript an Leerzeichen oder anderen Sonderzeichen?. Alles davon. Schreiben Sie keine Shell-Skripte, die sich auf die Sicherheit im Remote-Zugriff beziehen, bis Sie alles verstanden haben.

Oh, und [:alnum:] funktioniert perfekt. Sie wollten wahrscheinlich if [ -z … oder if ! [ -n … anstelle von if ! [ -z … schreiben.

Die Stärke eines Passworts gibt es nicht

Die Idee der "Passwortstärke" ist ein Mythos. Es ist ein Mythos, der von vielen Websites verbreitet wird, aber es ist immer noch ein Mythos. Es gibt keine Stärke eines Passworts, es gibt nur die Stärke eines Passwortgenerierungsprozesses .

Wenn ein Kennwort Sonderzeichen enthält, wird es nicht stärker. Ein Kennwort ist ein Kompromiss zwischen der Einfachheit des Speicherns und der Einfachheit des Knackens und Sonderzeichen erschweren das Speichern von Kennwörtern, aber nicht wesentlich das Knacken , wie in diesem Thread in Security Stack Exchange) analysiert ( die Kurzgeschichte , die Mathematik , einige Ergänzungen - Übung: in diese falsche Antwort , die Teile ignorieren die Fakten völlig?). Die Idee, dass Sonderzeichen ein Passwort stärker machen, basiert auf der Annahme, dass Leute, die Passwort-Cracker schreiben, Idioten sind. Ratet mal: Sie sind es nicht. Durch das Knacken von Passwörtern kann man Geld verdienen, also können Sie darauf wetten, dass es Leute gibt, die investieren, um es gut zu machen.

Wie soll ich dann Passwörter auswählen?

Zufällig . Wenn Ihre Methode zur Auswahl eines Passworts keine Zufallsquelle enthält (mit einem Computer oder Würfeln, wenn Sie es in der alten Schule mögen), ist es nicht gut.

Diceware ist eine beliebte Wahl, aber jede Methode, die dem XKCD-Muster folgt - mehrere „Wörter“ zufällig aus einem Wörterbuch auswählen - ist gut.

Ein korrektes Skript

#!/bin/sh
echo -n "Enter a password : "
IFS= read -r password

LEN=${#password}

if [ "$LEN" -lt 10 ]; then
  printf "%s is smaller than 10 characters\n" "$password"
fi
if [ -z "$(printf %s "$password" | tr -d "[:alnum:]")" ]; then
  printf "%s only contains ASCII letters and digits\n" "$password"
else
  printf "%s contains characters other than ASCII letters and digits\n" "$password"
fi

Die Verwendung von tr auf diese Weise macht die Dinge zu kompliziert. Die Shell ist perfekt in der Lage zu überprüfen, ob ein String Zeichen aus einer bestimmten Menge enthält.

#!/bin/sh
echo -n "Enter a password : "
IFS= read -r password

LEN=${#password}

if [ "$LEN" -lt 10 ]; then
  printf "%s is smaller than 10 characters\n" "$password"
fi
case "$password" in
  *[![:alnum:]]*)
    printf "%s contains characters other than ASCII letters and digits\n" "$password";;
  *)
    printf "%s only contains ASCII letters and digits\n" "$password";;
esac

(Beachten Sie, dass die Aussage über ASCII Buchstaben und Ziffern für Ubuntus /bin/sh gilt, aber in bash [:alnum:] alle Buchstaben und Ziffern in der aktuellen enthält Gebietsschema, nicht nur die ASCII.)

13
Gilles

Riecht für mich furchtbar nach einem XY-Problem. Schreiben Sie niemals Ihre eigenen Tools für die Arbeit mit Passwörtern. Zumindest beschäftigen Sie sich hier nicht mit der Speicherung von Passwörtern, aber das Erste, was Sie an Ihren Code denken, ist, dass ich ein All eingeben kann -numerisches Passwort und habe es als "stark" eingestuft (in Wirklichkeit wäre es viel schwächer als ein vollalphabetisches Passwort). Wenn Sie mit diesem Ansatz zur Sicherheit/Kennwortbehandlung fortfahren, werden Sie früher oder später hinfallen und es wird nicht schön sein, wenn es passiert.

Die richtige Lösung besteht darin, eine externe Bibliothek oder eine Hilfsanwendung zu verwenden, um die Kennwortsicherheit zu bestimmen (und andere kennwortbezogene Aufgaben auszuführen). Die meisten Linux-Systeme verfügen heutzutage über PAM, mit dem Sie alle Authentifizierungsaufgaben auf sichere Weise ausführen können (als Bonus erhalten Sie Unterstützung für andere Authentifizierungsmethoden als Kennwörter, je nachdem, wie das System des Benutzers konfiguriert ist), und muru hat bereits eine vorgeschlagen Hilfsanwendung, die die Kennwortstärke bestimmt.

8
Micheal Johnson

Wenn Sie eine gute Methode zum Erstellen von Passwörtern wünschen

Sehen

Passwortgenerator, der aktuelle Wörter kombiniert

"Starke Passwörter" oder "Stärke eines Passwortgenerierungsprozesses"

Ihre Frage: Wie überprüfe ich die Passwortstärke?

Wie erzwinge ich eine Richtlinie zur Kennwortkomplexität?

Sie können nur bestimmte Aspekte des Kennworts überprüfen oder für jede Methode ein bestimmtes Tool zum Erstellen des Kennworts oder eine allgemeine Brute-Force-Methode verwenden (wenn der Angreifer die Methode nicht kennt).

Shellscript pwdcheck mit cracklib-check

#!/bin/bash

# setting variables

usage="Use 4 words chosen randomly, see this link:
https://security.stackexchange.com/questions/6095/xkcd-936-short-complex-password-or-long-dictionary-passphrase"

minlen=20  # can be modified here
short="is shorter than $minlen characters"
goodmix="is long enough"
badmix="is too short
$usage"
separator="-------"

# checking parameter

if [ "$1" == "-h" ] || [ "$1" == "--help" ] || [ $# -gt 1 ]; then
 echo "${0##*/} uses 'cracklib-check'"
 echo "----------------------------------------------------------------"
 echo "Usage:   $0 CandidateContaining4DifferentWords"
 echo "Example: $0 At-least-$minlen-char"
 echo "         $0 'Should.be.selected.via.*random*.process'"
 echo "         $0 'Single-quote-for-1-special-character!'"
 echo "         $0 'FindPatternByDigitalTest123'"
 echo "         $0 'Provoke1pattern2search3by4separating5words'"
 echo "$usage"
 exit
Elif [ $# -eq 0 ]; then
 echo "$usage"
 echo "----------------------------------------------------------------"
 read -p "Enter a password : " password
Elif [ $# -eq 1 ]; then
 password="$1"
fi

# checking and installing if necessary

which cracklib-check > /dev/null
if [ $? -eq 1 ]; then
 read -p "Do you want to install 'cracklib-runtime' to get 'cracklib-check'? (y/N) " ans
 if [ "$ans" == "y" ]; then
  Sudo apt-get update && Sudo apt-get install cracklib-runtime
 fi
fi

if [ ${#password} -lt $minlen ]; then
 result="$short"
else
 result="$goodmix"
 case "$password" in
  *[![:alnum:]]*)
     alnm="'$password' contains characters other than ASCII letters and digits";;
#     result="$badmix";;
  *)
    alnm="$password contains only ASCII letters and digits";;
 esac
fi

echo "Test 1 - size&mix: '$password' $result"
test ${#password} -lt $minlen || echo "$alnm"
if [ "$result" == "$badmix" ] || [ "$result" == "$short" ]; then
 total="is bad"
else
 total='is good'
fi

echo "$separator"
echo "Test 2 - Lexicon: '$password'"
sed -e 's/[0-9]/123\n/g' -e 's/$//' -e 's/[§[email protected]£$€#¤%/()=?*,;.:_-~ ]/123\n/g' -e 's/$/123/g' \
<<< "$password" | LANG=C cracklib-check |sed 's/123: /: /'| \
grep 'it is based on a dictionary Word'
if [ $? -ne 0 ]; then
 echo 'no comment'
fi

echo "$separator"
echo "Test 3 - digital: '$password'"
sed -e 's/[[:alpha:]]//g' -e 's/[§[email protected]£$€#¤%/()=?*,;.:_-~ ]//g' -e 's/$/xyz/' \
<<< "$password" | LANG=C cracklib-check |sed 's/xyz: /: /'| \
grep 'it is too simplistic/systematic'
if [ $? -eq 0 ]; then
 total='is bad'
else
 echo 'is good'
fi

echo "$separator"
echo "Test 4 - cracklib-check: '$password'"
LANG=C cracklib-check <<< "$password" | tee /dev/stderr | grep ': OK' > /dev/null
if [ $? -eq 0 ]; then
 echo='is good'
else
 total='is bad'
fi

if [ "$total" == "is good" ]; then
 echo "$separator"
 ans=
 while [ "$ans" != "g" ] && [ "$ans" != "b" ]
 do
  read -p "Test 5 - manual: Is '$password' a good or bad password? (g/b) " ans
  if [ "$ans" == "g" ]; then
   echo 'is good'
  Elif [ "$ans" == "b" ]; then
   total='is bad'
   echo "$total"
  fi
 done
fi

echo "$separator"
if [ "$total" == "is good" ]; then
 echo "Every test result for '$password' $total: No weakness found :-)"
else
 echo "Some test result for '$password' $total: Some weakness found :-("
fi

Hilfstext

Läuft im aktuellen Verzeichnis ein Testverzeichnis. wo Sie die Shellscript-Datei haben,

$ ./pwdcheck -h
pwdcheck uses 'cracklib-check'
----------------------------------------------------------------
Usage:   ./pwdcheck CandidateContaining4DifferentWords
Example: ./pwdcheck At-least-20-char
         ./pwdcheck 'Should.be.selected.via.*random*.process'
         ./pwdcheck 'Single-quote-for-1-special-character!'
         ./pwdcheck 'FindPatternByDigitalTest123'
         ./pwdcheck 'Provoke1pattern2search3by4separating5words'
Use 4 words chosen randomly, see this link:
https://security.stackexchange.com/questions/6095/xkcd-936-short-complex-password-or-long-dictionary-passphrase

Das cracklib-Programmpaket

$ apt-cache policy cracklib-runtime 
cracklib-runtime:
  Installerad: 2.9.2-1ubuntu1
  Kandidat:    2.9.2-1ubuntu1
  Versionstabell:
 *** 2.9.2-1ubuntu1 500
        500 http://se.archive.ubuntu.com/ubuntu xenial-updates/main i386 Packages
        100 /var/lib/dpkg/status
     2.9.2-1build2 500
        500 http://se.archive.ubuntu.com/ubuntu xenial/main i386 Packages

Testen der verschiedenen Beispiele aus dem Hilfetext

Manueller Test wichtig, aber mit Bedacht anwenden

Ihre manuelle Überprüfung und Ihr "Test" können wichtig sein, um wirklich falsche Passwörter zu vermeiden. Wenn Sie jedoch eine automatische Zufallsmethode mit gutem Ruf verwenden, sollten Sie sich darauf verlassen und Manipulationen am Ergebnis vermeiden , weil Sie das Passwort wahrscheinlich leichter knacken können.

$ ./pwdcheck CandidateContaining4DifferentWords
Test 1 - size&mix: 'CandidateContaining4DifferentWords' is long enough
CandidateContaining4DifferentWords contains only ASCII letters and digits
-------
Test 2 - Lexicon: 'CandidateContaining4DifferentWords'
no comment
-------
Test 3 - digital: 'CandidateContaining4DifferentWords'
is good
-------
Test 4 - cracklib-check: 'CandidateContaining4DifferentWords'
CandidateContaining4DifferentWords: OK
-------
Test 5 - manual: Is 'CandidateContaining4DifferentWords' a good or bad password? (g/b) b
is bad
-------
Some test result for 'CandidateContaining4DifferentWords' is bad: Some weakness found :-(
# comment: This password is published here!

##### Short password #####

$ ./pwdcheck At-least-20-char
Test 1 - size&mix: 'At-least-20-char' is shorter than 20 characters
-------
Test 2 - Lexicon: 'At-least-20-char'
least: it is based on a dictionary Word
char: it is based on a dictionary Word
-------
Test 3 - digital: 'At-least-20-char'
is good
-------
Test 4 - cracklib-check: 'At-least-20-char'
At-least-20-char: OK
-------
Some test result for 'At-least-20-char' is bad: Some weakness found :-(

##### Reminder about random process #####

$ ./pwdcheck 'Should.be.selected.via.*random*.process'
Test 1 - size&mix: 'Should.be.selected.via.*random*.process' is long enough
'Should.be.selected.via.*random*.process' contains characters other than ASCII letters and digits
-------
Test 2 - Lexicon: 'Should.be.selected.via.*random*.process'
Should: it is based on a dictionary Word
selected: it is based on a dictionary Word
via: it is based on a dictionary Word
random: it is based on a dictionary Word
process: it is based on a dictionary Word
-------
Test 3 - digital: 'Should.be.selected.via.*random*.process'
is good
-------
Test 4 - cracklib-check: 'Should.be.selected.via.*random*.process'
Should.be.selected.via.*random*.process: OK
-------
Test 5 - manual: Is 'Should.be.selected.via.*random*.process' a good or bad password? (g/b) g
is good
-------
Every test result for 'Should.be.selected.via.*random*.process' is good: No weakness found :-)
# comment: Do not use the password literally ;-)

##### Single quote the password, if you intend to use special characters   #####
##### Words are found by Lexicon test (using cracklib-check), and accepted #####

$ ./pwdcheck 'Single-quote-for-1-special-character!'
Test 1 - size&mix: 'Single-quote-for-1-special-character!' is long enough
'Single-quote-for-1-special-character!' contains characters other than ASCII letters and digits
-------
Test 2 - Lexicon: 'Single-quote-for-1-special-character!'
Single: it is based on a dictionary Word
quote: it is based on a dictionary Word
for: it is based on a dictionary Word
special: it is based on a dictionary Word
character: it is based on a dictionary Word
-------
Test 3 - digital: 'Single-quote-for-1-special-character!'
is good
-------
Test 4 - cracklib-check: 'Single-quote-for-1-special-character!'
Single-quote-for-1-special-character!: OK
-------
Test 5 - manual: Is 'Single-quote-for-1-special-character!' a good or bad password? (g/b) b
is bad
-------
Some test result for 'Single-quote-for-1-special-character!' is bad: Some weakness found :-(

##### Showing how the digital test works (it uses cracklib-check) #####

$ ./pwdcheck 'FindPatternByDigitalTest123'
Test 1 - size&mix: 'FindPatternByDigitalTest123' is long enough
FindPatternByDigitalTest123 contains only ASCII letters and digits
-------
Test 2 - Lexicon: 'FindPatternByDigitalTest123'
no comment
-------
Test 3 - digital: 'FindPatternByDigitalTest123'
123: it is too simplistic/systematic
-------
Test 4 - cracklib-check: 'FindPatternByDigitalTest123'
FindPatternByDigitalTest123: OK
-------
Some test result for 'FindPatternByDigitalTest123' is bad: Some weakness found :-(

##### Showing the Lexicon test and the digital test #####

$ ./pwdcheck 'Provoke1pattern2search3by4separating5words'
Test 1 - size&mix: 'Provoke1pattern2search3by4separating5words' is long enough
Provoke1pattern2search3by4separating5words contains only ASCII letters and digits
-------
Test 2 - Lexicon: 'Provoke1pattern2search3by4separating5words'
Provoke: it is based on a dictionary Word
pattern: it is based on a dictionary Word
search: it is based on a dictionary Word
separating: it is based on a dictionary Word
words: it is based on a dictionary Word
-------
Test 3 - digital: 'Provoke1pattern2search3by4separating5words'
12345: it is too simplistic/systematic
-------
Test 4 - cracklib-check: 'Provoke1pattern2search3by4separating5words'
Provoke1pattern2search3by4separating5words: OK
-------
Some test result for 'Provoke1pattern2search3by4separating5words' is bad: Some weakness found :-(

##### Run interactively without any parameter #####

$ ./pwdcheck
Use 4 words chosen randomly, see this link:
https://security.stackexchange.com/questions/6095/xkcd-936-short-complex-password-or-long-dictionary-passphrase
----------------------------------------------------------------
Enter a password : CandidateContaining4DifferentWords
Test 1 - size&mix: 'CandidateContaining4DifferentWords' is long enough
CandidateContaining4DifferentWords contains only ASCII letters and digits
-------
Test 2 - Lexicon: 'CandidateContaining4DifferentWords'
no comment
-------
Test 3 - digital: 'CandidateContaining4DifferentWords'
is good
-------
Test 4 - cracklib-check: 'CandidateContaining4DifferentWords'
CandidateContaining4DifferentWords: OK
-------
Test 5 - manual: Is 'CandidateContaining4DifferentWords' a good or bad password? (g/b) g
is good
-------
Every test result for 'CandidateContaining4DifferentWords' is good: No weakness found :-)
[email protected] /media/multimed-2/test/test0/pwdstrength $ 
1
sudodus
td -d "[:alnum:]"

funktioniert bei mir:

$> echo '123§45!67M89(0' | tr -d  "[:alnum:]"
§!(   

Du kannst es gerne benutzen

#!/bin/bash

echo -n "Enter a password : "
read password
LEN=$(echo ${#password})

if [ $LEN -lt 10 ]; then
    echo "$password is smaller than 10 characters"
else
    if [ $(echo $password | tr -d "[:alnum:]" | wc -w) -eq 0 ]; then
        echo "$password is a weak password"
    else
        echo "$password is a strong password"
    fi
fi                                                                                                                      echo

wc -w zählt die Wörter.

  • Also, wenn Sie alle alnum entfernen und die Wortanzahl 0 => true => schwaches Passwort ist

  • wenn die Wortzahl 1 ist (oder mehr, wenn Leerzeichen verwendet werden) => false => strong password

1
derHugo