Laden...

Passwort sicherheit

Erstellt von Haggy vor 16 Jahren Letzter Beitrag vor 16 Jahren 12.118 Views
Haggy Themenstarter:in
1.134 Beiträge seit 2004
vor 16 Jahren
Passwort sicherheit

Kennt jemand einen schonfertigen algorithmus der mir zurückliefert wie sicher ein passwort ist ?

Also irgendeine art von index oder Wert

Mein Stackoverflow Profil
Skype Name : Boas.Enkler (bitte einen hinweis in der Kontaktanfrage damit ich euch vom Spam unterscheiden kann)

2.921 Beiträge seit 2005
vor 16 Jahren

Gewichte doch einfach die Anzahl z.B. mit 1. Buchstaben mit 2. Ziffern mit 3. Sonderzeichen mit 4.
Wenn irgendwas doppelt vorkommt ziehst Du was ab.
Zusätzliche Punkte könntest Du vergeben, wenn das Passwort Groß- und Kleinbuchstaben enthält. Das habe ich hier nicht berücksichtigt oder auch wenn es Ziffern, Groß-, Kleinbuchstaben UND Sonderzeichen enthält, wenn es kein Wort ist, dass man im Wörterbuch findet usw usw usw....

Und schon ist die Formel bzw. der Algorithmus fertig.

z.B. so:


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace PasswordSecurity
{
    public partial class Form1 : Form
    {
        string sPassword = string.Empty;
        public Form1()
        {
            InitializeComponent();
        }

        private void textBox1_KeyDown(object sender, KeyEventArgs e)
        {
        }

        public int CheckPasswordSecurity(string sPassword)
        {
            int nResult = 0;
            SortedList<char, char> slList = new SortedList<char, char>();
            foreach (char ch in sPassword)
            {
                if (char.IsDigit(ch))
                {
                    nResult += 2;
                }
                else if (char.IsLetter(ch))
                {
                    nResult += 3;
                }
                else
                {
                    nResult += 4;
                }
                try
                {
                    slList.Add(ch,ch);
                }
                catch (Exception ex)
                {
                    if (nResult - 9 > -1)
                    {
                        nResult -= 9;
                    }
                    else
                    {
                        nResult = 0;
                    }
                }
            }
            nResult += sPassword.Length;
            this.label1.Text = nResult.ToString();
            return nResult;
        }

        private void textBox1_TextChanged(object sender, EventArgs e)
        {
            sPassword = this.textBox1.Text;
            int nSecurity = CheckPasswordSecurity(sPassword);
            DisplaySecurity(nSecurity);
        }

        private void DisplaySecurity(int nSecurity)
        {
            if (nSecurity > 35)
            {
                label3.Text = "unbeatable!";
            }
            else if (nSecurity > 30)
            {
                label3.Text = "very hard";
            }
            else if (nSecurity > 25)
            {
                label3.Text = "very strong";
            }
            else if (nSecurity > 20)
            {
                label3.Text = "strong";
            }
            else if (nSecurity > 15)
            {
                label3.Text = "strong";
            }
            else if (nSecurity > 10)
            {
                label3.Text = "ok";
            }
            else if (nSecurity > 0)
            {
                label3.Text = "weak";
            }
        }
    }
}

Bei dem Vorschlag hats mich gepackt. Interessante Aufgabe sowas.

Seit der Erkenntnis, dass der Mensch eine Nachricht ist, erweist sich seine körperliche Existenzform als überflüssig.

B
1.529 Beiträge seit 2006
vor 16 Jahren

Du könntest auch das geometrische Mittel der gegenseitigen Differenzen aller UNICode-Werte des Strings bestimmen und als Maß nutzen. Dann brauchst du nichts bewerten oder ähnliches sondern ziehst als Kriterium bloß die Unterschiedlichkeit der Zeichen heran.

Im Code:

private double GetPasswordSecurityIndex( string password )
{
   double value = 1;
   for (int i = 0; i < password.Length; i++ )
      for (int j = i + 1; j < password.Length; j++ )
         value *= Math.Abs( (int)password[i] - (int)password[j]  ) + ( j - i );
   return password.Length * Math.( value, 1 / password.Length );
}

Vermutlich muss man diese Berechnung noch deutlich anpassen, allerdings liefert sie dann relativ schnell und eindeutig eine numerische Bewertung eines Passworts.
So empfinde ich die Nutzung eines SortedDictionary (@dr4g0n76: du hast versehentlich SortedList geschrieben), nur um doppelte Zeichen zu ermitteln, für arg umständlich. Desweiteren werden aufeinanderfolgende Zeichen nicht geprüft.
So sind die beiden Passwörter "abcdefgh" und "quejspod" gleichwertig, was sie jedoch mit Sicherheit nicht sind.

