Passwort-Stärke ermitteln (Code und Prüflogik)

[Satty67]

Hallo,

in mein aktuelles Projekt bekommt ja einen verschlüsselten Dokumenten-Container. Für die Passwortwahl will ich dem Benutzer ein Hilfe geben, wie gut das gewählte Passwort ist. Dazu hab' ich im Internet viele Theorien gelesen und natürlich PassphraseQuality aus der Codelib ausprobiert.

Erst schien mir PassphraseQuality perfekt, wobei mir dann insbesondere bei der Passwortlänge ein merkwürdiges Verhalten aufgefallen ist. "Satty67!" wird mit 21% bewertet, während "Sattttttttttttttttttttttttttttttttttty67!" unter 5% liegt (wie kann das schlechter sein?).

Dann "TheQuickBrownFoxJumpsOverTheLazyDog" bekommt 100% während "TheWeatherIsWet,WhenTheWeatherIsWet!" nur 55% erhält. Beide Passwörter sind gleich lang, nur das Erste enthält lauter unterschiedliche Buchstaben. Allerdings denke ich, dass die Sonderzeichen höher zu bewerten sind, denn bei einer BruteForce-Attacke ist der eigeschränkte Buchstabensatz ja nicht bekannt (A-Z wir immer geprüft). D.h. es wird auch etwas zuviel Wert auf unterschiedliche Zeichen gelegt, wobei die zusätzliche Verwendung von Sonderzeichen keinen verstärkenden Einfluß hat.

Lange Rede, kurzer Sinn, ich hab' mir selber was überlegt :stupid:

• Zeichenwiederholungen werden bei der Bewertung ignoriert und als Einzelzeichen gewertet, die restlichen Zeichen aber dadurch nicht abgewertet.
• Bei erkanntem Datum werden die Punkte nicht als wertvolle Sonderzeichen gewertet
• Prüfen, ob der Zeichensatz breit genutzt wird (Also Ziffern, Groß/Kleinbuchstaben, Sonderzeichen). Mindestens ein Zeichen der Gruppe ist nötig, um eine evtl. Attacke zu einem erweiterten Suchbereich zu zwingen.
• Anzahl unterschiedliche Zeichen im Verhältnis zur Länge ermitteln (nicht extrem hoch bewertet)
• Passwörter, die nur aus Buchstaben bestehen, abwerten (vermutetes Wort einer Sprache)
• Gesamtlänge bewerten (Länge schätze ich bis zu einer Obergrenze am wichtigsten ein)
• Die ganzen Einzelergebnisse ins richtige Verhältnis setzen

Ergebnis der Funktion ist hier auch ein Wert zw. 0.0 und 1.0 (zur besseren Vergleichbarkeit). Später werde ich wohl gleich ganze Prozente übergeben, damit man es gleich ohne Umrechnen einer ProgressBar o.ä. übergeben kann.

Alles in allem bin ich über das Bewertungsergebnis glücklicher, allerdings kenne ich nicht die Techniken im Detail, die bei einer Attacke angewendet werden. Deshalb kann ich mich bei der Bewertung eines Passwortes auch irren!

ToDo:

• TopTen-Passwörter abwerten, wenn das dann in ein TPasswordEdit kommt, per Property setzbar
• Keyboard-Layout: QWERTZ und CO, was Hagen bei sich implementiert hat

Der Code wird später in einer Komponente verbaut und ist nur zu besseren Prüf-/Tesbarkeit hier als Funktion vorgestellt. Kann es auch später als Einzelklasse aufbauen, das ist fix gemacht. Nach derzeitigem Diskussionsstand ist man aber noch nicht von der Qualität des Prüfergebnisses überzeugt, weshalb es sich noch nicht lohnt da etwas zu entwerfen.

Delphi-Quellcode:

function PasswordStrength(const Password : String): Extended;
const
  LowerMultiplicator   = 1.9; // Verhältnisse der 4 Zeichengruppen untereinander
  UpperMultiplicator   = 2.1; // und Anteil am Gesamtergebnis
  NumericMultiplicator = 1.5; // In der Summe etwa 10 scheint ausgewogen
  SignMultiplicator    = 2.5;
  DiffCharsMaxMulti    = 10; // Entropische Prüfung [schwach 10 - 100 stark]
  MinPasswordLength    = 4;  // Ein kürzeres Passwort fällt völlig durch
  MaxPasswordLength    = 32; // Ein längeres Passwort verbessert nicht mehr das Ergebnis

  // Zeichenwiederholungen (da wenig Wert) entfernen
  function RemoveRepetitions(const AString : string): String;
  var
    i : Integer;
  begin
    Result := AString;
    i := 2;
    while i <= Length(Result) do
    begin
      if Result[i] = Result[i-1] then
        Delete(Result, i, 1)
      else
        inc(i);
    end;
  end;

  // Sofern ein Datum erkannt wird, wertlose Separatoren entfernen
  function RemoveDateSeparator(const AString : string): String;
  var
    i : Integer;
    dt : TDateTime;
    DateStr : String;
  begin
    DateStr := AString;
    i := Length(DateStr);
    if (i > 0) and (AString[i] = DateSeparator) then
      Delete(DateStr, i, 1);

    if TryStrToDate(DateStr, dt) then
      Result := StringReplace(AString, DateSeparator, '', [rfReplaceAll])
    else
      Result := AString;
  end;

  // Längen-Multiplikator mit Rücksicht auf Obergrenze
  function LengthMul(const CurrentLength, MaxLength : Integer): Extended;
  begin
    if CurrentLength > MaxLength then
      Result := Math.Log2(MaxLength) * Math.Log2(MaxLength)
    else
      Result := Math.Log2(CurrentLength) * Math.Log2(CurrentLength)
  end;

  // Bewerten der im Passwort verwendeten Zeichen
  function CalculateEntropie(CleanPWLength, DiffCharsCount : Integer;
                  LowerMul, UpperMul, NumericMul, SignMul: Extended):Extended;
  begin
    Result := (DiffCharsCount * DiffCharsMaxMulti) / CleanPWLength;
    if (NumericMul + SignMul) = 0 then
      Result := Result + ((LowerMul + UpperMul) / 2)
    else
      Result := Result + LowerMul + UpperMul + NumericMul + SignMul;
  end;

  // Maximal ereichbares Ergebnis für Prozentrechnung ermitteln
  function GetBestResult: Extended;
  begin
    Result := CalculateEntropie(1, 1, LowerMultiplicator, UpperMultiplicator,
                                NumericMultiplicator, SignMultiplicator);
    Result := Result * LengthMul(MaxPasswordLength, MaxPasswordLength);
  end;

var
  i, CleanPWLength : Integer;
  CleanPassword,
  DiffChars : String;
  EntropieMul,
  LowerMul, UpperMul,
  NumericMul, SignMul : Extended;
begin
  Result     := 0;
  LowerMul   := 0;
  UpperMul   := 0;
  NumericMul := 0;
  SignMul    := 0;

  CleanPassword := Trim(Password);
  CleanPassword := RemoveDateSeparator(CleanPassword);
  CleanPassword := RemoveRepetitions(CleanPassword);

  CleanPWLength := Length(CleanPassword);
  if (CleanPWLength >= MinPasswordLength) then
  begin

    for i := 1 to Length(CleanPassword) do
    begin
      case CleanPassword[i] of
        'a'..'z': LowerMul   := LowerMultiplicator;
        'A'..'Z': UpperMul   := UpperMultiplicator;
        '0'..'9': NumericMul := NumericMultiplicator;
      else
        SignMul := SignMultiplicator;
      end;

      if Pos(CleanPassword[i], DiffChars) < 1 then
        DiffChars := DiffChars + CleanPassword[i];
    end;

    EntropieMul := CalculateEntropie(CleanPWLength, Length(DiffChars),
                                     LowerMul, UpperMul, NumericMul, SignMul);

    Result := EntropieMul * LengthMul(CleanPWLength, MaxPasswordlength);
    Result := Result / GetBestResult;
  end;
