Passwort auf Sicherheit prüfen

[MrKnogge]

Hi zusammen,

ich möchte ein Passwort auf Sicherheit prüfen(ähnlich wie bei gmx & co)

dazu beachte ich:
länge des Passwortes
Anzahl der verschiedenen Zeichen <- Hier liegt mein Problem
sind Zahlen enthalten
sind die Zahlen nur am ende angehängt, oder mittendrinn

Eigentlich kein grösseres Problem, da ich schon
in der Lage bin die Strings zu zerteilen und auszuwerten,
aber wie soll ich mir "merken" welches Zeichen im Text
schon vorhanden war.

Kann ich das irgendwie mit einer Menge machen ?

[Gast]

Klassifiziere zB alle Zeichen.

Dann

Delphi-Quellcode:

const
Zahl = 1;
Buchstabe = 2;
Sonderzeichen = 4;
//----------------------------
sicher:=0;
for i:=1 to length(s) do
case s[i] of
  '0'..'9': sicher:=sicher or Zahl;
  'a'..'z',
  'A'..'Z': sicher:=sicher or Buchstabe;
  else
    sicher:=sicher or Sonderzeichen;
end;

Wenn du danach pruefst, muss "sicher" = 4 sein sonst ist das Passwort nach deinen Massstaeben unsicher.

[MrKnogge]

Das wäre eine Lösung, aber ich würde schon gerne wissen, wieviele verschiedene Zeichen das Passwort hat.

[Gast]

Jo mei ... erst schreibste, des dir det jefaellt und nu is och wieda net recht.

Also ... erstell dir ein arr:Array[0..$FF] of Integer dann:

Delphi-Quellcode:

ZeroMemory(@arr, sizeof(arr));
for i:=1 to length(s) do
  inc(arr[Byte(s[i])]);

Dann haste fuer jedes Zeichen drinzustehen, wie oft es vorkommt ...

[negaH]

Man muß die Entropy der Zeichen berechnen. Damit ist sozusagen die Redundanz der vorkommenden Zeichen gemeint. Je weniger redundant eine Passphrase ist je besser ist die Qualität.

Delphi-Quellcode:

function PassphraseQuality(const Password: String): Extended;
// returns computed Quality in range 0.0 to 1.0
// source extracted from Delphi Encryption Compendium, DEC

  function Entropy(P: PByteArray; L: Integer): Extended;
  var
    Freq: Extended;
    I: Integer;
    Accu: array[Byte] of LongWord;
  begin
    Result := 0.0;
    if L <= 0 then Exit;
    FillChar(Accu, SizeOf(Accu), 0);
    for I := 0 to L-1 do Inc(Accu[P[I]]);
    for I := 0 to 255 do
      if Accu[I] <> 0 then
      begin
        Freq := Accu[I] / L;
        Result := Result - Freq * (Ln(Freq) / Ln(2));
      end;
  end;

  function Differency: Extended;
  var
    S: String;
    L,I: Integer;
  begin
    Result := 0.0;
    L := Length(Password);
    if L <= 1 then Exit;
    SetLength(S, L-1);
    for I := 2 to L do
      Byte(S[I-1]) := Byte(Password[I-1]) - Byte(Password[I]);
    Result := Entropy(Pointer(S), Length(S));
  end;

  function KeyDiff: Extended;
  const
    Table = '^1234567890ß´qwertzuiopü+asdfghjklöä#<yxcvbnm,.-°!"§$%&/()=?`QWERTZUIOPÜ*ASDFGHJKLÖÄ''>YXCVBNM;:_';
  var
    S: String;
    L,I,J: Integer;
  begin
    Result := 0.0;
    L := Length(Password);
    if L <= 1 then Exit;
    S := Password;
    UniqueString(S);
    for I := 1 to L do
    begin
      J := Pos(S[I], Table);
      if J > 0 then S[I] := Char(J);
    end;
    for I := 2 to L do
      Byte(S[I-1]) := Byte(S[I-1]) - Byte(S[I]);
    Result := Entropy(Pointer(S), L-1);
  end;

const
  GoodLength = 10.0; // good length of Passphrases
var
  L: Extended;
begin
  Result := Entropy(Pointer(Password), Length(Password));
  if Result <> 0 then
  begin
    Result := Result * (Ln(Length(Password)) / Ln(GoodLength));
    L := KeyDiff + Differency;
    if L <> 0 then L := L / 64;
    Result := Result * L;
    if Result < 0 then Result := -Result;
    if Result > 1 then Result := 1;
  end;
end;

Gruß Hagen

[Gast]

Auch ne Variante ... da er aber nichtmal obiges selbst auf die Reihe brachte, ist ein solcher Ansatz vielleicht unangemessen (im Sinne der Verständlichkeit - denn da ist noch Mathe/Physik nötig :))