2.921 Beiträge seit 2005
vor 16 Jahren

@Borg: Das war ja auch nur auf die schnelle um das zu zeigen, hab nicht mal überprüft, ob der Code läuft. Aber Du hast recht.

Seit der Erkenntnis, dass der Mensch eine Nachricht ist, erweist sich seine körperliche Existenzform als überflüssig.

Haggy Themenstarter:in
1.134 Beiträge seit 2004
vor 16 Jahren

Interessante Ansätze werdes beides mit einfließn lassen. Ggf. wäre noch ein kurzer dictionary check nciht schlecht. sobald ich was fertiges hab stell ichs in mienem Blog zur Verfügung 🙂

Mein Stackoverflow Profil
Skype Name : Boas.Enkler (bitte einen hinweis in der Kontaktanfrage damit ich euch vom Spam unterscheiden kann)

B
1.529 Beiträge seit 2006
vor 16 Jahren

Habe obigen Code mal ausprobiert und angepasst.
Die aktuelle Version:

private static double GetPasswordSecurityIndex( string pwd )
{
   double pwdlog = Math.Log( pwd.Length + 1);
   double pwdlen = (double)pwd.Length;
   double value = pwd.Length;
   for (int i = 0; i < pwd.Length; i++)
      for (int j = i + 1; j < pwd.Length; j++)
         value += Math.Pow( Math.Abs((int)pwd[i]-(int)pwd[j]) / pwdlen, pwdlog );
   return (value > 0.0) ? Math.Log( value ) : 0;
}

Hier mal ein paar Beispiele:


Borg    5,02650877675571
Borg1234        7,02423089434529
Borg was here.  7,95082622741682
No Borg here anymore, even not a single 1.      7,90570469080243
mycsharp        4,33975705524902
mycsharp.de     6,68671924145669
www.mycsharp.de 7,36601719119733
http://www.mycsharp.de  7,76037497025754
Das ist nur ein absolut sinnfreier Teststring, der nur zeigen soll, was bei extrem langen Passwörtern passiert. 6,97574345705376
hIug^H$&&%8_ihugü#      9,7687777314195

Ich finde, dass das schon relativ vielversprechend aussieht...

49.485 Beiträge seit 2005
vor 16 Jahren

Hallo Borg,

ich denke, die Länge des Passworts muss (stärker) berücksichtigt werden. Ein sechsbuchstabiges Passwort kann noch viele verschiedene Zeichen haben, man kann es relativ leicht knacken. Dagegen ist ein 12-buchstabiges Passwort, selbst wenn nur aus Kleinbuchstaben besteht, schon relativ hart, wenn es nicht in einem Wörterbuch steht.

herbivore

B
1.529 Beiträge seit 2006
vor 16 Jahren

Stimmt.

private static double GetPasswordSecurityIndex( string pwd )
{
   double mybase = 2.5;
   double pwdlog = Math.Log( pwd.Length + 1, mybase );
   double pwdlen = (double)pwd.Length;
   double value = 0.0;
   for (int i = 0; i < pwd.Length; i++)
      for (int j = i + 1; j < pwd.Length; j++)
         value += Math.Pow( Math.Abs((int)pwd[i]-(int)pwd[j]) / pwdlen, pwdlog );
   return (value > 0.0) ? Math.Log( pwd.Length * value ) : 0;
}

Jetzt habe ich leider keine Zeit zum Testen mehr. Mal heute abend schauen.

W
558 Beiträge seit 2006
vor 16 Jahren

Verschiedene Möglichkeiten eines Passworts (geordnete Stichprobe mit Wiederholung):

Verschiedene Zeichen ^ Stellen (Zeichen hoch Stellen)

Bsp:
Nur Kleinbuchstaben des Alphabets bei 4 Stellen:
26^4

Klein- und Großbuchstaben des Alphabets + Zahlen bei 4 Stellen:
(26 + 26 + 10)^4

usw.

mfg
webstarg

B
1.529 Beiträge seit 2006
vor 16 Jahren

Das hilft einem doch aber nicht bei der Gütebeurteilung eines gegebenen Passworts.

49.485 Beiträge seit 2005
vor 16 Jahren

Hallo Borg,

doch, wenn man für jede Zeichenklasse, aus der ein Zeichen im Passwort vorkommt, die Basis entsprechend der Zahl der Zeichen in der Zeichenklasse erhöht und als Exponent die Länge verwendet, bekommt man ein Maßzahl für die Güte des Passworts.

herbivore