end;

Der Vollständigkeit halber ein Anwendungsbeispiel:

Delphi-Quellcode:

procedure TForm1.Edit1Change(Sender: TObject);
begin
  Label1.Caption := Format('Sicherheit bei annähernd %.1f%%',
                           [PasswordStrength(Edit1.Text) * 100]);
end;

[Luckie]

Also was mir da auf an Hieb für ein Stichwort einfällt ist Entropie. Eventuell kannst hilft es dir bei deinen Recherchen. So wohl im physikalischem Sinne http://de.wikipedia.org/wiki/Entropi...ermodynamik%29 (Maß der "Unordnung") als auch im Sinne der Informatik http://de.wikipedia.org/wiki/Entropi...ionstheorie%29 (Maß der Informationsdichte). Dabei gehe ich davon aus, dass je größer die Unordnung ist, desto sicherer sollte das Passwort sein. Gleiches gilt für die Informationsdichte.

[Satty67]

Spezialisierte Algorithmen oder Theorien kenne ich nur wenige, da sind bei mir Stichwörter (für Google) immer hilfreich. :wink:

Ich hatte versucht mir eine Attacke auf ein Passwort vorzustellen bzw. was ein ermitteln schwer macht. Dabei kenne ich ja nicht alle Techniken. Dabei bleibe ich meistens bei BruteForce-Attacken hängen, welche durch eine möglichst hohe Zahl der Testläufe erschwert werden können.

Ich hab' aber gelesen, das es inzw. auch kombinierte Attacken gibt, die mit dem Hash (MD5 oder SHA) zusammen da gezielter angreifen.

[Luckie]

Experte bin ich auch nicht, aber das war was mir dazu eingefallen ist. Aber schreibe Hagen doch mal eine PN oder E-Mail und weise ihn auf deine Entdeckung hin.

[Satty67]

Wenn sich nicht rausstellt, das ich irgendeinem Irrtum aufgelaufen bin (wie so oft) kann/werde ich das machen.

[BUG]

Zitat:

Zitat von Satty67 (Beitrag 1050374)

"Satty67!" wird mit 21% bewertet, während "Sattttttttttttttttttttttttttttttttttty67!" unter 5% liegt (wie kann das schlechter sein?).

Wenn man sich Hagens Verfahren anschaut, ist die Entropie dort sehr wichtig (ist ein Faktor).

Die Entropie von "Sattttttttttttttttttttttttttttttttttty67!" ist viel geringer als die von "Satty67!", da ja das 't' überdurchschnittlich häufig vertreten ist.

[Satty67]

Ja aber das ist dem Angreifer ja nicht bekannt. Die Frage ist, ob solche 20 "T"s innerhalb des Passwortes einen Angriff leichter oder schwerer machen (weil die Länge größer wird).

Ich bin zwar nicht sicher, aber tendiere eben dazu, dass das Passwort dadurch etwas besser wird, aber auf keinen Fall um 15% schlechter. (In weiterer Kombination mit anderen zeichen eben deutlich besser, da hier der Längenvorteil eine Rolle spielt)

Anders gefragt:

ist "abcd" sicherer als "tttttttttttttttttt", wenn ein Angreifer keinen Hinweis auf die simple Art des Passwortes hat? Das ist wohl entscheidend für die Frage, ob ich auch eine entropische Komponente mit einarbeiten müsste.

Dazu ein Zitat:

Zitat:

Zitat von negaH (Beitrag 90789)

...primär entscheidet erstmal die Länge des Passwortes ob es gut oder schlecht ist. D.h. ein langes Passwort muß viel mehr gewichtung erhalten als ein kurzen Passwort. Ein um 1 Zeichen längeres Passwort sollte niemals schlechter bewertet werden als ein kombinatorisch gesehen besseres aber kürzeres Passwort...

...was aber bei dem Sat...ty67 Beispiel der Fall ist!?

[Sir Rufo]

Es kommt auf das Einsatzgebiet des Passwortes an ob die Entropie mehr oder weniger kritisch ist.

Wird das Kennwort als Hash gespeichert (worauf der Angreifer Zugriff hat) dann sind viele sich wiederholende Zeichen nicht ganz so schlimm, außer:

- das Kennwort besteht nur aus einem Buchstaben "tttttttt"
- der Angreifer hat mitbekommen (über die Schulter geschaut) das hauptsächlich ein "t" im Kennwort vorkommt

Wird das Passwort direkt als Schlüssel benutzt (z.B. WPA2-Key) so ist die Verschlüsselung mit "tttttttt" schlechter als mit einem "bunten" Passwort.

Die Entropie ist also auch ein Gradmesser für "Ausspähsicherheit" und "Verschlüsselungsgüte".
Somit sehe ich die Entropie als durchaus entscheidend an.

Beim reinen Schutz gegen Brute-Force-Attacken ist sicherlich die Länge ausschlaggebend "Size matters", aber die Realität kennt mehr als Brute-Force.

[Satty67]

Gut, ich will sowieso noch ein paar Subfunktionen einbauen, die spezielle Eigenschaften prüfen und dann abwerten.

• Datum: Punkte und Striche ect. werten bei mir in dem Fall noch zu sehr das PW auf
• TopTen: Wenn eines der häufig genutzen Passwörter eingegeben wird
• Keyboard-Layout: QWERTZ und CO, was Hagen bei sich implementiert hat
• Entropie: Allerdings etwas anders...

"Satttttttty" kann nicht schlechter sein als "Satty", es ist mindestens gleichwertig. Ich habe mir überlegt, das Wiederholungen ausschneide, bevor das Passwort mit den restlichen Methoden bewertet wird. z.B. ab der 3ten Wiederholung ausschneiden... ein "ttttttttt" wird dann wie "tt" bewertet und "Sattttttttty" wie "Satty"

Edit:

So, Wiederholungen werden ab dem 2ten Zeichen nun bei der Bewertung ignoriert. "Satty" und "Satttttttty" wird beides wie "Saty" bewertet. Eine höhere Last auf Entropie kann man durch Erhöhen der Konstante DiffCharsMaxMulti erreichen.

Ich denke es ist ein Kompromiss, der den Längenvorteil von vielen gleichen Zeichen zwar ignoriert, die restlichen Zeichen im Passwort aber durch Wiederholungen nicht abwertet?

Edit #2:

So, etwas umgebaut und Namen angepasst. Ich muss aufpassen, dass das ganz nicht zu aufwändig wird. Ist im Prinzip ja nur ein Vorschlag-Geber und sollte die Zeicheneingabe auf langsamen Rechnern nicht bremsen :stupid:

Ganz ehrlich, ich bin mit Auswertungsergebnis ziemlich zufrieden. Hagen hat mit Sicherheit die cryptologisch besseren Prüfmethoden verwendet, aber imho eben an einer Stelle einen Fehler drin oder zumindest ein seltsames Verhalten.

[sx2008]

Immer wenn ich solche komplexen Funktionen mit jeder Menge Unterfunktionen sehe,
dann klingelt bei mir ein kleines Glöckchen:
"hey, du solltest hier besser eine Klasse draus machen!"

Und wenn ich dann noch lese: "Gut, ich will sowieso noch ein paar Subfunktionen einbauen..."
dann bin ich mir sicher, dass hier eine Klasse benötigt wird.

[Die Muhkuh]

Zitat:

Zitat von Satty67 (Beitrag 1050392)

Ganz ehrlich, ich bin mit Auswertungsergebnis ziemlich zufrieden. Hagen hat mit Sicherheit die cryptologisch besseren Prüfmethoden verwendet, aber imho eben an einer Stelle einen Fehler drin oder zumindest ein seltsames Verhalten.

Ich würde, allein auf Grund Deiner Aussage, eher Hagens Prüfmethode bevorzugen da er, wie Du selbst sagt, die kryptologisch bessere Prüfmethode verwendet. Was bringt mir dann eine, die eine Passwortsicherheit anzeigt, die sich jemand ausgedacht hat? ;-)

