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 ?

Klassifiziere zB alle Zeichen.

Dann

zusammenfalten · markieren

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.

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:

markieren

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.

zusammenfalten · markieren

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

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

markieren

Delphi-Quellcode:

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

macht genau das was Asserbad ansprach. Mit

markieren

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

...

...

**MrKnogge**

WoW

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

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**

markieren

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

Passwort auf Sicherheit prüfen

Passwort auf Sicherheit prüfen

Re: Passwort auf Sicherheit prüfen

Re: Passwort auf Sicherheit prüfen

Re: Passwort auf Sicherheit prüfen

Re: Passwort auf Sicherheit prüfen

Re: Passwort auf Sicherheit prüfen

Re: Passwort auf Sicherheit prüfen

Re: Passwort auf Sicherheit prüfen

Re: Passwort auf Sicherheit prüfen

Re: Passwort auf Sicherheit prüfen

Forumregeln

MrKnogge Registriert seit: 9. Jun 2003 Ort: Pforzheim 2.458 Beiträge Delphi 2007 Professional	#3 Re: Passwort auf Sicherheit prüfen 7. Jul 2003, 17:02 Das wäre eine Lösung, aber ich würde schon gerne wissen, wieviele verschiedene Zeichen das Passwort hat. Christian Bootz Einstein ist tot, Newton ist tot, und mir ist auch schon ganz schlecht...
	Zitat

Gast (Gast) n/a Beiträge	#4 Re: Passwort auf Sicherheit prüfen 7. Jul 2003, 17:13 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: markieren 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 ...
	Zitat

Gast (Gast) n/a Beiträge	#6 Re: Passwort auf Sicherheit prüfen 8. Jul 2003, 09:09 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".
	Zitat

sakura Registriert seit: 10. Jun 2002 Ort: München 11.412 Beiträge Delphi 11 Alexandria	#8 Re: Passwort auf Sicherheit prüfen 8. Jul 2003, 10:22 @negaH: Ich habe mir mal erlaubt den Code in unsere Library zu kopieren: http://www.delphipraxis.net/viewtopic.php?p=50248#50248 ...... Daniel W. Ich bin nicht zurück, ich tue nur so
	Zitat