Requète préparée avec PDO

J'ai pris une ancienne version de user.php, je corrige !

public static function get($username) {
        self::init();

        $req = self::$db->prepare('SELECT id_adherent FROM tb_adherent WHERE login = :u');
        $req->bindParam(':u', $username, PDO::PARAM_STR);
        $req->execute();

 $id = $req->fetchColumn();

        return ($id) ? new self((int) $id) : null;
}

public function update() {
        $req = self::$db->prepare('UPDATE tb_adherent SET login = :u, email = :e, password = :p, hach_cookie = :h WHERE id = :id');
        $req->bindParam(':u', $this->username, PDO::PARAM_STR);
        $req->bindParam(':e', $this->email, PDO::PARAM_STR);
        $req->bindParam(':p', $this->password, PDO::PARAM_STR);
        $req->bindParam(':h', $this->hash, PDO::PARAM_STR);
        $req->bindParam(':id', $this->id, PDO::PARAM_INT);
        $req->execute();
}

On dirais qu'on a dépassé les 50 messages, ça en fait un peu trop pour un seul sujet :) !

Ajoutes cette méthode à la classe Security.

public static function getRandomHash() {
    return self::hash(rand() . sha1(self::GRAIN) . microtime(true));
}

Dans login.

if(!empty($_POST)) {
    $username = Security::clean($_POST['login']);
    $password = Security::clean($_POST['password']); 

    if(empty($username) || empty($password)) {
        $error = 'Veuillez entrer le Login et le Mot de passe';
    } 
    else {
        $password = Security::hash($password);

        $user = new User();
        $user->setUsername($username);
        $user->setPassword($password);

        if($user->login()) {
            if(isset($_POST['remember'])) {
                $hash = Security::getRandomHash();
                $time = time() + 3600 * 24 * 3;

                $user->setHash($hash);
                $user->update();
 
                $values[] = Security::crypt($user->getUsername());
                $values[] = $hash;
                $values[] = Security::crypt($time);

                setcookie('moncookie', serialize($values), $time);
            }

            $_SESSION['id_adherent'] = serialize($user);
            header('Location: index.php?body=compte_profil&type=compte');
            exit();
        } else {
            $error =  'La combinaison Login/Mot de passe est incorrect';
        }
    }
}

Dans la connexion automatique.

if(!isset($_SESSION['id_adherent']) && isset($_COOKIE['moncookie'])) {
    $values = Security::clean($_COOKIE['moncookie']);
    $values = unserialize($values);

    if(count($values) == 3) {
        $username = Security::decrypt($values[0]);
        $hash = $values[1];
        $time = Security::decrypt($values[2]);

        $user_try = User::get($username);

        if($user_try != null && $user_try->checkHash($hash)) {
            $values[1] = Security::getRandomHash();
            $user_try->setHash($values[1]);
            $user_try->update();

            $_SESSION['id_adherent'] = serialize($user_try);

            setcookie('moncookie', serialize($values), (int) $time);

            header('Location: index.php?body=compte_profil&type=compte');
            exit();
        } 
        else {
            // A mettre dans le fichier log
            $error =  'Le Login est incorrect';
        }
    } 
    else {
        // A mettre dans le fichier log
        $error =  'Le Cookie est invalide';
    }
}

Dans la classe User.

private $hash;

public function setHash($h) {
    $this->hash = $h;
}

public function setUserDatas(array $d) {
    if(!empty($d)) {
       $this->id = $d['id'];
       $this->username = $d['username'];
       $this->email = $d['email'];
       $this->password = $d['password'];
       $this->hash = $d['hash_cookie'];
    }
}

public function checkHash($hash) {
    return $this->hash == $hash;
}

public static function get($username) {
        $req = $this->db->prepare('SELECT id FROM tb_adherent WHERE username = :u');
        $req->bindParam(':u', $username, PDO::PARAM_STR);
        $req->execute();

        $r = $req->fetchColumn();

        return ($r == false) ? null : new self($r);
    }