Eventuell kann ja Hagen das ganze mal kommentieren, auch Deine Aussage, dass die vielen 't' hintereinander eine Brute-Force-Attacke erschweren sollte.

[Satty67]

Zitat:

Zitat von sx2008 (Beitrag 1050431)

"hey, du solltest hier besser eine Klasse draus machen!"

Es steht zwar versteckt da, aber es steht da... wird später Bestandteil eines TPasswordEdits bzw. passwordTextBox.

Zitat:

Zitat von Die Muhkuh (Beitrag 1050432)

die kryptologisch bessere Prüfmethode verwendet. Was bringt mir dann eine, die eine Passwortsicherheit anzeigt, die sich jemand ausgedacht hat?

Es gibt auch sichere Passwörter, die nicht wie von einem RandomCryptoGenerator erzeugt aussehen, da patzt nunmal meiner Meinung nach PassphraseQuality. Man kann PassphraseQuality zwar nicht vorwerfen, das es schlechte Passwörter gut bewertet, aber zumindest gleichwertige nicht gleich. Zudem denke ich, das meine Methode garnicht so übel ist, auch unter streng cryptologischen Gesichtspunkten.

Es wird eine Benutzerschnittstelle, das soll alles möglichst nachvollziehbar sein und nicht verwundern oder gar verärgern. Ich hätte mir die Arbeit ja garnicht gemacht, wenn ich nicht selbst beim Testen plötzlich ganz irritiert gewesen wäre.

Zitat:

Zitat von Die Muhkuh (Beitrag 1050432)

eine Passwortsicherheit anzeigt, die sich jemand ausgedacht hat?

Alles ist ausgedacht... von irgend jemandem, irgendwann. Ich hab's mir ja auch nicht in der dunklen Kammer ausgedacht, sondern mich durch Überlegungen und Beispiele aus dem Internet anregen lassen. Ich verfolge nur nicht die ganz strege entropologische Prüfung, weil ich davon überzeugt bin, dass es das nicht braucht.

Zitat:

Zitat von Die Muhkuh (Beitrag 1050432)

dass die vielen 't' hintereinander eine Brute-Force-Attacke erschweren sollte.

Da habe ich mich Sir Rufo's Einwänden angeschlossen und einen Kompromiss gefunden. Viele gleiche Zeichen werten ein Passwort nicht mehr auf, aber auch nicht mehr ab im vergleich zu einem gleichen Passwort, dem nur die wiederholten Zeichen fehlen.

***

Ich schreibe nacher Hagen eine Mail, er hat ja in jedem Fall viel Erfahrung in dem Bereich und möchte Stellung beziehen.

[Reinhard Kern]

Zitat:

Zitat von Satty67 (Beitrag 1050443)

Alles ist ausgedacht... von irgend jemandem, irgendwann. ....

Hallo,

ein grundsätzlicher Einwand: man kann (soll) Passwörter so erzeugen, dass die Folge völlig zufällig ist, z.B. mit einem Passwortgenerator. Das ist auch garkein Problem, aber umgekehrt ist es sehr schwer festzustellen, ob eine Buchstabenfolge zufällig ist (was immer das heisst, denn unter den zufälligen Folgen befinden sich ja auch alle sinnvollen Wörter).

Beispiele: VWLOHFZ HAMBURG LJYQXVD SCHATZI UZMZUOE

Eigentlich müssten Hamburg und Schatzi mit 0, die 3 anderen (generierten) mit 1 bzw. der für 7 Buchstaben höchsten Zahl bewertet werden. Ich schätze das geht nicht ohne Wörterbuch, und das müsste für jedes Land anders sein.

Gruss Reinhard

[Namenloser]

Noch wichtiger als die Anzahl und Entropie der Zeichen wäre imo zu prüfen, ob das Passwort zum Großteil aus einem oder 2 Wörtern besteht. Die meisten Angreifer werden nicht alle Möglichkeiten bruteforcen sondern einfach eine Wörterbuchattacke durchführen, mit der sie vielleicht bei 50% der Nutzer erfolgreich sind. Es gibt im Internet Listen mit häufig verwendeten Wörtern oder sogar häufig verwendeten Passwörtern.
Wenn ein Wort gefunden wird, sollte es als nur ein (oder 2?) Buchstabe(n) gewertet werden. (DasPferdFrisstGerneGurkenSalat ist ja schließlich nicht unsicherer als SPFGGS, genauer gesagt ist es sogar sicherer, weil es mehr Wörter als Buchstaben gibt).
Kommt halt darauf an, wie viel Aufwand du in die Passwortprüfung investieren willst...
[edit]Reinhard Kern war schneller...[/edit]

[cookie22]

Zitat:

Keyboard-Layout: QWERTZ und CO, was Hagen bei sich implementiert hat

wenn du dein programm nur in einem land nutzt ist das relativ einfach, schwieriger wird es wenn es international ist.

Zitat:

Wenn eines der häufig genutzen Passwörter eingegeben wird

du kannst dir im netz ein password wörterbuch beschaffen, es gibt dort welche mit den 3000-4000 meist genuzten passwörtern.

[Satty67]

Ja, eine Liste der häufigsten Passwörter zum ausschließen ist auf der ToDo-Liste (siehe erster Post). Das mache ich aber erst, wenn der Code in ein TPasswortEdit eingebaut wird. Die Liste kommt nicht fest in den Code sondern wird per Property publiziert. Dann kann man die auch noch in der Anwendung pflegen und aktualisieren und evtl. auf Wörterbuchgröße erweitern.

Das "Wörter einer Sprache" eine großes Problem sind, hab' ich auch gelesen, genauso Namen und eben Kombinationen daraus. Derzeit ist nur ein Methode drin, die Passwörter aus nur Buchstaben abwertet. Reinhards Beispiel zeigt schön, dass es mathematisch wohl keine sprachübergreifende gute Lösung für das Problem gibt. Mein Ansatz "drängt" den Anwender nur dazu, Zahlen und Sonderzeichen einzubauen, um auf einen besseren Wert zu kommen.

Die im Moment noch als Konstanten in der Funktion vorhandenen Werte, werden später auch als Property angeboten. Um den Einwänden Rechnung zu tragen,wird noch Bewertung der Länge und Abwertung von "Nur Buchstaben"-Passwörtern einstellbar. Neben der Manupulation der Einzel-Faktoren, kann ich dann auch Profile anbieten, die von locker bis streng voreinstellen.

Ich denke der Code ist schon recht flexibel... setze ich z.B. DiffCharsMaxMulti = 100, ist die Entropie fast schon strenger wie bei PassphraseQuality.

***

Was die Komplexität angeht... für das aktuelle Projekt nicht nötig. Dort wird auch nur angezeigt, nicht ein mindest Wert vorgeschrieben. Es sind Fahrzeug-Dokumente, keine geheimen Staatsakten. Aber soll ja alles wiederverwertbar sein und notfalls auch höheren Ansprüchen genügen.

[Namenloser]

Vielleicht könnte man als Annäherung analysieren, welche Buchstaben oder Buchstabenpaare oder Silben in der jeweiligen Sprache statistisch am häufigsten aufeinander folgen und dann diese Folgen in den Passwörtern abwerten? Somit muss man nicht ein komplettes Wörterbuch "mitschleppen", sondern nur ein vergleichsweise kleines Sprachprofil. Man könnte vielleicht sogar ein neuronales Netz dafür nehmen.

Ich habe aber keine Ahnung, wie gut so etwas funktionieren würde. Möglicherweise ist die Idee auch nur Mist...

[BUG]

Hier gibt es einen Online-Passwortchecker von Microsoft in JavaScript.


EDIT:
Auf StackOverFlow gibt es auch Anregungen.

U.A. dort für interessant befunden:

• John the Ripper :arrow: passwdqc
• CrackLib (Anleitung)

