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

[mleyen]

Zitat von 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.

Hagen hat recht.
Wenn man solche Einflussfaktoren wie Länge, Wörterbuch, Zufälligkeit, etc. nicht mit einbezieht, ist es bei weitem schlechter.

Brechen wir es doch mal aufs einfachste und logischste herrunter.
Wie definiert sich grundlegend die Passwortsicherheit?
Aus der gegebenen Zeichenmenge und die Verwendung von möglichst vielen unterschiedlichen Zeichen aus dieser Zeichenmenge:

Delphi-Quellcode:

function GetPWSecurenessStandard(const AStr: string): Byte;
// Vereinfacht, man könnte zB nach der Überschreitung von MaxDfrntSgns auf die Unterschiedlichkeit prüfen (100% eig. nur erreichbar, wenn man die Länge des Inhalts kennen würde)

  function GetMaxDfrntSgns: Cardinal;
  begin
    Result := Round(Power(2, SizeOf(Char) * 8));
    // Könnte auch sowas sein:
//      Result := Ord('z')+1-Ord('a') {+ Ord('Z')+1-Ord('A')};
  end;

  function CntDfrntSgns: Cardinal;
  var
    i: Integer;
    DfrntSgns: string;
  begin
    for i := 1 to Length(AStr) do
      if Pos(AStr[i],DfrntSgns)<=0 then
        DfrntSgns := DfrntSgns + AStr[i];
    Result := Length(DfrntSgns);
  end;

var
  DfrntSgnsCnt: Cardinal;
  MaxDfrntSgns: Cardinal;
begin
  MaxDfrntSgns := GetMaxDfrntSgns;
  if AStr = '' then
  begin
    Result := IfThen(MaxDfrntSgns = 0, 100, 0);
    Exit;
  end;

  DfrntSgnsCnt := CntDfrntSgns;

  if MaxDfrntSgns = DfrntSgnsCnt then
    Result := 100
  else
    Result := Round(DfrntSgnsCnt / Length(AStr) * 100);
end;

Sobald Doppelungen vorkommen ist es halt nicht mehr die maximal mögliche Sicherheit.

Wenn man jetzt Einflussfaktoren, wie z.B. einen Längenfaktor des Passworts miteinbeziehen will, sollte man folgendes machen:

Delphi-Quellcode:

function GetPWSecurenessLengthFactored(const AStr: string): Byte;
const
  // Setze diese Einflussfaktoren auf ein Maximum, von denen du denkst das es 100% Sicherheit gewährleistet:
  MinSecurePWLength = 10;
  // Prozentuale Einflussfaktoren (0-100):
  SecurenessFactorOfPWLength = 50;

begin
  if Length(AStr) >= MinSecurePWLength then
    Result := 100
  else
    Result := Round(Length(AStr) / MinSecurePWLength * 100);

  Result := Round(
    (SecurenessFactorOfPWLength / 100 * Result) +
    (100 - SecurenessFactorOfPWLength) / 100 * GetPWSecurenessStandard(AStr)
  );
end;

Und ich denke mal genau hier muss man selber weiterdenken. Denn man weiß nicht was für wen eine 100%ig sichere Länge ist. Genausowenig wie man mathematisch weiß was Zufall ist.
Jedoch, wenn man alle Passwörter der Welt kennen würde, könnte man eine favorisierte Passwörter-Liste miteinfließen lassen.
Genauso könnte man auch favorisierte Zeichen, wie z.B.: 'a'..'z', 'A'..'Z' und die 'seltenen' Sonderzeichen mit einfließen lassen.

Nur mathematisch lässt sich sowas nicht bestimmen.
Zu guter letzt nochmal ein (nicht wiedergefundenes) Zitat von Hagen zu einem Faktor der maximalen Sicherheit:
"Das Passwort muss genauso lang sein wie der Inhalt um die mathematisch maximale Sicherheit sicherzustellen?"

Edit:
Ui, sind da noch viele Beiträge zwichenzeitlich reingekommen.
Hier nochmal Einflussfaktoren aufgelistet:
- Passwortlänge
- Die für das Passwort mögliche Zeichenmenge
- Verwendung der Zeichenmenge (zB keine Dopplungen)
- Häufigkeit eines verwendeten Passworts
- Häufigkeit der verwendeten Zeichenmenge
(- Situationsbedingt: Der bekannte verschlüsselte Inhalt, durch den sich auf das Passwort zurückschließen lässt)

Also du hättest aus "Sattttttty67" -> "Sat!ty67" machen können. Dies wäre sicherer, da mehr unterschiedliche Zeichen aus der unbekannten Zeichenmenge verwendet würden.