B
1.529 Beiträge seit 2006
vor 16 Jahren

Damit bekommt man ja dennoch nur heraus, wie viel verschiedene Passwörter prinzipiell möglich sind, bei Verwendung der benutzten Blöcke.
Inwieweit hilft das jetzt bei der Bewertung eines konkreten Passworts?

Was ich damit meine: Mit dieser Art der Berechnung würde die Güte des Passworts "aa" 262 = 676 betragen. Das Passwort "aA" hätte die Güte 522 = 2704. Und dieses Passwort ist kaum besser als das andere.

49.485 Beiträge seit 2005
vor 16 Jahren

Hallo Borg,

hm, aA finde ich um Klassen besser als aa. Wenn du als Beispiel bringen würdest, dass aaaaaa die gleiche Bewertung bekäme wie argdip, dann würde mich das eher überzeugen. 🙂 Aber das die Berechnung bei Gütebeurteilung eines gegebenen Passworts hilft, das würde ich weiterhin behaupten.

herbivore

B
1.529 Beiträge seit 2006
vor 16 Jahren

Das Thema hat mich nicht in Ruhe gelassen.
Dann fiel mir ein Mittel der Statistik ein, um die Streuweite einer Stichprobe zu ermitteln: die Standardabweichung. Da die Werte aber relativ hoch waren, habe ich deren natürlichen Logarithmus gebildet.

Damit erhalte ich folgende Implementierung:

private static double GetPasswordStrength2( string pwd )
{
   // leeres Passwort => nix mit stark
   if (String.IsNullOrEmpty( pwd ))
   { return 0; }
   // Zeichen in int wandeln und summieren
   double[] values = new double[ pwd.Length ];
   double sum = 0.0;
   for (int i = 0; i < pwd.Length; i++)
   {
      values[ i ] = (double)((int)pwd[ i ]);
      sum += values[ i ];
   }
   // Mittelwert berechnen
   double mittel = sum / pwd.Length;
   // Varianz berechnen
   double varianz = 0.0;
   for (int i = 0; i < values.Length; i++)
   {
      double intern = values[ i ] - mittel;
      varianz += intern * intern;
   }
   // nur gleiche Zeichen => dek. Log. der Länge
   if (varianz <= 0.0)
   {
      return Math.Log10( pwd.Length );
   }
   // Standardabweichung s berechnen und deren nat. Log. zurückgeben
   return Math.Log( Math.Sqrt( varianz / (pwd.Length - 1)) );
}

Und siehe da, die erhaltenen Werte korrelieren ziemlich gut (auf vier Nachkommastellen gerundet):

Borg    3,0982
Borg1234        3,3839
Borg was here.  3,4521
No Borg here anymore, even not a single 1.      3,4831
mycsharp        2,1169
mycsharp.de     2,9958
www.mycsharp.de 3,174
http://www.mycsharp.de  3,3116
Das ist nur ein absolut sinnfreier Teststring, der nur zeigen soll, was bei extrem langen Passwörtern passiert. 3,4792
hIug^H$&&%8_ihugü#      3,9354
aaaaaa  0,7782
argdip  1,8985

Da die Skale logarithmisch ist, bedeutet das, dass das Passwort "argdip" ungefähr dreimal besser als "aaaaaa" ist...

Haggy Themenstarter:in
1.134 Beiträge seit 2004
vor 16 Jahren

Hi

in der Art habe ich auch schon ausprobiert.

Allerdings fehlt acuh hier eine stärkere gewichtung der Länge 🙂

Das "Das ist nur ein absolut sinnfreier Teststring, der nur zeigen soll, was bei extrem langen Passwörtern passiert" als PW nicht unsicherer wäre als
"No Borg here anymore, even not a single " 😉

werde mal weiter testen habe leider noch nichts 100% brauchbares 🙂

Mein Stackoverflow Profil
Skype Name : Boas.Enkler (bitte einen hinweis in der Kontaktanfrage damit ich euch vom Spam unterscheiden kann)

3.971 Beiträge seit 2006
vor 16 Jahren

Ich würde das ganze in 3 Teile gliedern,

1.
Ich würde ein Array erstellen, das alle verwendeten Zeichen enthält, wo gezählt wird, wie oft diese verwendet werden, welche ZeichenGruppe das ist (Buchstaben, Zahlen, gebräuchliche Sonderzeichen, außergewöhnliche Sonderzeichen). Sowie einen vemerk ob es ein Großbuchstabe oder Kleinbuchstabe ist. das Ganze Zusammenzählen und Prozentual auf die Gesamtlänge ausrechnen