algorithm password strength findet auch eine ganz Menge Bibliotheken. Viele scheinen einen heuristischen Ansatz zu verfolgen.

[cookie22]

Zitat:

Hier gibt es einen Online-Passwortchecker von Microsoft in JavaScript.

der bestimmt aber nur die passwortlänge, sonst nichts.

[Satty67]

Zitat:

Zitat von BUG (Beitrag 1050502)

Auf StackOverFlow gibt es auch Anregungen.

Ja, da hab' ich mich für den mittleren Prüfteil insperieren lassen:

Zitat:

* At least one uppercase and one lowercase letter
* At least one number
* At least one special character

wobei ich das in der Schleife im Case-Block prüfe.

Dezeit wird ja geprüft:

• Eventuell ein Datum? -> auf Zahlen reduzieren (da nur Zahlen sowieso ein schlechtes Ergebnis bringen)
• Wiederholdende Zeichen? -> nur das erste bewerten (da das scheinbar kein großen Vorteil bringt)
• Mindestens je ein Groß/KleinBuchstabe, Zahl, Sonderzeichen vorhanden?
• Anzahl unterschiedlicher Zeichen im Passwort (Entropie)
• Länge des Passwortes

Punkt 1/2 passen nur das zu prüfende Passwort (intern) an, also schneiden Punkte bzw. Zeichenwiederholungen aus.

Punkt 3 vergibt pro Zeichengruppe einen Multiplikator-Anteil, der später aufaddiert wird. Sind aber nur Groß/Klein-Buchstaben vorhanden, dann wird abgewertet.

Punkt 4 ergibt je nach Anzahl unterschiedlicher Zeichen zu Länge einen Multiplikator

Punkt 5 Bewertet die Länge expentionel, allerdings etwas abgemildert durch die Log2 Funktion

Am Ende steht ein Entropie-Wert (aus Punkt 3/4) und ein Längen-Wert (aus Punkt 4), die miteinander multipliziert das Ergebnis bilden.

Grundsätzlich sind alle in Tutorials vorgeschlagenen Prüfmethoden drin. Ebenso kann man durch etwas probieren, die Anteile der einzelnen Methoden am Gesamtergebnis verschieben. Wer also auf Entropie einen riesen Wert legt, kann das mit "DiffCharsMaxMulti = 100" machen. Was noch fehlt sind erweiterte Prüfungen wie Keybord-Layout-Check, TopTen-Passwörter-Check und wohl zu aufwändig, ein Wörterbuch-Check.

***

Zum Thema Entropie und Passwortlänge:

Kein Mensch/Hacker setzt sich an den PC und probiert manuell zig Tausend Kombinationen an der Tastatur. Es ist entweder ein wissensbasierter Angriff (Geburtstag/Name des Hundes/Passwort-TopTen), der dann einen Glückstreffer bringt oder ein maschineller Angriff auf den Hashcode.

Beim Angriff mit Hashcode wird wohl erst eine Wörterbuch-Attacke (einzelne/kombinierte Wörter einer Sprache) erfolgen und danach simples BruteForce... also alle Zeichenkombinationen/Längen durchprobiert. Da bin ich davon überzeugt, das leichte Entropie und breite Nutzung des Zeichensatzes und vor allem Länge den maximalen Schwierigkeitsgrad bringen. Eine maximale Entropie ist garnicht nötig, es werden sowieso maschinell alle Zeichen durchgetestet, also die Schleifen für jede Zeichenposition immer komplett durchlaufen.

***

Ich lasse mal das ganze etwas ruhen, ich denke es wurde so ziemlich alles zum Thema angesprochen. Für mich arbeitet die Prüfmethode gut und ich werde die (Logik) ins Projekt übernehmen.

Wenn ich mit dem Hauptprojekt weiter bin, werde ich dann hier noch die resultierenden Komponenten anhängen.

[negaH]

Im originalen Thread zu PassphraseQuality habe ich geschrieben das es keine echte Funktion geben kann die die Qualität eines Passwortes errechnet und auch das die gewählten Schranken in dieser Funktion aus mathematisch krypographischer Sicht sowieso viel zu gering geählt wurden. (würde man sich an math. anerkannten Schranken orientieren so würde man mit ganzen Sätzen mit mehr als 160 Zeichen also Passwörter arbeiten müssen).

Es gibt nur sehr wenige Bewertungfunktionen die man benutzen kann und bei denen man deren Sinnhaftigkeit auch math. als sinnvoll beweisen kann.

Eine ist die Entropie. Entropie lässt sich eindeutig berechnen und ist auch ein Maß für die Zufälligkeit einer Datenmenge. Je zufälliger ein Passwort desto wertvoller. Entropie ist also ein Maß das man ohne Wissen um die vom Angreifer verwendeten Verfahren immer als Maßstab benutzen kann. Die Verfahren zur Berechnung der Entropie sind beweisbar. In meinem Fall habe ich die Enropie der deutschen/englischen Sprache zu Grunde gelegt (der Multiplikationsfaktor ist entscheidend).

Ein weiteres beweisbares Verfahren ist die Wörterdatenbank. Fast alle heutigen kryptologischen Angriffe die besser als die reine Brute Force Attacke sind sind Wörterbuchangriffe. Nachteil für unsere Funktion ist die Wörterdatenbank ansich, es ist unpraktikabel bzw. in Relation zu einem echten Zufallspasswort ist eine Wörterdatenbank für unsere Funktion vom Aufwand-Nutzen-Verhältnis absoluter Schwachsinn.

Das Problem mit solchen Bewertungsfunktion ist der Fakt das man nur gute Funktionen konstruieren kann wenn man den Angriff exakt kennt der auf das Passwort angewendet wird. Man kennt den Angriff nicht ergo kann man nur eine allgemeingültige Funktion bauen, bzw. nur das lohnt sich im Vergleich zu echten Zufallspasswörtern.

Man kann noch einfachste Kriterien berücksichtigen zb. eben Tastaturlayouts etc.pp. wie in meiner Funktion auch geschehen. Mehr lohnt aber nicht.

Fazit: solche Funktionen sind niemals ein gutes Indiz für die reale Qualität eines Passwortes. Selbst das komplizierteste, längste und zufälligste Passwort muß 0% ergeben wenn es Allen im WEB bekannt gemacht wird oder wenn es einen Hacker schon längst bekannt ist. Dann wissen wir das noch nichtmal und das zeigt schon das solche Funktionen im Grunde das Unmögliche versuchen.

Es ist und bleibt in irgendeiner Form immer eine "Gimmeck-Funktion".

Nun könnte der Einwand kommen warum ich mit dieser Überzeugung überhaupt eine solche Funktion veröffentlicht habe ?

Weil sie besser und math. korrekter ist als viele der anderen Funktionen die im WEB kursieren.
Und weil es offensichtlich einen Bedarf für solche Funktionen gibt.

Was du nun als "falsches" oder "unlogisches" Ergebnis betrachtest ist reine Ansichtssache oder besser gesagt Definitionssache. In deiner Betrachtungsweise mag dein Passwort mit den vielen t's besser sein als das mit den wenigen t's, aber kannst du mir auch math. beweisbar begründen warum ich deiner Betrachtungsweise zustimmen sollte ? Ich argumentiere das meine Funktion einfach math. die Entropie als Merkmal einer Datenmenge berechnet und daraus gewichtet die Qualität bewertet. Ich kann verargumentieren das uns dieser Weg als Denkmodel offensteht und kryptographisch korrekt sein muß innerhalb des angenommenen Modells. Dh. alles basiert auf beweisbarem Wissen und nicht gefühlsmäßigen Annahmen, und das ist der wirklich wichtige Punkt bei der ganzen Diskussion. Damit möchte ich nicht sagen das du mit deiner Annahme falsch liegst o.ä. sondern nur darlegen was man letzendlich an Informationen auswerten und als Bewertung überhaupt sinnvollerweise heran ziehen kann.

