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

login con contraseña encriptada php

Question

Tengo una base de datos sobre la que estoy tratando de ponerle 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 trabajando ...

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

Entonces 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í hay 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 cambio, terminé creando un componente de autenticación personalizado para eludir el algoritmo 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 colocar dentro del método beforeFilter de 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

Solo 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 usar ese hashing sistema también.

La solución fue:

Cree una aplicación de archivo / Controller / Component / 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 asume la función _findUser pero difiere a FormAuthenticate para todas las demás funciones de forma normal. Esto se activa al editar AppController.php y agregar 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, tenga en cuenta el uso de la clave de matriz asociativa ''Personalizado''.

Finalmente, es necesario cifrar la contraseña al crear un nuevo usuario, por lo que al archivo de modelo (en mi caso Account.php) agregué:

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