public function update() {
    $req = $this->db->prepare('UPDATE tb_adherent SET username = :u, email = :e, password = :p, hash_cookie = :hc WHERE id = :id');
    $req->bindParam(':u', $this->username, PDO::PARAM_STR);
    $req->bindParam(':e', $this->email, PDO::PARAM_STR);
    $req->bindParam(':p', $this->password, PDO::PARAM_STR);
    $req->bindParam(':hc', $this->hash, PDO::PARAM_STR);
    $req->bindParam(':id', $this->id, PDO::PARAM_INT);
    $req->execute();
}

<?php
class Security {

    const GRAIN = 'f?,j89-k0.;-!?lqjçs_di3%5a6_4jhfgh';

    public static function hash($donnee) {
        return sha1(md5($donnee) . self::GRAIN . sha1($donnee . self::GRAIN) . $donnee);
    }

    public static function clean($donnee) {
        return trim($donnee);
    }

    public static function crypt($donnee) {
        $iv_size = mcrypt_get_iv_size(MCRYPT_BLOWFISH, MCRYPT_MODE_ECB);
        $iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
        $encrypted_string = mcrypt_encrypt(
              MCRYPT_BLOWFISH, 
              self::GRAIN,
              utf8_encode($donnee), 
              MCRYPT_MODE_ECB, 
              $iv);
         return $encrypted_string;
    }

    public static function decrypt($donnee) {
        $iv_size = mcrypt_get_iv_size(MCRYPT_BLOWFISH, MCRYPT_MODE_ECB);
        $iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
        $decrypted_string = mcrypt_decrypt(
             MCRYPT_BLOWFISH, 
             self::GRAIN, 
             $donnee, 
             MCRYPT_MODE_ECB, 
             $iv);
         return $decrypted_string;
    }
}

