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

[negaH]

Zitat:

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 ?

Dies ist eigentlich nicht nötig. Die Zahlen liegen auf dem Keyboard dicht beieinander und auch im ASCII Code liegen sie dicht beieinander.
D.h. beide Funktionen "KeyDiff" und "Differency" würde ein Passwort das aufeinanderfolgende Zahlen enthält schlechter bewerten.
Z.b. "Test0123" sollte schlechter bewertet werden als "T0e1s2t3" und dieses schlechter als "T2s0e1t3".
Zahlen ansich im Passwort erhöhen dessen Qualität, gegenüber Passwörtern die nur Buchstaben benutzen.
Natürlich ist das Geburtsdatum die allerschlechteste Wahl, aber das ist eine andere Diskussion über Wissensbasierte Angriffsmethoden.

Gruß Hagen

[sakura]

Zitat:

Zitat von negaH

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

Wird sofort getan und vorgemerkt ;-)

...:cat:...

[negaH]

Übrigens, wer sich fragt warum

Delphi-Quellcode:

if L <> 0 then L := L / 64;

benötigt wird, hier die Erklärung.
Es gibt 256 verschiende Zeichen im ASCII Zeichensatz, 256 / 64 = 4.
Normalerweise hat englischer Text eine Entropy von 3.6 Bits pro 8 Bit Zeichen. D.h. englischen Text basierend auf dem ASCII Zeichensatz lässt sich mit ca. 222% komprimieren. Damit wäre ein normales englisches 36 Zeichen Wort nur so sicher wie ein 10 Bytes Speicherrecord der mit echten Zufallszahlen befüllt wurde. Um dieser Entropy Rechnung zu tragen wird mit 64 dividiert.

"Unknackbare" Passwörter sollten ca. 128 Bit lang sein und per Zufall erzeugt werden und nur einmal Verwendung finden 8)

Um mit obiger Funktion gute Passwörter zu erzeugen muß man schon sehr lange Phrasen, Gedichte, Ferse o.ä. eingeben. D.h. ich habe die Parameter so eingestellt das sich ein relativ guter Vergleich zu den geforderten 128Bit Zufallspasswörtern ergibt.


@sakura: danke :-)

Gruß Hagen

[Gast]

Zitat:

Unknackbare" Passwörter sollten ca. 128 Bit lang sein und per Zufall erzeugt werden und nur einmal Verwendung finden

Verwechselst du da nicht Passphrase (aus der ein Schlüssel erzeugt wird) und Password (welches direkt als Zugangsauthentifizierung gilt)?

BTW: Ich stamme aus dem selben Teil Deutschlands :) ... siehe meine Signatur. Aber verziehen ist es natürlich :mrgreen:

[negaH]

Zitat:

Verwechselst du da nicht Passphrase (aus der ein Schlüssel erzeugt wird) und Password (welches direkt als Zugangsauthentifizierung gilt)?

Es gibt eigentlich keine offizielle Definition was ein Passwort und was eine Passphrase ist. Normalerweise bezeichnet man ein Text der aus einem Wort besteht als Passwort und ein Text, z.b. Zitat, Gedicht usw. als Passphrase.

Konvertierte Passwörter, z.b. mit obengenannter Hashfunktion, bezeichnet man als Sessionkey. Meistens wird eine MGF = Mask Generation Function dazu benutzt um das textbasierte Passwort/Passphrase, plus einem zufällig oder serverseitig vorgeschriebenen Seed, mit Hilfe einer Einwegfunktion (Hash), in einen Sessionkey zu verwandeln.
Es gibt verschiedene Ansätze für dieses Problem, z.b. OTP, S/Key, UNIX Crypt usw. Die einen nutzen Verschlüsselungen die das Passwort mit sich selber verschlüsseln, die anderen preferieren Einwegfunktionen. Ich persönlich nutze dafür ausschließlich Einwegfunktionen. Da man nichts entschlüsseln kann was nicht zu entschlüsseln geht, eben Einweg.

Gruß Hagen

[sakura]

Der OffTopic-Teil ist hier zu finden http://www.delphipraxis.net/viewtopic.php?t=7079

...:cat:...

