¿Cómo reemplazo el algoritmo hash de contraseña cakephp?

Question

Tengo una base de datos existente que estoy tratando de poner encima de una aplicación de pastel. La aplicación anterior usaba crypt() en Perl para eliminar las contraseñas. Necesito hacer lo mismo en la aplicación PHP.

¿Dónde está el lugar correcto para hacer ese cambio en una aplicación cakephp estándar? ¿Y cómo sería ese cambio?

Answer 1

Lo tengo trabajo ...

aquí es 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'); 
    } 
} 

entonces aquí es 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 vez 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 método beforeFilter del AppController. En mi caso, simplemente elegí ponerlo específicamente en un controlador donde iba a usar autenticación personalizada con un modelo de usuario diferente.

Answer 3

Para seguir esto en CakePHP 2.4.1, estaba construyendo un front-end para una base de datos heredada que tenía contraseñas de usuario existentes almacenadas como md5 (número de cuenta: statictext: contraseña) y para permitir a los usuarios iniciar sesión necesitábamos para usar ese sistema de hash también.

La solución fue:

Cree 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, pero _findUser difiere a FormAuthenticate para todas las demás funciones de forma normal. 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; 
}