if(isset($_COOKIE) && !isset($_SESSION)) {

C'est quoi cette condition ?
Jamais cette condition ne retournera "true" car le tableau $_SESSION existe dés que tu fais "session_start".

Remets la condition originale, et retentes.

Et ben à l'intérieur de tes deux méthodes "crypt" et "decrypt", faut bien qu'elles retournent quelque chose.

Exemple !

<?php
class Security {

    const GRAIN = 'f?,j89-k0.;-!?lqjçs_di3%5a6_4jhfgh';

    public static function hash($donnee) {
        return sha1(md5($donnee) . self::GRAIN . sha1($donnee . self::GRAIN) . $donnee);
    }

    public static function clean($donnee) {
        return trim($donnee);
    }

    public static function crypt($donnee) {
        return encrypt($donnee, self::GRAIN);
    }

    public static function decrypt($donnee) {
        return decrypt($donnee, self::GRAIN);
    }
}

Ajoutes ...

echo '<br>Cookie : ' . $_COOKIE['moncookie'] . '<br>';

Si il contient seulement un "_", alors le problème tourne autour de crypt et decrypt, peut être que t'as oublié de faire un return.

Alors faut tester, débuger ...

if(!isset($_SESSION['id_adherent']) && isset($_COOKIE['moncookie'])) {
        echo '<br>Session No, Cookie Yes<br>';

        $values = Security::clean($_COOKIE['moncookie']);
        $values = explode('_', $values);

        if(count($values) == 2) {
            $username = Security::decrypt($values[0]);
            $password = Security::decrypt($values[1]);

            echo '<br>Cookie Username : ' . $username . ', Password : ' . $password . '<br>';

            $user_try = new User();
            $user_try->setUsername($username);
            $user_try->setPassword($password);

            if($user_try->login()) {
                echo '<br>Cookie datas corrects<br>';

                $_SESSION['id_adherent'] = serialize($user_try);
                //header('Location: index.php');
                exit();
            } 
            else {
                // A mettre dans le fichier log
                $error =  'La combinaison Login/Mot de passe est incorrect';
            }
        } 
        else {
            // A mettre dans le fichier log
            $error =  'Le Cookie est invalide';
        }
}

Regarde ce que ça affiche.

Précise un peu quel résultat tu reçoit, quel message est affiché après la tentative de connexion automatique ?

C'est $values et non pas values !

J'ai mis ce commentaire parce que j'ai jugé inutile d'afficher à l'utilisateur que les données du cookie sont invalides.
Parce que si tu réfléchis bien, il n'y a aucune raison pour que les données soient invalide, SAUF si l'utilisateur a essayé (je ne sais pour quelle raison) de modifier manuellement le contenu du cookie (surement pour tenter de décrypter le contenu du cookie afin de voler la session d'un autre membre), donc au lieu de lui afficher un message "Cookie invalide", on insère plutôt l'information dans un fichier log avec quelque informations supplémentaires (IP, date ...), et si l'IP est statique dans le pays de cet utilisateur, alors tu pourras savoir qui ou combien d'utilisateurs sont "hostiles" envers ton service web.

Qu'est ce qui te dit que l'erreur provient de la classe Security ?

Pour la première erreur (Undefined index) : On dirais que tu mélanges entre les deux nominations $_SESSION['id_adherent'] et $_SESSION['adherent'], utilises soit l'un soit l'autre !

Je pense que la deuxième erreur est dépendante de la première.

Salut,

Pourquoi ça, quelle est l'erreur ?

<?php
class Security {

    const GRAIN = 'f?,j89-k0.;-!?lqjçs_di3%5a6_4jhfgh';

    public static function hash($donnee) {
        return sha1(md5($donnees) . self::GRAIN . sha1($donnees . self::GRAIN) . $donnees);
    }

    public static function clean($donnee) {
        return trim($donnees);
    }

    public static function crypt($donnee) {
        return;
    }

    public static function decrypt($donnee) {
        return;
    }
}
?>

Ben c'est la même chose l'ami, c'est pareil que ce que j'ai dis plus haut !
Avant d'essayer d'accéder à l'objet, il faut le récupérer à partir de sa représentation linéaire, qui est enregistrée dans la session.

Par contre, tu ne peux travailler avec "sha", car c'est une fonction de hachage, c'est à dire qu'il n'y a pas de fonction qui fait l'inverse.
Donc tu dois chercher une fonction de cryptage/décryptage.

Pourquoi tu as besoin de décrypter, parce que lorsque l'utilisateur se connecte, la première chose que tu vérifies est l'existance d'une session, si ce n'est pas le cas, tu vérifies l'existence d'un cookie.
Si le cookie existe, tu dois récupérer sa valeur, la décrypter, puis connecter l'utilisateur grâce à la valeur décrypté (id, username ou email).

Tu dois également ajouter son mot de passé (haché) afin de vérifier l'identité de l'utilisateur.

if(isset($_POST['remember'])) {
    $user = unserialize($_SESSION['id_adherent']);
    $value = Security::crypt($user->getUsername()) . '_' . crypt($user->getPassword());

    setcookie('moncookie', $value, time() + 3600 * 24 * 3);
}

if(isset($_SESSION['id_adherent'])) {
    // Utilisateur déja connécté
    $user = unserialize($_SESSION['id_adherent']);
}
elseif(isset($_COOKIE['moncookie'])) {
    $values = trim($_COOKIE['moncookie']);
    $values = explode('_', $values);

    if(count(values) == 2) {
        $username = Security::decrypt($values[0]);
        $password = Security::decrypt($values[1]);

        $user_try = new User();
        $user_try->setUsername($username);
        $user_try->setPassword($password);

        if($user_try->login()) {
            $_SESSION['id_adherent'] = serialize($user_try);
            header('Location: index.php');
            exit();
        }
        else {
            // Les identifiants ne correspondent pas
        }
    }
    else {
        // Le cookie est invalide
    }
}

Voila, n'oublie pas de définit les méthodes "crypt" et "decrypt" dans la classe Security, et d'ajouter la méthode "getPassword" à la classe User.