2.
Würde ich jedes Zeichen, und jede Zeichengruppe im Textvergleichen, wie oft das vorkomment. Beispiel
"aaaaaaa", dort ist die Wiederholung relativ oft.
"abababababababa"
"abcabcabcabcabc"

  1. Einfache Wörterbucheinträge durchgehen

Es gibt 3 Arten von Menschen, die die bis 3 zählen können und die, die es nicht können...

2.921 Beiträge seit 2005
vor 16 Jahren

Nachdem wir hier alle fröhlich drau losdiskutiert haben, habe ich auch das noch entdeckt:

http://www.selflinux.org/selflinux/pdf/passwoerter.pdf

1 Über die Sicherheit von Passworten
Die Sicherheit eines passwortgeschützten Systems hängt entscheidend von der Wahl des richtigen Passwortes ab.
Im allgemeinen unterscheidet man fünf Sicherheitsstufen: nachlässig, niedrig, mittel, hoch und sehr hoch.
Wahrscheinlichkeit bedeutet hier die in Prozent angegebene Wahrscheinlichkeit, mit der das Passwort in einer
gegebenen Zeit durch Brute-Force-Methoden erraten werden kann. Bei Brute-Force Angriffen handelt es sich
um das methodische Durchprobieren alle in Frage kommenden Schlüsselkombinationen.
Die Berechnung erfolgt nach der Formel des National Computer Security Center [NCSC1985a].
Formel NCSC1985a
Dabei ist t_{life} die Lebenszeit des Passwortes in Sekunden, \frac{n_{tries}}{\text{sec}} [tfrac.png] die
Anzahl der möglichen Tests pro Sekunde, n_{c} die Anzahl der möglichen Zeichen und l die Länge des
Passwortes.
Der Wert von \frac{n_{tries}}{\text{sec}} [tfrac.png] liegt bei durchschnittlichen Rechnern und mit dem
normalen Verfahren (crypt()) bei etwa 250.000 Versuchen pro Sekunde.

Interessant ist bei diesem Ansatz dass die Lebenszeit des Passwortes berücksichtigt wird.

Seit der Erkenntnis, dass der Mensch eine Nachricht ist, erweist sich seine körperliche Existenzform als überflüssig.

Haggy Themenstarter:in
1.134 Beiträge seit 2004
vor 16 Jahren

ein in der Tat interessanter Punkt.

Mein Stackoverflow Profil
Skype Name : Boas.Enkler (bitte einen hinweis in der Kontaktanfrage damit ich euch vom Spam unterscheiden kann)

S
8.746 Beiträge seit 2005
vor 16 Jahren

Ist ja alles schön und gut, aber niemand macht Brute-Force-Attacken mit simpler Permutation. Daher sind rein statistische Bewertungen von Passwörtern eigentlich sinnfrei.

Viel wichtiger ist es sicherzustellen, dass keine Wörterbuch-Attacken möglich sind. Und dafür reicht es, die Anreicherung mit Sondernzeichen und/oder Groß/Kleinbuchstaben einzufordern bzw. zu messen. Hier kann man dann durchaus auf statistische Verfahren zurückgreifen.

B
1.529 Beiträge seit 2006
vor 16 Jahren

Das Problem dabei ist halt nur, dass auch diese Berechnung der "Errat-Wahrscheinlichkeit" keinen Unterschied zwischen verschiedenen Passwörtern der gleichen Klasse macht. So wie beim Vorschlag von webstarg und herbivore weiter oben, wird ermittelt, wie viele unterschiedliche Passwörter es theroretisch gibt. In diesem Beispiel wird jetzt daraus die Wahrscheinlichkeit berechnet, mit der ein bestimmtes Passwort innerhalb seiner Lebenszeit erraten werden kann. Streng genommen gilt das aber nur dann, wenn das Passwort selbst eine zufällige Zeichenkombination aus dem Zeichenraum ist. Dann gilt natürlich immer: ein Passwort ist um so besser, je größer der Zeichenraum ist, je zufälliger die Zeichen kombiniert werden und je länger es ist. In die Berechnung der Wahrscheinlichkeit fließt jetzt halt noch die Wahrscheinlichkeit mit ein, das Passwort innerhalb seiner Lebenszeit zu erraten, wobei natürlich logisch ist: je öfter Passwörter gewechselt werden, desto unwahrscheinlicher wird es, dieses während der Verwendung zu erraten.

Daher halte ich diese Art der Berechnung nur für zufällig ermittelte Passwörter für sinnvoll.

49.485 Beiträge seit 2005
vor 16 Jahren

Hallo Borg,

hm, so ganz verstehe ich die Argumentation nicht . Es ist doch völlig egal, ob aaaaaa absichtlich gewählt oder das Ergebnis eines Zufallsprozesses ist. 🙂