BTW: Coole neue Wortschöpfung "Differency".

[negaH]

jo, "Differncy" ist doch Russiches Englisch ;-)

Es gab mal Zeiten in Deutschland in denen die eine Hälfte der Deutschen Russich statt Englisch lernen musste, ich hoffe mir sei es verziehen :-)

Zum Code selber. Der Aufruf

Delphi-Quellcode:

Result := Entropy(Pointer(Password), Length(Password));

macht genau das was Asserbad ansprach. Mit

Delphi-Quellcode:

Result := Result * (Ln(Length(Password)) / Ln(GoodLength));

Wird, falls das Passwort ansich gut ist, die Länge des Passwortes als Qualitätsmerkmal eingerechnet. Um so länger es ist um so besser.

"KeyDiff" wiederum testet das passwort auf Buchstabenreihenfolgen die identisch mit der Reihenfolge auf dem Keyboard sind. "QWERTZ" oder "1234556" sind also schlechte Passwörter.

"Differency" :-) wiederum bewertet ob ASCII Reihenfolgen im Passwort sind. Z.b. würde "ABCDEF" schlecht bewertet.

Über Entropy() wird dabei immer die statistische Verteilung, relativ auf das Set aller 256 möglichen ASCII Zeichen berechnet.

Gruß Hagen

[sakura]

@negaH: Ich habe mir mal erlaubt den Code in unsere Library zu kopieren: http://www.delphipraxis.net/viewtopic.php?p=50248#50248

...:cat:...

[MrKnogge]

WoW :shock:

Der Code is mehr als ich suchte und spart mir viel Arbeit :dancer: :dancer2:

Könnte man nicht noch miteinbinden, ob Zahlen im Passwort enthalten sind, und wenn ja ob diese einfach nur hintendran gehängt wurden oder "mitten im Passwort" stehen ?

Also die Funktion ist kein Problem, aber wie bau ich die dann ein ?
(Wie stark muss sowas bewertet werden ?)

[negaH]

Delphi-Quellcode:

ProgressBar.Max := 100;
ProgressBar.Min := 0;
ProgressBar.Value := Round(100 * PassphraseQuality('Passwort'));

Aber, man muß immer wissen das obige Funktion eben nur eine "unintelligente" Art ist ein Passwort zu überprüfen.
Auch als gut bewertete Passwörter können durch Datenbank basierte Angriffe eigentlich schlechte Passwörter sein. D.h. ein Angreifer nutzt eine Datenbank mit den häufigsten Passwörtern. In dieser DB würden viele Passwörter auftreten die durch obigen Algo. als sicher eingestuft wurden. Einzigster Ausweg wäre obige Funktion um diese Datenbank zu erweitern, was aber unmöglich ist :-)

Viel wichtiger wird es dagegen den Benutzer des Passwortes zu schützen.
Erreicht wird dies durch die Anwendung einer secure Hash Function. Diese konvertiert das eingegebene Passwort in eine nicht-rückwandel-bare Form. Sollte eine Verschlüsselung etc. die mit einem solchen konvertierten Passwort erzeugt wurde, gebrochen werden, so ist das eigentlich eingegebene Passwort denoch sicher.
Heutzutage werden häufig Passwörter benutzt die für mehrere verschiedene Accounts gültig sind. Z.b. die PIN des Onlinebankings wird gleichzeitig als Passwort für den Onlinezugang benutzt. Eine "hacker"-Software die dieses passwort direkt ermitteln kann, per Brute Force z.b., würde somit auch Zugang zum Onlinebanking bekommen.
Um dies zu verhindern sollte das Passwort nach Eingabe sofort per hashfunktion in einen Sessionkey umgewandelt werden, und die Eingabe aus dem Speicher gelöscht werden.

Ein guter Passwort-Alswähl-Algorithmus könnte aber basierend auf einer anderen Idee programmiert werden.
Deine Anwendung scannt alle geeigneten Dateien, z.b. im Windows-System Ordner. Der Benutzer muß dann eine dieser Dateien wählen und die Byte-Position, als Zahl, in dieser Datei angeben. Er merkt sich also z.b. "User32.dll" + Position "1356". Nun werden die 256 Bytes aus dieser Datei die an Fileoffset 1356 stehen als Passwort verwendet.
Natürlich kann man diese Datei auch durch Zufall erzeugen, darf dann aber nicht kopiert werden :)

Ein Angreifer muß nun Zugriff auf diese Datei erlangen.

@sakura: wäre nett wenn das "negaH" in Hagen umgewandelt wird :-) Leider war Hagen als Name schon vergeben.

Gruß Hagen