Letzendlich gilt folgendes:
1.) zufällige Passwörter sind der Maßstab an dem wir uns orientieren müssen
2.) die annerkannten Sicherheitsschranken für Zufallspasswörter sind unsere Bewertungsgrundlage, dh. also zb. > 128 Bits bei symmetrischen Verchlüsselungen. Diese Schranken sind durch Mathematiker errechnet.
3.) je weniger zufällig desto höher die Wahrscheinlichkeit für eine Semantik, desto höher die Wahrscheinlichkeit für Wörterbuchangriffe bzw. Angriffe mit bekanntem Wissen
4.) Entropie ist ein Maßstab für Zufälligkeit
5.) ergo: Entropie kann als primäres Kriterium für die Bewertung heran gezogen werden (neben der Länge des Passwortes)

Welche Gewichtung man benutzt zwischen Entropie, Länge usw. des Passwortes ist reine Erfahrungssache und du wirst darüber meiner Kenntnis nach nichts an Material im WEB finden (ausser pauschalen Aussagen). Nun, exakt diese Gewichtung der Faktoren innerhalb der Geamtbewertung der Qualität ist es die in deinem Falle so "unlogische" Resultate erzeugt. Gebe mir eine bessere Gewichtung die du eventuell an Hand von Fakten auch math. beweisen kannst.

Gruß Hagen

[Satty67]

Erst mal Danke, das du dir die Mühe gemacht hast so ausführlich zu antworten. Es war wichtig, dass Du Deinen Standpunkt hier so deutlich gemacht hast. Es erleichtert den Leuten zu entscheiden, wenn Sie eine Methode suchen.

****

Letzlich ist die Frage, ob Satty67 sicher ist als Sattttttttty67 nicht nicht zu beweisen, wenn ich deiner Argumentation folge. Deine Funktion sagt, dass o.a. kürzere Passwort ist sicherer. Ich vermute, das längere Passwort ist sicherer als das kürzere, wenn das kürzere Bestandteil des längeren ist. Das ist halt nur simple Logik. Die Anzahl unterschiedlicher Zeichen ist ja die gleiche, aber die Entropie wird schlechter, weil Gesamt-Verteilung schlechter wird. Im Prinzip kann bei strenger Entropie-Prüfung ein langes Passwort nur noch schlechter werden, wenn einem die Zeichen ausgehen. Ich könnte mich anschließen, wenn man behauptet, es wird dann nicht besser, aber schlechter kann ich einfach nicht nachvollziehen.

Es ist aber nicht wirklich schlimm, das wir da nicht 100% gleicher Meinung sind. Ich hatte es schon geschrieben und schreibe es nochmal: Deine Funktion riskiert zumindest nie, ein schlechteres Passwort besser zu bewerten.

Zitat:

Zitat von negaH (Beitrag 1052246)

Gebe mir eine bessere Gewichtung die du eventuell an Hand von Fakten auch math. beweisen kannst.

Du hast ja selbst geschrieben, dass es so einen (entgültigen) Beweis für keine Prüfmethode geben kann. Daher ist im Prinzip auch eine Diskussion um die bessere Methode sinnlos. €: Ich weis, das ich selbst die Diskussion angestossen hab', aber da kannte ich noch nicht die Gegenargumente.

[Reinhard Kern]

Zitat:

Zitat von negaH (Beitrag 1052246)

1.) zufällige Passwörter sind der Maßstab an dem wir uns orientieren müssen
2.) die annerkannten Sicherheitsschranken für Zufallspasswörter sind unsere Bewertungsgrundlage, dh. also zb. > 128 Bits bei symmetrischen Verchlüsselungen. Diese Schranken sind durch Mathematiker errechnet.
3.) je weniger zufällig desto höher die Wahrscheinlichkeit für eine Semantik, desto höher die Wahrscheinlichkeit für Wörterbuchangriffe bzw. Angriffe mit bekanntem Wissen
4.) Entropie ist ein Maßstab für Zufälligkeit
5.) ergo: Entropie kann als primäres Kriterium für die Bewertung heran gezogen werden (neben der Länge des Passwortes)

Hallo Hagen,

offensichtlich hast du die Diskussion überhaupt nicht gelesen. Deine Argumentation ist Nonsense: eine beliebige Zeichenfolge aus 7 Buchstaben ist schon ein ziemlich starkes Passwort, allerdings ist z.B. "Schatzi" völlig unbrauchbar (ich hoffe, das muss ich dir nicht auch noch erklären), und das geht aus der Entropie nicht hervor. Zudem gilt das nur in Deutschland, in Indien sind ganz andere Wörter schwache Passwörter.

Die Entropie besagt absolut nichts. Allenfalls könnte man auf sprachübliche Silben prüfen, aber damit eliminiert man sprechbare Wörter und nicht nur sinnvolle, ausserdem hat das ja auch nichts mit Entropie zu tun.

Alle existierenden Algorithmen zur Bestimmung der Passwortstärke sind hilflose Ersatzrechnereien im Bewusstsein der Tatsache, dass es keinen wirklichen Algorithmus gibt - oder eben auch ohne das Bewusstsein, davon wird der Algorithmus aber nicht besser.

Übrigens kann natürlich auch ein zufälliger Passwortgenerator "Schatzi" liefern, aber die Wahrscheinlichkeit ist erträglich gering, und der User muss es ja nicht nehmen, Verstand ist manchmal auch ganz nützlich.

Gruss Reinhard

[himitsu]

Zitat:

offensichtlich ... "Schatzi" ... schwache Passwörter.

Zu den "Wörterbüchern" hatt er doch was gesagt?

Wenn "Schatzi" demjenigen, welcher das Passwort erraten soll, nicht bekannt ist, dann ist dieses Passwort genauso sicher, wie z.B. "umflcRa".

Du müßtest allso in die Prüfung ein Wörterbuch einbinden,
nur gibt es da ein Problem. denn du kennst das Wörterbuch des Angreifers nicht.
Es gibt also vermutlich Wörter, welche der Angreifer kennt/verwendet, aber weil dein Wörterbuch es nicht kennt, würde dein Code dann behaupten das Passwort wäre sicher ... mit etwas Pech steht dieses Wort dann auch noch am Anfang der Wörterlist und ist ratzfatz geknackt.



Eventuell könnte man zur Entropie noch eine gramatikalische Prüfung nutzen, welche dann mit mehrere Sprachen prüft, ob das Word in dieses Sprachen ein "aussprechbares" Wort wäre.

Nur lassen sich "sprechbare" Wörter besser merken und werden gern benutzt.

[Satty67]

Mir ist zumindest klar, das es wohl nur schwer bis garnicht realisierbar ist, alles abzudecken. Ich kann der Argumentation (von Hagen) zumindest soweit folgen, das es zwar ein gutes aber nie ein ideales Vorschlagsystem geben kann, weil man es nicht nachweisen könnte. Das ich Ihm in Sachen Entropie nicht 100% folgen kann, habe ich ja oben geschrieben.

Mir ging es aber vor allem um eines:

Wenn der Benutzer bei der Passwort-Bewertung so ins Grübeln kommt, wie ich, dann zweifelt er an meinem ganzen Programm. Das ist nicht schön ;)

Zitat:

Zitat von Reinhard Kern (Beitrag 1052305)

Verstand ist manchmal auch ganz nützlich.

Das ist wohl das wichtigste. Das Eingabefeld bekommt einen deutlichen Hinweis, dass die Bewertung nur eine Hilfestellung ist, aber kein Garant für ein sicheres Passwort.

PS: Auf die Bewertung verzichten will ich aber auch nicht, für die meisten ist es ein Ansporn, die LED auf "grün" zu bringen ;)

[hathor]

Beispiel:

€~}|{`_^]\[@?>=<;:/.-,+*)('&%$#"!

Sicherheit bei annähernd 69,4%

Da habe ich mehr erwartet!
---------------------------------------------------
€~}|{`_^]\[@?>=<;:/.-,+*)('&%$#"!zZ

Sicherheit bei annähernd 91,7%
---------------------------------------------------
€~}|{`_^]\[@?>=<;:/.-,+*)('&%$#"!zZ1

Sicherheit bei annähernd 100,0%
---------------------------------------------------
{`_^]\[@?>=<;:/.-,+*)('&%$#"!zZ1

Sicherheit bei annähernd 100,0%
---------------------------------------------------
{ö_ü]ß[@?>=<;:/.-,+*)(ä&%$#"!zZ1

Sicherheit bei annähernd 100,0%

[Satty67]

...und bei PassphraseQuality? 54,9% bzw. 58,9%

Der Grund ist aber schnell genannt. Nur Sonderzeichen sind knapp 30 auf der Tastatur erreichbare Zeichen. Mit einer Ziffer erhöhst Du auf weitere 10 Zeichen... das gleiche bei Buchstaben.

Bei TPasswortCheck (Komponente auf Basis des Codes): 69,4 bzw. 77,8%

Dort wurden die Multiplikatoren nochmal justiert. Ich konnte den Code hier nicht mehr aktualisieren (24h Sperre).

***

Ich könnte den entgültigen Code, der aktuell auch in TPasswortCheck verbaut ist, hier posten. Vielleicht auch einen Moderator bitten, im ersten Post ein Verweis auf den anderen Thread zu setzen oder den Code auszutauschen.

[Reinhard Kern]

Hallo,

es ist zwar schon alles gesagt, wenn auch noch nicht von allen im Forum, aber noch eine kleine Frage zur Ergänzung:

wie stark ist das Passwort "Cwmdauddwr" ?

Auflösung: das ist ein Vorort von Rhayader in Wales, google liefert 44000 Treffer. Die Passwortstärke sollte also in der gegend von Null liegen.

Was mich auf die Idee bringt, ein mögliches Passwort zu googlen und den Kehrwert der Treffer zu verwenden.

Gruss Reinhard

[hathor]

Cwmdauddwr

21,8%

[Satty67]

...und bei PassphraseQuality? und bei der verfeinerten Funktion in TPasswortCheck?

Ich erspare mir alle genannten Beispiele mit den Alternativen zu vergleichen. Wer ernsthaft vergleichen will, kann es selber machen. Wie gesagt, eine perfekte Funktion kann es nicht geben, zuviele Fallen.

Hier die entgültige Methode, wie sie im Forum in TPasswortCheck vorgestellt wurde. (Nur schnell wieder aus der Komponente rausgeschnippelt, kein Schönheitspreis erwartet ;) )

Delphi-Quellcode:

unit UPasswordCheckFunktion;

interface

function GetPasswordStrength(Password: String; ForceEntropy : Boolean = false): Extended;

implementation

uses
  SysUtils, math;

function RemoveRepetitions(const AString : string): String;
var
  i : Integer;
begin
  Result := AString;
  i := 2;
  while i <= Length(Result) do
  begin
    if Result[i] = Result[i-1] then
      Delete(Result, i, 1)
    else
      inc(i);
  end;
end;

function RemoveDateSeparator(const AString : string): String;
var
  i : Integer;
  dt : TDateTime;
begin
  i := Length(AString);
  if (i > 0) and (AString[i] = DateSeparator) then
    Result := Copy(AString, 1, i-1)
  else
    Result := AString;

  if TryStrToDate(Result, dt) then
    Result := StringReplace(AString, DateSeparator, '', [rfReplaceAll]);
end;

function GetPasswordStrength(Password: String; ForceEntropy : Boolean = false): Extended;
var
  FLowerMultiplicator   : Extended;
  FUpperMultiplicator   : Extended;
  FNumericMultiplicator : Extended;
  FSignMultiplicator    : Extended;
  FDiffCharsMaxMulti    : Extended;
  FLengthMultiplicator  : Extended;

  FMinPasswordLength    : Integer;
  FMaxPasswordLength    : Integer;

  procedure InitPasswordCheck(ForceEntropie : Boolean);
  begin
    FLowerMultiplicator   := 19;
    FUpperMultiplicator   := 21;
    FNumericMultiplicator := 15;
    FSignMultiplicator    := 25;
    FDiffCharsMaxMulti    := 100;
    FLengthMultiplicator  := 20;

    FMinPasswordLength    := 4;
    FMaxPasswordLength    := 32;

    if ForceEntropie then
      FDiffCharsMaxMulti := FDiffCharsMaxMulti * 10;
  end;

  function LengthMul(const CurrentLength, MaxLength : Integer): Extended;
  begin
    if CurrentLength > MaxLength then
      Result := Math.Log2(MaxLength) * Math.Log2(MaxLength)
    else
      Result := Math.Log2(CurrentLength) * Math.Log2(CurrentLength);

    Result := Result * FLengthMultiplicator;
  end;

  function CalculateEntropie(CleanPWLength, DiffCharsCount : Integer;
                  LowerMul, UpperMul, NumericMul, SignMul: Extended):Extended;
  begin
    Result := (DiffCharsCount * FDiffCharsMaxMulti) / CleanPWLength;
    if (NumericMul + SignMul) = 0 then
      Result := Result + ((LowerMul + UpperMul) / 2)
    else
      Result := Result + LowerMul + UpperMul + NumericMul + SignMul;
  end;

  function GetBestResult: Extended;
  begin
    Result := CalculateEntropie(1, 1, FLowerMultiplicator, FUpperMultiplicator,
                                FNumericMultiplicator, FSignMultiplicator);
    Result := Result * LengthMul(FMaxPasswordLength, FMaxPasswordLength);
  end;

var
  i, CleanPWLength : Integer;
  CleanPassword,
  DiffChars : String;
  EntropieMul,
  LowerMul, UpperMul,
  NumericMul, SignMul : Extended;
begin
  Result     := 0;

  LowerMul   := 0;
  UpperMul   := 0;
  NumericMul := 0;
  SignMul    := 0;

  InitPasswordCheck(ForceEntropy);
  CleanPassword := Trim(Password);
  CleanPassword := RemoveDateSeparator(CleanPassword);
  CleanPassword := RemoveRepetitions(CleanPassword);

  CleanPWLength := Length(CleanPassword);
  if (CleanPWLength >= FMinPasswordLength) then
  begin

    for i := 1 to Length(CleanPassword) do
    begin
      case CleanPassword[i] of
        'a'..'z', ' ' : LowerMul   := FLowerMultiplicator;
        'A'..'Z' : UpperMul   := FUpperMultiplicator;
        '0'..'9' : NumericMul := FNumericMultiplicator;
      else
        SignMul := FSignMultiplicator;
      end;

      if Pos(CleanPassword[i], DiffChars) < 1 then
        DiffChars := DiffChars + CleanPassword[i];
    end;

    EntropieMul := CalculateEntropie(CleanPWLength, Length(DiffChars),
                                     LowerMul, UpperMul, NumericMul, SignMul);

    Result := EntropieMul * LengthMul(CleanPWLength, FMaxPasswordlength);
    Result := Result / GetBestResult;
  end;
end;

end.

[Satty67]

(Sorry für Doppelpost, aber mit dem Code im Post oben, wäre das arg unübersichtlich geworden)

Zitat:

Zitat von Reinhard Kern (Beitrag 1052450)

Was mich auf die Idee bringt, ein mögliches Passwort zu googlen und den Kehrwert der Treffer zu verwenden.

Wie gesagt, ich hab' akzeptiert das es ein riesen Projekt werden würde und eine ideale Prüfmethode fast unmöglich. Mein Ziel, wenigstens nicht unlogisch "auszusehen" habe ich aber mit der letzten Version annähernd erreicht.

Die Idee mit Google ist übrigens richtig gut, denke da werden auch verschiedene Sprachen gut abgedeckt. €: Wäre es ein Passwort-Generator, wäre das eine gute Methode, um das zufällig erzeugte Passwort nochmal zu checken.

[BUG]

Zitat:

Zitat von Satty67 (Beitrag 1052464)

Die Idee mit Google ist übrigens richtig gut, denke da werden auch verschiedene Sprachen gut abgedeckt. €: Wäre es ein Passwort-Generator, wäre das eine gute Methode, um das zufällig erzeugte Passwort nochmal zu checken.

:shock: Ein Passwort im Klartext durchs Internet an Google zu schicken ist eine gute Idee?

[Satty67]

Nein, Google lädt man sich vorher runter auf einen USB-Stick oder so... naja, wie gesagt, irgend etwas übersicht man immer ;) (Womit es aber auch beim Check leider nicht wirklich sinnvoll wäre)