Aber ich stimmt dr4g0n76 zu, dass wir hier vermutlich auch bei langem Überlegen nicht zu effektiven Bewertungsmaßstäben kommen, wie es fertig in der Fachliteratur gibt.

herbivore

B
1.529 Beiträge seit 2006
vor 16 Jahren

Ich glaube mittlerweile, dass eine Skale allein nicht zum Erfolg führt.

Die Standardabweichung liefert ein gutes Zeichen dafür, wie stark die Zeichen konzentriert sind. Allerdings arbeitet sie bislang einfach auf dem UniCode-Zeichensatz, der nicht nach Ähnlichkeit bzw. Korelationen zwischen den Zeichen sortiert ist. So müssten in einem angepassten Zeichensatz "e", "n" und "s" direkt nebeneinander stehen, da sie die häufigsten Buchstaben eines deutschen Textes sind (bzw. im Zeichensatz müssten die Zeichen nach ihrer Häufigkeit in den Texten der entsprechenden Sprache sortiert sein).
Damit ließen sich deutlich bessere Resultate erzielen; man könnte - vermute ich - sogar Wörter erkennen.

Zweitens müsste man ein Wörterbuch benutzen, um die größten Teilstrings zu ermitteln, die in einem Wörterbuch stehen. Je weniger Zeichenfolgen in einem Wörterbuch stehen, desto besser ist das Passwort.

Und drittens sollte das Passwort eine Mustererkennung durchlaufen, um so etwas wie "ababab" zu erkennen. Dazu stelle ich mir vor, das Passwort als Punktmenge im durch Stelle X Zeichencode gebildeten Raum darzustellen und dann eine Fourier-Transformation durchzuführen, die diese Punktemenge abbildet. Je mehr Koeffizienten diese Funktion enthält, desto besser ist das Passwort.

Wie man das ganze dann in einen Wert gießt, bereit mir noch Kopfzerbrechen.

B
1.529 Beiträge seit 2006
vor 16 Jahren

@herbivore: Ich wollte eigentlich darauf hinaus, dass die obige Berechnung der (LaPlace-)Wahrscheinlichkeit keinen Sinn macht, wenn die gewählten Passwörter nicht gleichverteilt sind. Und da wohl Passwörter der Klasse "aaaaaa" häufiger vorkommen dürften als welche der Klasse "bu.Hö&", ist die Gleichverteilung eben nicht gewährleistet und damit die Berechnung der (LaPlace-)Wahrscheinlichkeit sinnlos.
Die Berechnung setzt einfach voraus, dass der gesamte Zeichenraum gleichverteilt benutzt wird. Aber solange ich dem Benutzer sein Passwort selbst wählen lasse, funktioniert das nicht.
Beispiel: Es soll ein zehnstelliges Passwort aus Klein- und Großbuchstaben sowie Zahlen, Umlaute und Sonderzeichen gewählt werden. Theoretisch habe ich ja dann einen Zeichenraum von 27+26+10+3+39 = 105 (nur auf der Tastatur abgebildete Zeichen gezählt) und damit einen Schlüsselraum von 105^10 ~ 1,63e18.
Praktisch hingegen werden über Alt Gr zu erreichend Sonderzeichen nicht vorkommen, selbst Shift scheint den meisten Benutzern unbekannt zu sein. Außer um den Namen ihrer Katze groß zu schreiben, was aber wohl kein Vorteil ist.
Dabei kommen dann höchstens Passwörter der Klasse "Muschi2003" für die in diesem Jahr gekaufte Katze heraus oder "Daniel2005" für das damals geborene Kind.
Untersuchungen (siehe beispielsweise http://www.heise.de/newsticker/meldung/73396) würden zeigen, dass 80% der Passwörter gerade mal 50% des Zeichenraums nutzen, also nichts mit Gleichverteilung.

Da aber kein Benutzer den verfügbaren Zeichenraum ausnutzt, sind alle Berechnungen, die diesen verwenden sinnlos, solange der Nutzer sein Passwort selbst wählen kann.

S
8.746 Beiträge seit 2005
vor 16 Jahren

Original von Borg
Die Berechnung setzt einfach voraus, dass der gesamte Zeichenraum gleichverteilt benutzt wird. Aber solange ich dem Benutzer sein Passwort selbst wählen lasse, funktioniert das nicht.

Bingo. Insofern hast du völlig recht: Eine wie von dir skizzierte Bewertung macht Sinn bei zufällig generierten Passwörtern, um bestimmte Kombination, die gefährlich sein können (nicht müssen) von vornherein auszuschliessen.