Was ist der beste Weg, um die Stärke eines Passworts zu überprüfen?
https://stackoverflow.com/questions/75057
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Was ist der beste Weg, um sicherzustellen, dass ein Benutzer angegebenes Kennwort ein sicheres Kennwort in einer Registrierung oder Passwort ändert Form ist?
Eine Idee, die ich hatte (in Python)
def validate_password(passwd):
conditions_met = 0
conditions_total = 3
if len(passwd) >= 6:
if passwd.lower() != passwd: conditions_met += 1
if len([x for x in passwd if x.isdigit()]) > 0: conditions_met += 1
if len([x for x in passwd if not x.isalnum()]) > 0: conditions_met += 1
result = False
print conditions_met
if conditions_met >= 2: result = True
return result
Lösung
1: Eliminate häufig verwendete Passwörter
Überprüfen Sie die eingegebenen Passwörter mit einer Liste von häufig verwendeten Passwörter (siehe zB die Top 100.000 Passwörter in der durchgesickerten LinkedIn Kennwortliste: http://www.adeptus-mechanicus.com/codex/linkhap/combo_not.zip ), stellen Sie sicher, dass a href enthalten <= "http://www.gamehouse.com / Blog / leet-Speak-Spickzettel /“rel = "nofollow noreferrer"> leetspeek Substitutionen :
A @, E3, B8, S5, usw.
Entfernen Sie die Teile des Passworts, die gegen diese Trefferliste aus dem eingegebenen Begriff, vor 2 unten Teil gehen.
2: Zwingen Sie keine Regeln für den Benutzer
Die goldene Regel der Passwörter ist, dass mehr besser ist.
Vergessen Sie gezwungen Verwendung von Kappen, Zahlen und Symbole, weil sie (die überwiegende Mehrheit der) Benutzer werden:
Machen Sie den ersten Buchstaben ein Kapital -;
- Legen Sie die Nummer 1 am Ende;
-. Setzen Sie ein ! nach, dass, wenn ein Symbol erforderlich ist
Statt überprüfen Passwortstärke
Für einen anständigen Ausgangspunkt zu finden unter: http://www.passwordmeter.com/
Ich schlage vor, als mindestens die folgenden Regeln:
Additions (better passwords)
-----------------------------
- Number of Characters Flat +(n*4)
- Uppercase Letters Cond/Incr +((len-n)*2)
- Lowercase Letters Cond/Incr +((len-n)*2)
- Numbers Cond +(n*4)
- Symbols Flat +(n*6)
- Middle Numbers or Symbols Flat +(n*2)
- Shannon Entropy Complex *EntropyScore
Deductions (worse passwords)
-----------------------------
- Letters Only Flat -n
- Numbers Only Flat -(n*16)
- Repeat Chars (Case Insensitive) Complex -
- Consecutive Uppercase Letters Flat -(n*2)
- Consecutive Lowercase Letters Flat -(n*2)
- Consecutive Numbers Flat -(n*2)
- Sequential Letters (3+) Flat -(n*3)
- Sequential Numbers (3+) Flat -(n*3)
- Sequential Symbols (3+) Flat -(n*3)
- Repeated words Complex -
- Only 1st char is uppercase Flat -n
- Last (non symbol) char is number Flat -n
- Only last char is symbol Flat -n
Just folgend passwordmeter nicht genug, denn sicher genug, um sein naiver Algorithmus sieht Password1! als gut, während es außerordentlich schwach ist. Stellen Sie sicher, Anfangsbuchstaben außer Acht zu lassen, wenn Scoring sowie Hinter Zahlen und Symbole (wie in den letzten drei Regeln).
Die Berechnung Shannon-Entropie
Siehe: schnellster Weg Entropie in Python berechnen
3: Lassen Sie keine Kennwörter, die zu schwach sind,
Anstatt den Benutzer zwingen, sich selbst zu besiegen Regeln zu biegen, damit alles, was eine ausreichend hohe Punktzahl zu bekommen. Wie hoch ist abhängig von Ihrem Anwendungsfall.
Und was am wichtigsten ist:
Wenn Sie das Kennwort akzeptieren und speichern sie in einer Datenbank, href="https://stackoverflow.com/questions/4578431/how-to-hash-and-salt-passwords"> .
Andere Tipps
Je nach Sprache, verwende ich reguläre Ausdrücke in der Regel zu überprüfen, ob es hat:
- Mindestens ein Groß- und ein Kleinbuchstaben
- Mindestens eine Zahl
- Mindestens ein Sonderzeichen
- Eine Länge von mindestens sechs Zeichen
Sie können alle oben genannten benötigen, oder eine Stärke Meter Art von Skript verwenden. Für meine Stärke Meter, wenn das Passwort die richtige Länge hat, wird wie folgt bewertet:
- Eine Bedingung erfüllt: schwaches Passwort
- Zwei Bedingungen erfüllt: mittel Passwort
- Alle Bedingungen erfüllt: starkes Passwort
Sie können die oben anpassen Ihren Bedürfnissen gerecht zu werden.
Der objektorientierte Ansatz wäre ein Satz von Regeln. Weisen Sie ein Gewicht zu jeder Regel und durchlaufen sie. In psuedo-Code:
abstract class Rule {
float weight;
float calculateScore( string password );
}
Die Berechnung der Gesamtpunktzahl:
float getPasswordStrength( string password ) {
float totalWeight = 0.0f;
float totalScore = 0.0f;
foreach ( rule in rules ) {
totalWeight += weight;
totalScore += rule.calculateScore( password ) * rule.weight;
}
return (totalScore / totalWeight) / rules.count;
}
Ein Beispiel Regel-Algorithmus, basierend auf der Anzahl von Zeichenklassen vorhanden:
float calculateScore( string password ) {
float score = 0.0f;
// NUMBER_CLASS is a constant char array { '0', '1', '2', ... }
if ( password.contains( NUMBER_CLASS ) )
score += 1.0f;
if ( password.contains( UPPERCASE_CLASS ) )
score += 1.0f;
if ( password.contains( LOWERCASE_CLASS ) )
score += 1.0f;
// Sub rule as private method
if ( containsPunctuation( password ) )
score += 1.0f;
return score / 4.0f;
}
Die beiden einfachsten Metriken zu überprüfen sind:
- Länge. Ich würde sagen, 8 Zeichen als ein Minimum.
- Die Anzahl der verschiedenen Charakterklassen das Passwort enthält. Dies sind in der Regel, Kleinbuchstaben, Großbuchstaben, Zahlen und Satzzeichen und andere Symbole. Ein starkes Passwort Zeichen aus mindestens drei dieser Klassen enthalten; wenn Sie eine Nummer oder andere nicht-alphabetisches Zeichen zwingen, reduzieren Sie deutlich die Wirksamkeit von Wörterbuch-Attacken.
Cracklib ist groß, und in neueren Paketen gibt es ein Python-Modul für sie zur Verfügung. Jedoch auf Systeme, die es noch nicht haben, wie CentOS 5, ich habe einen ctypes Wrapper für das System cryptlib geschrieben. Dies würde auch auf einem System arbeiten, das Sie nicht Python-libcrypt installieren können. Es hat erfordert Python mit ctypes zur Verfügung, so dass für CentOS 5 haben Sie das python26 Paket installieren und zu verwenden.
Es hat auch den Vorteil, dass es die Benutzername nehmen und für Passwörter überprüfen, die sie enthalten oder sind im Wesentlichen ähnlich wie die libcrypt „FascistGecos“ Funktion, aber ohne dass der Benutzer in / etc / passwd existieren.
Meine ctypescracklib Bibliothek finden Sie auf Github
Einige Beispiel verwendet:
>>> FascistCheck('jafo1234', 'jafo')
'it is based on your username'
>>> FascistCheck('myofaj123', 'jafo')
'it is based on your username'
>>> FascistCheck('jxayfoxo', 'jafo')
'it is too similar to your username'
>>> FascistCheck('cretse')
'it is based on a dictionary word'
nach den anderen hilfreichen Antworten zu lesen, das ist, was ich mit:
-1 gleiche wie Benutzernamen
+0 enthält Benutzernamen
+1 mehr als 7 Zeichen
+1 mehr als 11 Zeichen
1 enthält Ziffern
+1 Mischung aus Groß- und Klein
1 enthält Interpunktion
+1 nicht druckbare Zeichen
pwscore.py:
import re
import string
max_score = 6
def score(username,passwd):
if passwd == username:
return -1
if username in passwd:
return 0
score = 0
if len(passwd) > 7:
score+=1
if len(passwd) > 11:
score+=1
if re.search('\d+',passwd):
score+=1
if re.search('[a-z]',passwd) and re.search('[A-Z]',passwd):
score+=1
if len([x for x in passwd if x in string.punctuation]) > 0:
score+=1
if len([x for x in passwd if x not in string.printable]) > 0:
score+=1
return score
Beispiel für die Verwendung:
import pwscore
score = pwscore(username,passwd)
if score < 3:
return "weak password (score="
+ str(score) + "/"
+ str(pwscore.max_score)
+ "), try again."
wahrscheinlich nicht die effizienteste, aber es scheint vernünftig. nicht sicher ‚zu ähnlich username‘ FascistCheck => ist es lohnt sich.
'abc123ABC! @ £' = Score 6/6 wenn keine Ober von username
vielleicht das sollte niedriger punkten.
Es ist die offene und freie John the Ripper Passwort-Cracker, die eine gute Möglichkeit, eine überprüfen vorhandene Passwort-Datenbank.
Gut, das ist, was ich benutze:
var getStrength = function (passwd) {
intScore = 0;
intScore = (intScore + passwd.length);
if (passwd.match(/[a-z]/)) {
intScore = (intScore + 1);
}
if (passwd.match(/[A-Z]/)) {
intScore = (intScore + 5);
}
if (passwd.match(/\d+/)) {
intScore = (intScore + 5);
}
if (passwd.match(/(\d.*\d)/)) {
intScore = (intScore + 5);
}
if (passwd.match(/[!,@#$%^&*?_~]/)) {
intScore = (intScore + 5);
}
if (passwd.match(/([!,@#$%^&*?_~].*[!,@#$%^&*?_~])/)) {
intScore = (intScore + 5);
}
if (passwd.match(/[a-z]/) && passwd.match(/[A-Z]/)) {
intScore = (intScore + 2);
}
if (passwd.match(/\d/) && passwd.match(/\D/)) {
intScore = (intScore + 2);
}
if (passwd.match(/[a-z]/) && passwd.match(/[A-Z]/) && passwd.match(/\d/) && passwd.match(/[!,@#$%^&*?_~]/)) {
intScore = (intScore + 2);
}
return intScore;
}
Neben dem Standardansatz des Mischens alpha, numerisch und Symbole, bemerkte ich, wenn ich mit myOpenID letzter Woche registriert, der Passwort-Checker sagt Ihnen, ob Ihr Kennwort auf einem Wort aus dem Wörterbuch basiert, selbst wenn Sie Zahlen addieren oder Alphas ersetzen mit ähnlichen Zahlen (unter Verwendung von Null anstelle von 'o', '1' anstelle von 'i', usw.).
Ich war ziemlich beeindruckt.
Ich habe eine kleine Javascript-Anwendung. Werfen Sie einen Blick: Noch ein anderes Passwort Meter . Sie können den Quellcode herunterladen und verwenden / ändern es unter der GPL. Viel Spaß!
Ich weiß nicht, ob jemand findet diese nützlich, aber ich möchte die Idee eines ruleset wie phear vorgeschlagen, so ging ich und eine Regel Python 2.6 Klasse geschrieben (obwohl es mit 2,5 wahrscheinlich kompatibel ist):
import re
class SecurityException(Exception):
pass
class Rule:
"""Creates a rule to evaluate against a string.
Rules can be regex patterns or a boolean returning function.
Whether a rule is inclusive or exclusive is decided by the sign
of the weight. Positive weights are inclusive, negative weights are
exclusive.
Call score() to return either 0 or the weight if the rule
is fufilled.
Raises a SecurityException if a required rule is violated.
"""
def __init__(self,rule,weight=1,required=False,name=u"The Unnamed Rule"):
try:
getattr(rule,"__call__")
except AttributeError:
self.rule = re.compile(rule) # If a regex, compile
else:
self.rule = rule # Otherwise it's a function and it should be scored using it
if weight == 0:
return ValueError(u"Weights can not be 0")
self.weight = weight
self.required = required
self.name = name
def exclusive(self):
return self.weight < 0
def inclusive(self):
return self.weight >= 0
exclusive = property(exclusive)
inclusive = property(inclusive)
def _score_regex(self,password):
match = self.rule.search(password)
if match is None:
if self.exclusive: # didn't match an exclusive rule
return self.weight
elif self.inclusive and self.required: # didn't match on a required inclusive rule
raise SecurityException(u"Violation of Rule: %s by input \"%s\"" % (self.name.title(), password))
elif self.inclusive and not self.required:
return 0
else:
if self.inclusive:
return self.weight
elif self.exclusive and self.required:
raise SecurityException(u"Violation of Rule: %s by input \"%s\"" % (self.name,password))
elif self.exclusive and not self.required:
return 0
return 0
def score(self,password):
try:
getattr(self.rule,"__call__")
except AttributeError:
return self._score_regex(password)
else:
return self.rule(password) * self.weight
def __unicode__(self):
return u"%s (%i)" % (self.name.title(), self.weight)
def __str__(self):
return self.__unicode__()
Ich hoffe, dass jemand dies nützlich findet!
Beispiel Verbrauch:
rules = [ Rule("^foobar",weight=20,required=True,name=u"The Fubared Rule"), ]
try:
score = 0
for rule in rules:
score += rule.score()
except SecurityException e:
print e
else:
print score
HAFTUNGSAUSSCHLUSS: Nicht geprüfte Einheit
Wenn Sie die Zeit haben, einen Passwort-Cracker dagegen laufen.
Passwortstärke Kontrolleure, und wenn Sie Zeit haben + Ressourcen (ein berechtigte nur, wenn Sie für mehr als ein paar Passwörter überprüft) verwendet Rainbow Tables.
Mit einer Reihe von Kontrollen, um sicherzustellen, trifft Mindestkriterien:
- mindestens 8 Zeichen lang
- enthält mindestens ein nicht-alphanumerische Zeichen
- überein oder enthalten nicht Benutzername / E-Mail / etc.
- etc
Hier ist eine jQuery-Plugin, das Passwort Stärke Berichte (nicht selber ausprobiert): http://phiras.wordpress.com / 2007/04/08 / Passwort-Stärke-Meter-a-jquery-Plugin /
Und das Gleiche zu PHP portiert: http://www.alixaxel.com/wordpress / 2007/06/09 / php-Passwort-Stärke-Algorithmus /
Was ist der beste Weg, um sicherzustellen, dass ein Benutzer angegebenes Kennwort ein sicheres Kennwort in einer Registrierung oder Passwort ändert Form ist?
nicht auswerten Komplexität und oder Stärke, werden die Nutzer einen Weg finden, um Ihr System zu täuschen oder so frustriert, dass sie verlassen wird. Das wird nur bekommt man Situationen Beispiel . Nur erfordern bestimmte Länge und dass durchgesickert Passwörter werden nicht verwendet. Bonuspunkte: stellen Sie sicher, was auch immer Sie bei der Implementierung ermöglicht die Verwendung von Passwort-Manager und / oder 2FA
.