Wer sich den Spass machen will, in der Anlage eine Exe, die schlicht die beiden Funktionen gegenüber stellt. Es ist wohl mit etwas Suche immer möglich, für beide Funktionen einen Satz Passwörter zu finden, wo diese blöd aussehen.

[Sir Rufo]

Diesen Password-Prüfer http://www.passwordmeter.com finde ich gar nicht mal so übel.

[Satty67]

hab' gleich mal Satty67 und Sattttttty67 eingegeben (duck und weg...)

Ne, also sehr interessant. Man kann auch schön verfolgen, wie einzelne Eingaben bewertet werden. Allgemein geht es aber fast zu schnell Richtung 100%. Da bleibt wenig Luft für Leute, die komplexere Passwörter mögen. Aber das kann man sicher anpassen.

[Sir Rufo]

Ich habe das mal übersetzt

Delphi-Quellcode:

unit uPassStrength;

interface

type
  TPassphraseStrength = ( psVeryWeak, psWeak, psGood, psStrong, psVeryStrong );

  TPassphraseInfo = record
    Length : integer;
    AlphaUC : integer;
    AlphaLC : integer;
    Number : integer;
    Symbol : integer;
    MidChar : integer;
    Requirements : integer;
    AlphasOnly : integer;
    NumbersOnly : integer;
    UnqChar : integer;
    RepChar : integer;
    RepInc : Extended;
    ConsecAlphaUC : integer;
    ConsecAlphaLC : integer;
    ConsecNumber : integer;
    ConsecSymbol : integer;
    ConsecCharType : integer;
    SeqAlpha : integer;
    SeqNumber : integer;
    SeqSymbol : integer;
    SeqChar : integer;
    ReqChar : integer;
    MultConsecCharType : integer;
    function Score : integer;
    function ScoreStr : string;
    function Strength : TPassphraseStrength;
    procedure Clear;
  end;

procedure PassphraseAnalyseEx( const Password : string; out PassphraseInfo : TPassphraseInfo );
function PassphraseScore( const Password : string ) : integer;
function PassphraseStrength( const Password : string ) : TPassphraseStrength;

implementation

uses
  SysUtils, Math;

function StringReverse( const Str : string ) : string;
  var
    idx : integer;
  begin
    Result := '';
    for idx := 1 to Length( Str ) do
      Result := Str[ idx ] + Result;
  end;

procedure PassphraseAnalyseEx( const Password : string; out PassphraseInfo : TPassphraseInfo );
  const
    AlphasUC = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    AlphasLC = 'abcdefghijklmnopqrstuvwxyz';
    Alphas = 'abcdefghijklmnopqrstuvwxyz';
    Numerics = '0123456789';
    Symbols = ')!@#$%^&*()';
    MinLength = 8;
    MinAlphaUC = 1;
    MinAlphaLC = 1;
    MinNumber = 1;
    MinSymbol = 1;
  var
    a : integer;
    TmpAlphaUC, TmpAlphaLC, TmpNumber, TmpSymbol : integer;
    b : integer;
    CharExists : Boolean;
    S : integer;
    Fwd, Rev : string;
    pwd : string;
  begin
    // Initialisierung
    TmpAlphaUC := 0;
    TmpAlphaLC := 0;
    TmpNumber := 0;
    TmpSymbol := 0;

    pwd := StringReplace( Password, ' ', '', [ rfReplaceAll ] );

    PassphraseInfo.Clear;
    PassphraseInfo.Length := Length( pwd );

    // Durchsuche das Passwort nach Symbolen, Nummern, Groß- und Kleinschreibung
    for a := 1 to Length( pwd ) do
      begin

        // Großbuchstaben
        if Pos( pwd[ a ], AlphasUC ) >= 1 then
          begin
            if ( TmpAlphaUC > 0 ) then
              begin
                if ( TmpAlphaUC + 1 = a ) then
                  begin
                    inc( PassphraseInfo.ConsecAlphaUC );
                    inc( PassphraseInfo.ConsecCharType );
                  end;
              end;
            TmpAlphaUC := a;
            inc( PassphraseInfo.AlphaUC );
          end

          // Kleinbuchstaben

        else if Pos( pwd[ a ], AlphasLC ) >= 1 then
          begin
            if ( TmpAlphaLC > 0 ) then
              begin
                if ( TmpAlphaLC + 1 = a ) then
                  begin
                    inc( PassphraseInfo.ConsecAlphaLC );
                    inc( PassphraseInfo.ConsecCharType );
                  end;
              end;
            TmpAlphaLC := a;
            inc( PassphraseInfo.AlphaLC );
          end

          // Ziffern

        else if Pos( pwd[ a ], Numerics ) >= 1 then
          begin
            if ( a > 1 ) and ( a < Length( pwd ) ) then
              inc( PassphraseInfo.MidChar );
            if ( TmpNumber > 0 ) then
              begin
                if ( TmpNumber + 1 = a ) then
                  begin
                    inc( PassphraseInfo.ConsecNumber );
                    inc( PassphraseInfo.ConsecCharType );
                  end;
              end;
            TmpNumber := a;
            inc( PassphraseInfo.Number );
          end

          // Symbole

        else if Pos( pwd[ a ], AlphasLC + AlphasUC + Numerics ) < 1 then
          begin
            if ( a > 1 ) and ( a < Length( pwd ) ) then
              inc( PassphraseInfo.MidChar );
            if ( TmpSymbol > 0 ) then
              begin
                if ( TmpSymbol + 1 = a ) then
                  begin
                    inc( PassphraseInfo.ConsecSymbol );
                    inc( PassphraseInfo.ConsecCharType );
                  end;
              end;
            TmpSymbol := a;
            inc( PassphraseInfo.Symbol );
          end;

        // Doppelte Zeichen prüfen
        CharExists := False;
        for b := 1 to Length( pwd ) do
          if ( a <> b ) and ( pwd[ a ] = pwd[ b ] ) then
            begin
              CharExists := true;
              PassphraseInfo.RepInc := PassphraseInfo.RepInc + ( Length( pwd ) / Abs( b - a ) );
            end;
        if CharExists then
          begin
            inc( PassphraseInfo.RepChar );
            PassphraseInfo.UnqChar := Length( pwd ) - PassphraseInfo.RepChar;
            if PassphraseInfo.UnqChar <> 0 then
              PassphraseInfo.RepInc := Ceil( PassphraseInfo.RepInc / PassphraseInfo.UnqChar )
            else
              PassphraseInfo.RepInc := Ceil( PassphraseInfo.RepInc );
          end;
      end; // for a := 1 to Length( pwd ) do

    for S := 1 to Length( Alphas ) - 2 do
      begin
        Fwd := Copy( Alphas, S, 3 );
        Rev := StringReverse( Fwd );
        if ( Pos( Fwd, LowerCase( pwd ) ) >= 1 ) or ( Pos( Rev, LowerCase( pwd ) ) >= 1 ) then
          begin
            inc( PassphraseInfo.SeqAlpha );
            inc( PassphraseInfo.SeqChar );
          end;
      end;

    for S := 1 to Length( Numerics ) - 2 do
      begin
        Fwd := Copy( Numerics, S, 3 );
        Rev := StringReverse( Fwd );
        if ( Pos( Fwd, LowerCase( pwd ) ) >= 1 ) or ( Pos( Rev, LowerCase( pwd ) ) >= 1 ) then
          begin
            inc( PassphraseInfo.SeqNumber );
            inc( PassphraseInfo.SeqChar );
          end;
      end;

    for S := 1 to Length( Symbols ) - 2 do
      begin
        Fwd := Copy( Symbols, S, 3 );
        Rev := StringReverse( Fwd );
        if ( Pos( Fwd, LowerCase( pwd ) ) >= 1 ) or ( Pos( Rev, LowerCase( pwd ) ) >= 1 ) then
          begin
            inc( PassphraseInfo.SeqSymbol );
            inc( PassphraseInfo.SeqChar );
          end;
      end;

    if ( PassphraseInfo.AlphaLC + PassphraseInfo.AlphaUC > 0 ) and ( PassphraseInfo.Symbol = 0 ) and
      ( PassphraseInfo.Number = 0 ) then
      PassphraseInfo.AlphasOnly := Length( pwd );

    if ( PassphraseInfo.AlphaLC + PassphraseInfo.AlphaUC = 0 ) and ( PassphraseInfo.Symbol = 0 ) and
      ( PassphraseInfo.Number > 0 ) then
      PassphraseInfo.NumbersOnly := Length( pwd );

    if ( PassphraseInfo.Length > 0 ) and ( PassphraseInfo.Length >= MinLength ) then
      inc( PassphraseInfo.ReqChar );
    if ( PassphraseInfo.AlphaUC > 0 ) and ( PassphraseInfo.AlphaUC >= MinAlphaUC ) then
      inc( PassphraseInfo.ReqChar );
    if ( PassphraseInfo.AlphaLC > 0 ) and ( PassphraseInfo.AlphaLC >= MinAlphaLC ) then
      inc( PassphraseInfo.ReqChar );
    if ( PassphraseInfo.Number > 0 ) and ( PassphraseInfo.Number >= MinNumber ) then
      inc( PassphraseInfo.ReqChar );
    if ( PassphraseInfo.Symbol > 0 ) and ( PassphraseInfo.Symbol >= MinSymbol ) then
      inc( PassphraseInfo.ReqChar );

    PassphraseInfo.Requirements := PassphraseInfo.ReqChar;
  end;

