Comment puis-je remplacer l'algorithme de hachage de mot de passe CakePHP?

Question

J'ai une base de données existante, je suis en train de mettre une application de gâteau au-dessus de. L'ancienne application utilisée crypte () en Perl de hachage des mots de passe. Je dois faire la même chose dans l'application PHP.

Où est le bon endroit pour faire ce changement dans une application standard CakePHP? Et qu'est-ce qu'un tel changement ressemble?

Answer 1

Je l'ai travail ...

voici mon AppController:

class AppController extends Controller {
    var $components = array('Auth');

    function beforeFilter() {
        // this is part of cake that serves up static pages, it should be authorized by default
        $this->Auth->allow('display');
        // tell cake to look on the user model itself for the password hashing function
        $this->Auth->authenticate = ClassRegistry::init('User');
        // tell cake where our credentials are on the User entity
        $this->Auth->fields = array(
           'username' => 'user',
           'password' => 'pass',
        );
        // this is where we want to go after a login... we'll want to make this dynamic at some point
        $this->Auth->loginRedirect = array('controller'=>'users', 'action'=>'index');
    }
}

Alors voici l'utilisateur:

<?php
class User extends AppModel {
    var $name = 'User';

    // this is used by the auth component to turn the password into its hash before comparing with the DB
    function hashPasswords($data) {
         $data['User']['pass'] = crypt($data['User']['pass'], substr($data['User']['user'], 0, 2));
         return $data;
    }
}
?>

Tout le reste est normal, je pense.

Voici une bonne ressource: http : //teknoid.wordpress.com/2008/10/08/demystifying-auth-features-in-cakephp-12/

Answer 2

En fait, la méthode décrite ci-dessus par DANB ne fonctionnait pas pour moi dans CakePHP 2.x Au lieu de cela, je fini par créer un composant Auth personnalisé pour contourner l'algorithme de hachage standard:

/app/Controller/Component/Auth/CustomFormAuthenticate.php

<?php
App::uses('FormAuthenticate', 'Controller/Component/Auth');

class CustomFormAuthenticate extends FormAuthenticate {

    protected function _password($password) {
        return self::hash($password);
    }

    public static function hash($password) {
        // Manipulate $password, hash, custom hash, whatever
        return $password;
    }
}

... et puis utilisez dans mon ... contrôleur

public $components = array(
    'Session',
    'Auth' => array(
        'authenticate' => array(
            'CustomForm' => array(
                'userModel' => 'Admin'
            )
        )
    )
);

Ce dernier bloc peut également être mis à l'intérieur de la beforeFilter méthode de AppController . Dans mon cas, je choisis juste pour le mettre précisément dans un contrôleur où je vais utiliser l'authentification personnalisée avec un modèle d'utilisateur.

Answer 3

Il suffit de suivre cela dans CakePHP 2.4.1, je construisais un front-end pour une base de données existante qui avait des mots de passe d'utilisateurs existants stockés sous forme md5 (ACCOUNTNUMBER: StaticText: mot de passe), et pour permettre aux utilisateurs de se connecter nous devions utiliser ainsi que le système de hachage.

La solution est:

Créer une application de fichier / contrôleur / Component / auth / CustomAuthenticate.php avec:

<?php
App::uses('FormAuthenticate', 'Controller/Component/Auth');

class CustomAuthenticate extends FormAuthenticate {

    protected function _findUser($username, $password = null) {
        $userModel = $this->settings['userModel'];
        list(, $model) = pluginSplit($userModel);
        $fields = $this->settings['fields'];

        if (is_array($username)) {
            $conditions = $username;
        } else {
            $conditions = array(
                $model . '.' . $fields['username'] => $username
            );

        }

        if (!empty($this->settings['scope'])) {
            $conditions = array_merge($conditions, $this->settings['scope']);

        }

        $result = ClassRegistry::init($userModel)->find('first', array(
            'conditions' => $conditions,
            'recursive' => $this->settings['recursive'],
            'contain' => $this->settings['contain'],
        ));
        if (empty($result[$model])) {
            return false;
        }

        $user = $result[$model];
        if ($password) {
            if (!(md5($username.":statictext:".$password) === $user[$fields['password']])) {
                return false;
            }
            unset($user[$fields['password']]);
        }

        unset($result[$model]);
        return array_merge($user, $result);
    }

}

Le « étend FormAuthenticate » signifie que ce fichier prend en charge la fonction _findUser mais remet à FormAuthenticate pour toutes les autres fonctions normalement. Il est ensuite activé en éditant AppController.php et en y ajoutant quelque chose de classe AppController comme ceci:

public $components = array(
    'Session',
    'Auth' => array(
        'loginAction' => array('controller' => 'accounts', 'action' => 'login'),
        'loginRedirect' => array('controller' => 'accounts', 'action' => 'index'),
        'logoutRedirect' => array('controller' => 'pages', 'action' => 'display', 'home'),
        'authenticate' => array (
            'Custom' => array(
                'userModel' => 'Account',
                'fields' => array('username' => 'number'),
            )
        ),
    )
);

On notera en particulier l'utilisation de la clé de tableau associatif « Personnalisé ».

Enfin, il est nécessaire de hachage du mot de passe lors de la création d'un nouvel utilisateur, ainsi le fichier modèle (dans mon cas Account.php) J'ajouté:

public function beforeSave($options = array()) {
    if (isset($this->data[$this->alias]['password'])) {
        $this->data[$this->alias]['password'] = md5($this->data[$this->alias]['number'].":statictext:".$this->data[$this->alias]['password']);
    }
    return true;
}