Reihenfolge beim Überprüfen neuer Passwörter

[vapita]

Hallo Tom,

Ach, die berühmten IF-SCHLEIFEN ;-)

Oder gibt es sie doch?

Da hatte ich wohl einen Knoten im Gehirn. Es ist natürlich eine IF-Abfrage, keine -Schleife. Jedenfalls nicht in meinem Fall. Danke für den Hinweis auf die nette Lektüre. 😉

Das Ganze kannst Du auch als leicht lesbare Funktion aufbauen.

function (insert_new_pass($pass1, $pass2))
{

   if ( !test1() ) return 'Fehler: Eine Passwortangabe fehlt';
   if ( !test2() ) return 'Fehler: Passworte stimmen nicht überein';  
   if ( !test3() ) return 'Fehler: Passwortlänge zu kurz';  
   if ( !test4() ) return 'Fehler: Unerlaubte Zeichen im Passwort';  
   if ( !test5() ) return 'Fehler: Es muss mindestens ein Groß, ein Klein, eine Ziffer, ein Sonderzeichen im Passwort enthalten sein'; 

   # ...

   if ( !db_insert_password() ) return 'Fehler: Eintragung in die DB nicht möglich';  

   return true;
}

Prüfen musst Du dann nach dem Aufruf der Funktion auf

if (($message = insert_new_pass()) === true ## weitermachen, sonst $message ausgeben.

Und anstelle der statischen Fehlermeldungen und TRUE könntest Du auch Fehlernummern und 0 zurückgeben. Dann kannst Du die Fehlermeldungen anhand der Nummer sprachabhängig ausgeben lassen.

Ich habe die Anregungen umgesetzt und die Password-Klasse etwas umgearbeitet:

    /**
     * @param $plain_password
     * @return false|string|null
     */
    public function hash($plain_password)
    {
        $plain_password = (is_array($plain_password)) ? array_pop($plain_password) : $plain_password;
        return password_hash($plain_password, PASSWORD_DEFAULT);
    }

    /**
     * @param string $plain_password
     * @param string $correct_hash
     * @return bool
     */
    public function verify(string $plain_password, string $correct_hash)
    {
       return password_verify($plain_password, $correct_hash);
    }

    /**
     * @param $password
     * @return bool
     */
    private function isString($password){
        if(is_array($password)){
            foreach ($password as $item){
                $passwordIsString = (is_string($item)) ?? false;
            }
            return ($passwordIsString) ?? false;
        } else {
            return (is_string($password)) ?? false;
        }
    }

Ich prüfe, ob das Passwort (oder die Passwörter, wenn es ein Array ist) ein String ist.

    /**
     * @param array $password
     * @return bool
     */
    private function isEqual(array $password){
        return ($password[0] == $password[1]) ?? false;
    }

    /**
     * @param $password
     * @return bool
     */
    private function hasMinLength($password){
        $password = (is_array($password)) ? array_pop($password) : $password;
        return (strlen($password) > 7) ?? false;
    }

Ich prüfe einmal mit strlen() die Zeichenlänge, jedoch brauch ich das gar nicht mehr, da ich bereits mit isComplex() prüfe, ob das Passwort lang genug ist, oder?

    /**
     * @param $password
     * @return bool
     */
    private function isAllowed($password){
        // TODO: auf erlaubte Zeichen prüfen
        return true;
    }

Ich bin mir noch nicht sicher, wie ich prüfe, ob nicht erlaubte Zeichen enthalten sind, bzw. welche das eigentlich sein sollen. Ich würde es wahrscheinlich auf lateinische Buchstaben, arabische Ziffern und die Sonderzeichen @#-_$%^&+=§!? begrenzen.

    /**
     * @param $password
     * @return bool
     */
    private function isComplex($password){
        $password = (is_array($password)) ? array_pop($password) : $password;

        /** Das Passwort muss mindestens
         * - einen Kleinbuchstaben,
         * - einen Großbuchstaben,
         * - eine Ziffer und
         * - ein Sonderzeichen @#-_$%^&+=§!?
         * enthalten.
         * Das Passwort muss zwischen 8 und 20 Zeichen lang sein.
         */
        return (preg_match('/^(?=.*\d)(?=.*[@#\-_$%^&+=§!\?])(?=.*[a-z])(?=.*[A-Z])[0-9A-Za-z@#\-_$%^&+=§!\?]{8,20}$/',$password))? true : false;
    }

}

Hier prüfe ich ja eigentlich auch nochmals die Zeichenkettenlänge. Entferne ich dies hier wieder oder lasse ich einfach die hasMinLentgh() weg?

    /**
     * @param array $password
     * @return int
     */
    public function validate(array $password):int
    {
        if(!$this->isString($password))     return 1601;    // kein String
        if(!$this->isEqual($password))      return 1602;    // stimmt nicht überein
        if(!$this->hasMinLength($password)) return 1603;    // ist nicht lang genug
        if(!$this->isAllowed($password))    return 1604;    // verwendet nicht erlaubte Zeichen
        if(!$this->isComplex($password))    return 1605;    // ist nicht komplex genug
        return 0; // alles in Ordnung
    }

So ist es tatsächlich übersichtlicher. Da hab ich wieder was gelernt. Vielen Dank dafür.

Die Idee mit den Fehlercodes gefällt mir gut. In der View rufe ich die Fehlermeldung dann über ein Array ab.

Beste Grüße

vapita