function PassphraseScore( const Password : string ) : integer;
  var
    pi : TPassphraseInfo;
  begin
    PassphraseAnalyseEx( Password, pi );
    Result := pi.Score;
  end;

function PassphraseStrength( const Password : string ) : TPassphraseStrength;
  var
    pi : TPassphraseInfo;
  begin
    PassphraseAnalyseEx( Password, pi );
    Result := pi.Strength;
  end;

{ TPassphraseInfo }

procedure TPassphraseInfo.Clear;
  begin
    Length := 0;
    AlphaUC := 0;
    AlphaLC := 0;
    Number := 0;
    Symbol := 0;
    MidChar := 0;
    Requirements := 0;
    AlphasOnly := 0;
    NumbersOnly := 0;
    UnqChar := 0;
    RepChar := 0;
    RepInc := 0;
    ConsecAlphaUC := 0;
    ConsecAlphaLC := 0;
    ConsecNumber := 0;
    ConsecSymbol := 0;
    ConsecCharType := 0;
    SeqAlpha := 0;
    SeqNumber := 0;
    SeqSymbol := 0;
    SeqChar := 0;
    ReqChar := 0;
    MultConsecCharType := 0;
  end;

function TPassphraseInfo.Score : integer;
  const
    MultLength = 4;
    MultRepChar = 1;
    MultMidChar = 2;
    MultRequirements = 2;
    MultConsecAlphaUC = 2;
    MultConsecAlphaLC = 2;
    MultConsecNumber = 2;
    MultConsecCharType = 0;
    MultConsecSymbol = 1;
    MultAlphaUC = 2;
    MultAlphaLC = 2;
    MultSeqAlpha = 3;
    MultSeqNumber = 3;
    MultSeqSymbol = 3;
    MultNumber = 4;
    MultSymbol = 6;
  begin
    Result := 0;
    // Additions
    Result := Result + Length * MultLength;
    if ( AlphaUC > 0 ) and ( AlphaUC < Length ) then
      Result := Result + ( Length - AlphaUC ) * MultAlphaUC;
    if ( AlphaLC > 0 ) and ( AlphaLC < Length ) then
      Result := Result + ( Length - AlphaLC ) * MultAlphaLC;
    if ( Number > 0 ) and ( Number < Length ) then
      Result := Result + Number * MultNumber;
    Result := Result + Symbol * MultSymbol;
    Result := Result + MidChar * MultMidChar;
    if Requirements > 3 then
      Result := Result + Requirements * MultRequirements;
    // Deducations
    Result := Result - AlphasOnly;
    Result := Result - NumbersOnly;
    Result := Result - Trunc( RepInc );
    Result := Result - ConsecAlphaUC * MultConsecAlphaUC;
    Result := Result - ConsecAlphaLC * MultConsecAlphaLC;
    Result := Result - ConsecNumber * MultConsecNumber;
    Result := Result - SeqAlpha * MultSeqAlpha;
    Result := Result - SeqNumber * MultSeqNumber;
    Result := Result - SeqSymbol * MultSeqSymbol;

    if Result > 100 then
      Result := 100
    else if Result < 0 then
      Result := 0;
  end;

function TPassphraseInfo.ScoreStr : string;
  begin
    case Strength of
      psVeryWeak :
        Result := 'sehr schwach';
      psWeak :
        Result := 'schwach';
      psGood :
        Result := 'gut';
      psStrong :
        Result := 'stark';
      psVeryStrong :
        Result := 'sehr stark';
    end;
  end;

function TPassphraseInfo.Strength : TPassphraseStrength;
  var
    sc : integer;
  begin
    sc := Score;
    if sc >= 80 then
      Result := psVeryStrong
    else if sc >= 60 then
      Result := psStrong
    else if sc >= 40 then
      Result := psGood
    else if sc >= 20 then
      Result := psWeak
    else
      Result := psVeryWeak;
  end;

end.

[Satty67]

Das ging ja fix :thumb:

Ich würde zwar noch etwas TPassphraseInfo.Score anpassen, damit mehr Luft nach oben ist, aber ansonsten sehr interessant.

[Sir Rufo]

Aus dem Grunde habe ich auch die Ermittlung der Einzelwerte und der Ermittlung des Scores entsprechend getrennt.
Dann ist die Erweiterung der Funktion erheblich einfacher.

Zudem könnte man auch eine entsprechende Bewertungs-Information wie auf der Website anzeigen.

[Satty67]

Gerade etwas gespielt, der Score halbiert gibt (gefühlt) gute Werte und vergleichbar mit den anderen beiden Funktionen.

Am besten das Passwort durch alle 3 jagen und den Mittelwert ausgeben :stupid:

[Reinhard Kern]

Zitat:

Zitat von BUG (Beitrag 1052469)

Zitat:

Zitat von Satty67 (Beitrag 1052464)

Die Idee mit Google ist übrigens richtig gut, denke da werden auch verschiedene Sprachen gut abgedeckt. €: Wäre es ein Passwort-Generator, wäre das eine gute Methode, um das zufällig erzeugte Passwort nochmal zu checken.

:shock: Ein Passwort im Klartext durchs Internet an Google zu schicken ist eine gute Idee?

Hallo,

klar bin ich mir auch über die Gefahren klar. Ein Passwort im Klartext zu verschicken ist zunächst nicht gefährlich, wenn keiner weiss, dass es ein (mögliches) Passwort ist. Aber würde sich mein Vorschlag allgemein durchsetzen, könnte google schnell auf die Idee kommen, für jeden Benutzer zu speichern, was der so anfragt, und daraus eine personalisierte Angriffsliste zu erstellen. An "don't be evil" glaube ich sowieso nicht, selbst wenn das ursprünglich mal ehrlich gemeint war.

Für solche Software ist eine gut entwickelte Paranoia nicht unbedingt Voraussetzung, aber sie hilft doch sehr.

Gruss Reinhard