¿Cómo se sustituye el algoritmo de hash de contraseñas cakephp?

Question

Tengo una base de datos existente estoy tratando de poner una aplicación de la torta en la parte superior de. La aplicación de edad utiliza crypt () en Perl para cifrar las contraseñas. Tengo que hacer lo mismo en la aplicación PHP.

¿Dónde está el lugar correcto para hacer que el cambio en una aplicación cakephp estándar? Y qué sería un cambio de este tipo parece?

Answer 1

Lo tengo trabajo ...

aquí está mi 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');
    }
}

A continuación, aquí está el usuario:

<?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;
    }
}
?>

Todo lo demás es normal, creo.

Aquí es un buen recurso: http : //teknoid.wordpress.com/2008/10/08/demystifying-auth-features-in-cakephp-12/

Answer 2

En realidad el método descrito anteriormente por DANB no funcionó para mí en CakePHP 2.x En lugar de eso terminó creando un componente de autenticación personalizado para omitir el algoritmo de hash estándar:

/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;
    }
}

... y luego usar eso en mi controlador ...

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

Este último bloque también se puede poner dentro de la beforeFilter método de la AppController . En mi caso me acaba de elegir para ponerlo específicamente en un controlador donde iba a utilizar la autenticación personalizada con un modelo de usuario diferente.

Answer 3

Sólo para seguir esto en CakePHP 2.4.1, yo estaba construyendo un front-end para una base de datos de legado que tenía las contraseñas de usuario existentes almacenados como MD5 (ACCOUNTNUMBER: StaticText: contraseña), y que permita a los usuarios acceder necesitábamos utilizar ese sistema de hashing también.

La solución fue:

Crear un archivo app / Controlador / Componente / auth / CustomAuthenticate.php con:

<?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);
    }

}

El "extiende FormAuthenticate" significa que este archivo se hace cargo de la función _findUser pero se remite a FormAuthenticate para todas las demás funciones de la forma habitual. Esto entonces se activa mediante la edición de AppController.php y añadiendo a la clase AppController algo como esto:

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'),
            )
        ),
    )
);

En particular interés el uso de la clave de la matriz asociativa 'personalizado'.

Por último es necesario hash de la contraseña al crear un nuevo usuario, por lo que el archivo de modelo (en mi caso account.php) añadí:

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;
}