[Schubi]

Wird in der Funktion nicht vergessen, zu bewerten ob Groß- Kleinbuchstaben durcheinander sind, oder nur kleine usw?

Mag unter Windows zwar keine Rolle spielen, aber im Web auf jeden Fall!

[negaH]

Zitat:

Wird in der Funktion nicht vergessen, zu bewerten ob Groß- Kleinbuchstaben durcheinander sind, oder nur kleine usw?

Nein wird nicht vergessen. Die Methode überprüft die Häufigkeit der Zeichen, deren Abstand im ASCII Zeichensatz zueinander und deren Abstand auf QWERTZ Keybords untereinander. D.h. ein Key wie "ABCDEF" oder "QWERTZ" wird schlechter bewertet. Ein Passwort wie "AaBbCc" ist dagegen schon besser. Im Grunde müsste es sogar so sein das ein Passwort wie "AfKtMp" relativ gut ist, denn welcher Mensch nutzt zur Passworteingabe intensiv die Shift Taste ?

Wer sich nicht sicher ist wie meine Funktion arbeitet sollte sie mal mit verschiedenen Passwörtern austesten und die Resultate vergleichen.

Generell kann es keine Funktion geben die bestimmt ob ein Passwort gut oder schlecht ist. Selbst ein Passwort aus echten Zufallsdaten mit 32 Bytes Länge kann enorm schlecht sein, nämlich wenn es geknackt wurde !

D.h. um lange Passwörter sehr schnell zu knacken muß der Angreifer von vornherein sich auf eine Auswahl von möglichen Keys beschränken. Alle möglichen Paswörter kann er nicht durchprobieren da dies bei guten Verschlüsselungen technisch nicht durchführbar ist. Somit sollte ein Passwort lang sein und möglichst resistent gegen "Vermutungen" sein. Am besten ein kurzer Satz mit Ziffern, Sonderzeichen und absolut schwachsinnigem Inhalt.

Ein sehr gutes Passwort sollte nur einmal verwendet werden.

Gruß Hagen

[Schubi]

Komisch, vor allem daher, weil ich mehrere Passwörter getestet habe. Mit dutzenden Groß, klein kombis. Fast immer kam auf die letzte Nachkommastelle das gleiche Ergebnis

[negaH]

Das ist auch korrekt so, denn 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.
Jedes Zeichen mehr in einem Passwort erhöht dessen Entropie um 3,5 Bits. Dies ist primär stärker zu gewichten als die Kombinationsvielfalt der Buchstaben im Passwort.

Gruß Hagen

[Cyberaxx]

Hallo

Ich weiß das dieser Thread verdammt alt ist aber ich mußte ihn nun ausgraben.
In der CodeLib habe ich die Funktion entdeckt, leider habe ich damit ein kleines Problemchen

es geht um diese beiden Zeilen

Delphi-Quellcode:

Byte(S[I-1]) := Byte(Password[I-1]) - Byte(Password[I]);
Byte(S[I-1]) := Byte(S[I-1]) - Byte(S[I]);

Vermerk vom Debugger
Der linken Seite kann nichts zugewiesen werden

Ich nutze Delphi 2010 Pro

Gruß
Cyber

[p80286]

Ich vermute mal es geht hierum

Delphi-Quellcode:

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;

Dann könnte Dir evtl

Delphi-Quellcode:

S: ansistring;

weiter helfen. (oder sogar S:shortstring ?)
Soweit ich weiß hat D2010 im String schon 16Bit-Chars, Und da dürfte der Hund begraben sein.

Gruß
K-H

[Cyberaxx]

Danke das war der Ansatz den ich brauchte

Delphi-Quellcode:

  function KeyDiff: Extended;
  const
    Table = '^1234567890ß´qwertzuiopü+asdfghjklöä#<yxcvbnm,.-°!"§$%&/()=?`QWERTZUIOPÜ*ASDFGHJKLÖÄ''>YXCVBNM;:_';
  var
    //S: String;
    S: AnsiString;
    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] := AnsiChar(J); // <-- ebenfalls abgeändert Char in AnsiChar, sonst meckert der Compiler erneut :)
    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;