Ankündigung

Einklappen
Keine Ankündigung bisher.

Passwort generieren

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Passwort generieren

    Oft kommt es vor, dass ein Benutzer sein Passwort vergisst. Da in jedem guten System die Passwörter mit einer Einwegverschlüsselung (sah1, md5 o.ä) gespeichert werden, muss diesen Benutzern ein neues PW zugewiesen werden. Die folgenden Funktionen generieren ein PW einer bestimmten Komplexität:
    PHP-Code:
    function gen_passwd($anz 8){ 
    /*
    **    Function:      Generate password
    **
    **    Parameter:     Integer $anz   Minimal length of password        default: 8
    **
    **    Return value:  String:        Generated password
    */
        
    $z1 range(3347);   // Kein O (Buchstabe) und kein 0 (Null)
        
    $z2 range(4978);
        
    $z3 range(80126);
        
    $zeichen array_merge($z1$z2$z3);    // Erlaubte Zeichen
        
    do{
            
    $passw '';
            
    shuffle($zeichen);                    // Zeichenvorat mischen
            
    for($i 0;$i $anz;$i ++){          // $anz Zeichen auslesen
                
    $passw .= chr($zeichen[$i]);
            }
        } while(!(
    pw_ok($passw$anz)));          // Konsistenz prüfen
        
    return $passw;

    Prüfen, ob das PW der geforderten Komplexität (mindestens je einen Gross- und Kleinbuchstaben, ein Sonderzeichen und eine Ziffer) vorhanden ist. Kann natürlich auch zur Prüfung einer Passwortänderng durch den Benutzer verwendet werden
    PHP-Code:
    function pw_ok($passw$length 8){
    /*
    **    Function        Checks consistency of a password
    **                    The password must consist of at least one digit,
    **                    lower- und uppercase letter and a special sign,
    **                    and the length must be at least $length characters
    **
    **    Parameter:      String: $passw         Password
    **                    Integer $length        Minimal length of the PW
    **
    **    Return value:   Boolean
    */
        
    if (strlen($passw) < $length){        // Passwort zu kurz
            
    return false;
        }
        return 
    preg_match('/[[:digit:]]/'$passw) &&         // Ziffern
               
    preg_match('/[[:lower:]]/'$passw) &&         // Kleinbuchstaben
               
    preg_match('/[[:upper:]]/'$passw) &&         // Grossbuchstaben
               
    preg_match('/[[:punct:]]/'$passw);           // Sonderzeichen

    Gruss
    L


  • #2
    Zwei Kritikpunkte:
    • Wenn schon Pflichtzeichen erzwungen werden, würde ich anstatt der nicht-deterministischen Schleife aus Erstellen und Testen eher ein Passwort mit n-m Zeichen erstellen, wobei n die gewünschte Länge und m die Anzahl an (unterschiedlichen) Pflichzeichen ist und dann die Pflichtzeichen hinzufügen und alles durchmischen.
    • Die Empfehlung für Klein-/Großbuchstaben, Zahlen und Sonderzeichen gibt es doch eigentlich, damit Benutzer möglichst keine einfachen (einfach zu erratenden) Worte wählen (Name der Tochter, hallo, 12345, usw). Bei einem zufällig erzeugten Passwort fällt das (bis auf ganz große Zufälle) weg.
      Dein Alphabet umfasst 92 Zeichen. Mit $length=8 gibt es nicht mehr als 92^8 Möglichkeiten (durch die Pflichtzeichen sogar etwas weniger). Jetzt wähle ich als Alphabet nur 1234567890abcdefghjkmnpqrstuvwxyz (kein o, kein i, kein l) also 33 Zeichen und $lenght=10 oder $length=11
      PHP-Code:
      echo bcpow('92''8') . "\n";
      echo 
      bcpow('33''10') . "\n";
      echo 
      bcpow('33''11') . "\n"
      PHP-Code:
      5132188731375616
      1531578985264449
      50542106513726817 
      10 Zeichen reichen nicht, aber mit $length=11 ergeben sich mit dem verkleinerten, aber leichter zu tippenden Alphabet mehr Möglichkeiten (ich kann sogar noch 1 und 0 rausschmeißen und damit alle il1 und o0 Verwechslungen ausschließen ). Stellen wir noch eine Zahl an den Anfang (gegen die großen Zufälle), haben wir ein 12-stelliges Passwort. Dass kann man benutzerfreundlich in 3x4-Zeichen-Blocks darstellen.

    Kommentar


    • #3
      Deinen ersten Einwand verstehe ich nicht ganz. Bei Tests habe ich einfach festgestellt, dass in etwa 45% der Fälle das Passwort schon im ersten Durchgang vergeben wird. Im Schnitt sind es knapp 2.1 Durchgänge, was ich, da es sich doch um eine nicht so häufig benutzte Funktion handelt, für vertretbar halte.
      Und mit dem zweiten hast du natürlich recht, mit der Anzahl Möglichkeiten. Die Funktionen stammen aber aus einem konkreten (Intranet-)Projekt und die Bedingungen waren so vorgegeben (allerdings für ein vom Benutzer gesetztes Passwort). Ich habe dann einfach auf das generierte Passwort die gleichen Regeln übernommen.
      Und da im Normalfall das Passwort nach der ersten Benutzung geändert werden muss, wenn es etwas komliziert daherkommt.
      Gruss
      L

      Kommentar


      • #4
        Der erste Punkt teilt sich in zwei Unterpunkte.
        Zitat von lazydog
        Im Schnitt sind es knapp 2.1 Durchgänge
        Es kann aber eben auch 5, 10 oder 10 Millionen Durchgänge dauern. (Sehr) Unwahrscheinlich aber möglich.
        Und Testen und Erstellen sind nicht fest an die selben Regeln gebunden. Das spielt hier keine große Rolle, weil alles überschaubar ist. Aber der Robustheit wegen müssten das Erstellen und der Test stärker aneinander gekoppelt sein. Also zum Beispiel, wenn Du beim selben Modul, dass preg_match bereit stellt, nachfragen könntest
        Gib mir alle Symbole der Menge [[:digit:]]
        genauso für [[:lower:]]
        genauso für [[:upper:]]
        genauso für [[punct:]]
        Daraus dann die vereinigte Menge bilden, eventuell noch Symbole hinzufügen und dann aus diesem Pool das Passwort erstellen.
        Aber egal, für das Hier und Jetzt etwas abgehobene Gedanken. Einfach ignorieren

        Kommentar


        • #5
          Hallo,

          Hier eine Methode einer Klasse die ich damals zu meiner aktiven Programmiererzeit geschrieben habe. 100% Trefferquote und sehr übersichtlicher Code.

          PHP-Code:
          public static function GetRandomPassword()
              {
                  
          $password = (string)'';
                  
          $password .= mt_rand(09);
                  
          $password .= chr(mt_rand(97122));
                  
          $password .= chr(mt_rand(6590));
                  
                  for (
          $i 0$i 5$i++)
                  {
                      Switch (
          mt_rand(02))
                      {
                          case 
          0:
                              
          $password .= mt_rand(09);
                              break;
                          case 
          1:
                              
          $password .= chr(mt_rand(97122));
                              break;
                          case 
          2:
                              
          $password .= chr(mt_rand(6590));
                              break;
                      }
                  }
                  
          $password str_shuffle($password);
                  
                  return 
          $password;
             } 
          Gruß Thomas

          Kommentar


          • #6
            Leider nicht dokumentiert

            Mich wuerde eine Funktion interessieren, die lesbare Passwoerter generiert, also Vokale beruecksichtigt und einbaut. Wenn da jemand grad was hat kann er es ja posten; googlen kann ich aber selber, falls nicht.
            "Mein Name ist Lohse, ich kaufe hier ein."

            Kommentar


            • #7
              Hallo @ All!

              Also die hier ist mein kleiner Passwortgenerator der richtig gut funktioniert!

              PHP-Code:
              function passwort_create($zeichen 8)
              {
               
              $chars array_merge(
                      
              range(09),
                      
              range('a''z'),
                      
              range('A''Z')
                  );
                  
              shuffle($chars);
                  return 
              implode(''array_slice($chars0$zeichen)); 
              }
               
              //Zum Funktion benutzen
              $new_passwort passwort_create(); 
              Die Variable $new_passwort kann dann per E-Mail verschickt werden
              Aus dem Dynamo Lande kommen wir. Trinken immer reichlich kühles Bier. Und dann sind wir alle voll, die Stimmung ist so toll. Aus dem Dynamo Lande kommen wir.
              http://www.lit-web.de

              Kommentar


              • #8
                Zitat von litterauspirna Beitrag anzeigen
                Also die hier ist mein kleiner Passwortgenerator der richtig gut funktioniert!
                Nur hast du dabei keine Kontrolle, ob das Passwort auch komlex genug ist, d.h. auch aus allen Klassen mindestens ein Zeichen enthält. Ausserdem schliesst du Sonderzeichen aus, die eigentlich wesentlich zu sichereren Passwörten beitragen können.

                Das gilt übrigens alles auch für das Beispiel von Thomas
                Gruss
                L

                Kommentar


                • #9
                  Hmm das ist natürlich ein gutes Argument! Danke werde dies mal berücksichtigen!
                  Aus dem Dynamo Lande kommen wir. Trinken immer reichlich kühles Bier. Und dann sind wir alle voll, die Stimmung ist so toll. Aus dem Dynamo Lande kommen wir.
                  http://www.lit-web.de

                  Kommentar


                  • #10
                    Zitat von lazydog Beitrag anzeigen
                    Nur hast du dabei keine Kontrolle, ob das Passwort auch komlex genug ist, d.h. auch aus allen Klassen mindestens ein Zeichen enthält. Ausserdem schliesst du Sonderzeichen aus, die eigentlich wesentlich zu sichereren Passwörten beitragen können.

                    Das gilt übrigens alles auch für das Beispiel von Thomas
                    Hi,

                    Das war damals die Anforderung, dass keine Sonderzeichen verwendet werden dürfen.

                    Gruß Thomas

                    Kommentar


                    • #11
                      Zitat von lazydog Beitrag anzeigen
                      Nur hast du dabei keine Kontrolle, ob das Passwort auch komlex genug ist, d.h. auch aus allen Klassen mindestens ein Zeichen enthält.
                      Und das glaube ich eben nur bedingt. Es geht hier ja um zufällig erzeugte Passwörter. Warum brauche ich da überhaupt Klassen von Zeichen?
                      Nehmen wir mal die einfachste Form von (naja irgendwie) "aussprechbaren" Passwörtern. Immer abwechselnd ein Konsonant und ein Vokal.
                      PHP-Code:
                      <?php
                      function genpw($x=7)
                      {
                        
                      /* static */$digits str_split('123456789'1);
                        
                      /* static */$cons str_split('bdfghkmnprstvwxz'1);
                        
                      /* static */$vowels str_split('aeiou');
                        
                      $e = array($digits[array_rand($digits)]);
                        for(
                      $i=0$i<$x$i++) {
                          
                      $e[] = $cons[array_rand($cons)] . $vowels[array_rand($vowels)];
                        }
                        
                      shuffle($e);
                        return 
                      implode(''$e);
                      }

                      for(
                      $n=0$n<20$n++) 
                      {
                        echo 
                      genpw() . "\n";
                      }
                      7 Paare, 16 Konsonanten, 5 Vokale abwechselnd. Dann sind das schon (16*5)^7 ~ 20 Billionen Möglichkeiten. Wie viele Möglichkeiten die eingestreute Ziffer jetzt noch beisteuert, übersteigt meine Stochastikfähigkeiten Aber wenn sie an einer festen Stelle steht, 9 Ziffern, (16*5)^7 * 9 ~ 188 Billionen Möglichkeiten. Und dass sie die Position ändern kann, verringert wohl kaum die Anzahl der Möglichkeiten. (Habe ich mich irgendwo verrechnet?)
                      Brauche ich jetzt wirklich noch Groß/Kleinschreibung, Sonderzeichen oder sonstige Tests? Ab dem dritten Fehlversuch verzögere ich die Passworteingabe vielleicht ein bisschen, Captcha, Zwangspause. Es gibt es genügend Eskalationsstufen. Da brauche ich nicht den Benutzer bei der korrekten Eingabe mit irgendwelchen Zeichen, die er oder sie noch nie auf der Tastatur gesehen hat, belasten

                      Kommentar


                      • #12
                        (16*5)^7 * 9 * 16 = 3 Billarden Möglichkeiten. sollte dann ungefähr stimmen .

                        Mittels Brute-Force mit einem "normalen" PC ca. zu lösen in in 1 Jahr bei 100'000 Abfragen / Sekunde. Wobei da userbezogene Mechanismen deftig ausbremsen dürften.
                        Wichtig ist, dass du die Mechanismen User, und nicht Sessionbezogen machst. Deine Abfrage, ob bereits das 3.Mal versucht wurde bringt nicht, wenn du gar nicht merkst, dass es der gleiche "Bot" ist, der abfragt. Dieser kann sich problemlos für jede Abfrage als neuer Benutzer ausgeben .

                        Kommentar


                        • #13
                          Kannst Du mir das letzte *16 erklären?
                          (Ernst gemeinte Frage. Stochastik interessiert mich nicht genug, um mich ausgiebig damit zu beschäftigen. Aber wenn es mal über den Weg läuft ...)

                          Kommentar


                          • #14
                            @Chriz: ich meine, es gibt ein PEAR-Paket zur Generierung von Passwörtern. Der Methode zum generieren des Passworts kannst du den Parameter 'pronounceable' übergeben, um lesbare Passwörter zu erzeugen.
                            Refining Linux: “Performing Push Backups – Part 1: rdiff-backup

                            Kommentar


                            • #15
                              zum Ursprungsbeispiel: Wieso beschneidest Du mögliche Kombinationsmöglichkeiten, indem Du jedes Zeichen nur einmal zuläßt? Der Algorithmus nutzt doch nen laufenden Index im Array. Warum kein Random? Das gilt übrigens auch für den Code von litterauspirna.
                              Deshalb stimmt auch diese Aussage nicht:
                              Dein Alphabet umfasst 92 Zeichen. Mit $length=8 gibt es nicht mehr als 92^8 Möglichkeiten
                              Bzw. doch. Es gibt sogar weit weniger Möglichkeiten:
                              92 * 91 * 90 ...
                              Die Empfehlung für Klein-/Großbuchstaben, Zahlen und Sonderzeichen gibt es doch eigentlich, damit Benutzer möglichst keine einfachen (einfach zu erratenden) Worte wählen (Name der Tochter, hallo, 12345, usw). Bei einem zufällig erzeugten Passwort fällt das (bis auf ganz große Zufälle) weg.
                              Nein, wieso? Eine beliebige Kombination von Groß- und Kleinbuchstaben vermindert doch die Möglichkeit, eine einfache Rainbow-Table zu benutzen. Restrisiko: Ein zufällig erzeugtes echtes Wort...

                              @Zerg: Prochaska's PHP Sicherheit empfielt die PEAR Klasse Text_Password. Die erlaubt die Angabe des Zeichenvorrats und auch die 'pronounceable' Option: Aussprechbarkeit des Passwortes. Aber Vorsicht: Das Buch spricht hier bei 8 Zeichen (m.E. aber nur aus Kleinbuchstaben) von lediglich 14 Millionen Kombinationen...
                              --

                              „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                              Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


                              --

                              Kommentar

                              Lädt...
                              X