[APORTE] Sistema de Sesiones y Autentificación de usuario con MySQL

[Nisrokh]

Hola gente, como le va... Hace rato que no entraba a Foros del Web, y decidi hacer un posteo con un aporte por primera vez, además me gustaría que me ayuden a mejorar y ver si lo que hice es seguro o no, etc... He hecho un sistema de sesiones y autentificacion de usuario para un portal en el que estoy trabajando, y me gustaría que dejen su comentario para ver si lo que hice realmente sirve y como dije, si es seguro... ¡Espero que les sirva!

Nota: Está documentado en Inglés ya que más que nada lo hice para guiarme yo mismo, el inglés siempre me pareció más simple y corto de escribir comparado al español :p

Antes de empezar, les pido que lean todo el posteo antes de probala en su servidor XAMPP, o el que tengan...

Tablas MySQL:

Código MySQL:

-- Tabla para las sesiones
CREATE TABLE IF NOT EXISTS `_sessions` (
  `session_id` varchar(64) NOT NULL DEFAULT '',
  `session_data` longtext NOT NULL,
  `session_touched` bigint(20) unsigned NOT NULL,
  UNIQUE KEY `session_id` (`session_id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
 
-- Tabla para usuarios
CREATE TABLE IF NOT EXISTS `_users` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `account_name` varchar(16) NOT NULL DEFAULT '',
  `account_pass` varchar(32) NOT NULL DEFAULT '',
  `account_email` varchar(96) NOT NULL DEFAULT '',
  `account_type` tinyint(1) unsigned NOT NULL DEFAULT '1',
  `account_status` tinyint(1) NOT NULL DEFAULT '0',
  `account_validation_key` varchar(32) NOT NULL DEFAULT '',
  `account_registered_date` datetime NOT NULL DEFAULT '0000-00-00 00:00:00',
  PRIMARY KEY (`id`),
  UNIQUE KEY `account_name` (`account_name`),
  KEY `account_email` (`account_email`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8;
 
-- Insertamos un usuario de prueba...
-- Usuario: demo
-- Clave: demo
INSERT INTO `_users` (`id`, `account_name`, `account_pass`, `account_email`, `account_type`, `account_status`, `account_validation_key`, `account_registered_date`) VALUES
(1, 'demo', '$1$CZ..jd4.$/zsff1Id4S9h3gylYr/6R/', '[email protected]', 0, 1, '', '2010-01-01 16:00:00');
 

Nora: la clave fue encryptada con crypt() utilizando como salt: $1$CZ..jd4.$XUyjB06VQ7K.E3yKw7hXh/ En una de las clases que verán a continuación, van a notar que ya les puse el salt en una variable...

Bueno, a continuacion la clase de Sessiones y Autentificación:

[Nisrokh]

SimpleSession.php

Código PHP:

<?php
 
/**
 * @author estilodg.com <[email protected]>
 * @copyright 2010
 */
 
// Error code constants
define('LOGIN_ACCESS_NO_ATTEMPT', -1);
define('LOGIN_ACCESS_GRANTED', 0);
define('LOGIN_ACCESS_ERROR_ATTEMPT_FAILED', 1);
define('LOGIN_ACCESS_ERROR_NONEXISTENT_ACCOUNT', 2);
define('LOGIN_ACCESS_ERROR_UNAUTHORIZED_ACCOUNT', 3);
define('LOGIN_ACCESS_ERROR_UNVALIDATED_ACCOUNT', 4);
define('LOGIN_ACCESS_ERROR_BLOCKED_ACCOUNT', 5);
define('LOGIN_ACCESS_ERROR_MISSING_USERNAME', 6);
define('LOGIN_ACCESS_ERROR_MISSING_PASSWORD', 7);
define('LOGIN_ACCESS_ERROR_UNKNOWN_ERROR', 8);
 
// Session data encryption keys
define('SESSION_DATA_ENCRYPTION_KEY_1', '944672318');
define('SESSION_DATA_ENCRYPTION_KEY_2', '410344323');
 
/**
 * Simple Login Management
 * 
 * @package SimpleSession
 * @subpackage SimpleLogin
 * @author Diego P. M. Baltar <[email protected]>
 * @copyright 2010
 * @version 0.1
 */
abstract class SimpleLogin {
    
    /**
     * Authentification salt
     * 
     * @access private
     * @var string
     */
    private $auth_salt = '$1$CZ..jd4.$XUyjB06VQ7K.E3yKw7hXh/';
    
    /**
     * Login status
     * 
     * @access public
     * @var integer
     */
    public $status = LOGIN_ACCESS_NO_ATTEMPT;
    
    /**
     * Login
     * 
     * @access public
     * @return void
     */
    public function login($username = '', $password = '') {
        
        if ($this->logged_in())
            return;
        
        $username = trim($username);
        $password = trim($password);
        
        if (!$username or empty($username)) {
            $this->status = LOGIN_ACCESS_ERROR_MISSING_USERNAME;
            return;
        } else if (!$password or empty($password)) {
            $this->status = LOGIN_ACCESS_ERROR_MISSING_PASSWORD;
            return;
        }
        
        // Encrypt password
        $password = crypt($password, $this->auth_salt);
        
        // Build and execute query
        $query_sentence = "
            SELECT
                id, account_name, account_pass, account_type, account_status
            FROM
                {$this->mysql->tables['users']}
            WHERE
                account_name = '%s'
        ";
        $this->mysql->query(sprintf($query_sentence, $this->mysql->escape($username)));
        
        // If user exists...
        if ($this->mysql->affected_rows > 0) {
            $row = $this->mysql->query_result[0];
            $this->mysql->clean();
            
            // 0 => Administrator, 1 => Moderator, 2 => User
            // Allow administrators and moderators only
            if ((int)$row->account_type > 1) {
                $this->status = LOGIN_ACCESS_ERROR_UNAUTHORIZED_ACCOUNT;
                return;
            }
            
            // Check whether the user account is unvalidated
            if ((int)$row->account_status == 0) {
                $this->status = LOGIN_ACCESS_ERROR_UNVALIDATED_ACCOUNT;
                return;
            }
            
            // Check user password
            if (substr($password, 0, 32) == $row->account_pass) {
                
                // Now we check if the user account has been blocked
                if ((int)$row->account_status == -1) {
                    $this->status = LOGIN_ACCESS_ERROR_BLOCKED_ACCOUNT;
                    return;
                } else if ((int)$row->account_status == 1) {
                    $this->status = LOGIN_ACCESS_GRANTED;
                    $this->data->account_id = (int)$row->id;
                    $this->data->account_name = $row->account_name;
                    $this->data->account_type = (int)$row->account_type;
                    $this->data->access = true;
                    $this->regenerate_id(true);
                    return;
                }
            } else {
                $this->status = LOGIN_ACCESS_ERROR_ATTEMPT_FAILED;
                return;
            }
        } else {
            $this->status = LOGIN_ACCESS_ERROR_NONEXISTENT_ACCOUNT;
            return;
        }
    }
    
    public function logout() {
        if ($this->logged_in())
            $this->destroy();
    }
    
    /**
     * Check if user is logged in
     * 
     * @access public
     * @return boolean
     */
    public function logged_in() {
        if (!isset($this->data->account_name))
            unset($this->data->access);
        else {
            $username = trim($this->data->account_name);
            if (!$username or empty($username)) {
                unset($this->data->account_id);
                unset($this->data->account_name);
                unset($this->data->account_type);
                unset($this->data->access);
            }
        } return $this->data->access;
    }
}
 
// Continua...
 
?>
 

[Nisrokh]

Continuacion de SimpleSession.php

Código PHP:

<?php
 
/**
 * Simple Session
 * 
 * @package SimpleSession
 * @author Diego P. M. Baltar <[email protected]>
 * @copyright 2010
 * @version 0.2
 */
class SimpleSession extends SimpleLogin {
    
    /**
     * Session garbage collector divisor
     * 
     * @access private
     * @var integer
     */
    private $gc_divisor = 100;
    
    /**
     * Session garbage collector lifetime
     * 
     * @access private
     * @var integer
     */
    private $gc_maxlifetime = 3600;
    
    /**
     * Session garbage collector probability
     * 
     * @access private
     * @var integer
     */
    private $gc_probability = 10;
    
    /**
     * Encryption available
     * 
     * @access private
     * @var boolean
     */
    private $encryption;
    
    /**
     * Encryption key
     * 
     * @access private
     * @var string
     */
    private $encryption_key;
    
    /**
     * SimpleMySQL object
     * 
     * @access protected
     * @var object
     */
    protected $mysql = null;
    
    /**
     * Session name
     * 
     * @access protected
     * @var string
     */
    protected $name = '__SESSID';
    
    /**
     * Session lifetime
     * 
     * @access protected
     * @var integer
     */
    protected $lifetime = 1800;
    
    /**
     * Session cookie path
     * 
     * @access protected
     * @var string
     */
    protected $cookie_path = '/';
    
    /**
     * SimpleSessionVars object
     * 
     * @access private
     * @var object
     */
    public $data = null;
    
    /**
     * Session ID
     * 
     * @access public
     * @var string
     */
    public $id;
    
    /**
     * SimpleSession object constructor
     * 
     * @access public
     * @param object SimpleMySQL instance
     * @return void
     * 
     * @see SimpleSessionVars
     */
    public function __construct(SimpleMySQL $MySQL) {
        
        if (!extension_loaded('mcrypt'))
            $this->encryption = false;
        else if (!function_exists('mcrypt_module_open'))
            $this->encryption = false;
        else {
            $this->encryption = true;
            
            $key_1 = md5(SESSION_DATA_ENCRYPTION_KEY_1);
            $key_2 = md5(SESSION_DATA_ENCRYPTION_KEY_2);
            
            $this->encryption_key = $key_1.$key_2;
        }
        
        // Save MySQL object and clean its previous results if any
        $this->mysql = $MySQL;
        $this->mysql->clean();
        
        // Set session garbage collector properties
        ini_set('session.gc_divisor', $this->gc_divisor);
        ini_set('session.gc_probability', $this->gc_probability);
        ini_set('session.gc_maxlifetime', $this->gc_maxlifetime);
        
        // Set session id hashing options
        ini_set('session.hash_function', 1);
        ini_set('session.hash_bits_per_character', 5);
        
        // Set handler functions
        session_set_save_handler(
            array(&$this, '__open'),
            array(&$this, '__close'),
            array(&$this, '__read'),
            array(&$this, '__write'),
            array(&$this, '__destroy'),
            array(&$this, '__gc')
        );
        
        // Call session_write_close() from the object destructor
        @register_shutdown_function(array(&$this, '__destruct'));
    }
    
    /**
     * SimpleSession object destructor
     * 
     * @access public
     * @return boolean
     */
    public function __destruct() {
        
        // Call session_write_close() then return true
        session_write_close();
        return true;
    }
    
    public function __open($save_path, $session_name) {
        return true;
    }
    
    public function __close() {
        return true;
    }
    
    public function __read($session_id) {
        
        $session_id = $this->mysql->escape($session_id);
        $session_data = '';
        
        // Build query to retrieve current session data
        $query_sentence = "
            SELECT
                session_data
            FROM
                {$this->mysql->tables['sessions']}
            WHERE
                session_id = '%s'
        ";
        $this->mysql->query(sprintf($query_sentence, $session_id));
        
        // Check if session data is available
        if ($this->mysql->affected_rows > 0) {
            $session_data = $this->mysql->query_result[0]->session_data;
            $session_data = $this->decrypt($session_data);
            $this->mysql->clean();
        }
        
        // If no session data was found, return an empty string
        return (string)$session_data;
    }
    
    public function __write($session_id, $session_data) {
        
        $session_id = $this->mysql->escape($session_id);
        $session_data = $this->encrypt($session_data);
        
        // Build query to write/rewrite current session data into database
        $query_sentence = "
            REPLACE INTO
                {$this->mysql->tables['sessions']}
                (session_id, session_data, session_touched)
            VALUES
                ('%s', '%s', UNIX_TIMESTAMP())
        ";
        $this->mysql->query(sprintf($query_sentence, $session_id, $session_data));
        $this->mysql->clean();
        
        return true;
    }
    
    public function __destroy($session_id) {
        
        $session_id = $this->mysql->escape($session_id);
        
        // Build query to delete the current session from database
        $query_sentence = "
            DELETE FROM
                {$this->mysql->tables['sessions']}
            WHERE
                session_id = '%s'
        ";
        $this->mysql->query(sprintf($query_sentence, $session_id));
        
        return true;
    }
    
    public function __gc($session_max_lifetime) {
        $query_sentence = "
            DELETE FROM
                {$this->mysql->tables['sessions']}
            WHERE
                session_touched + {$session_max_lifetime} < UNIX_TIMESTAMP()
        ";
        $this->mysql->query($query_sentence);
        return true;
    }
    
    /**
     * Session start
     * 
     * @access public
     * @return unknown
     */
    public function start() {
        
        session_name($this->name);
        session_set_cookie_params($this->lifetime, $this->cookie_path);
        session_cache_limiter('nocache');
        
        header("Pragma: no-cache");
        header("Expires: Mon, 28 Aug 1989 02:22:00 GMT");
        header("Last-Modified: " .gmdate("D, d M Y H:i:s"). " GMT");
        header("Cache-Control: no-store, no-cache, must-revalidate");
        header("Cache-Control: post-check=0, pre-check=0", false);
        
        session_start();
        
        $this->id = session_id();
        
        // Create SimpleSessionData object to manipulate session data
        // I.e.: $SimpleSession->data->foo = 'bar' => ($_SESSION['foo'] = 'bar')
        $this->data = new SimpleSessionData;
    }
    
    /**
     * Session destroy
     * 
     * @access public
     * @return boolean
     */
    public function destroy() {
        
        // Unset all session variables
        $this->id = null;
        session_unset();
        
        // Delete session cookie, if found
        if (isset($_COOKIE[$this->name]))
            @setcookie($this->name, '', time() - $this->lifetime, $this->cookie_path);
        
        // Destroy the current session
        return session_destroy();
    }
    
    /**
     * Session regenerate ID
     * 
     * @access public
     * @param boolean $delete_old_session
     * @return boolean
     */
    public function regenerate_id($delete_old_session = false) {
        if (session_regenerate_id($delete_old_session))
            $this->id = session_id();
        else return false;
    }
    
    /**
     * Session data encrypter
     * 
     * @access public
     * @param string $session_data
     * @return string
     */
    private function encrypt($session_data = '') {
        
        if (empty($session_data))
            return $session_data;
        
        if (!$this->encryption)
            return base64_encode($session_data);
        
        $td = mcrypt_module_open('rijndael-256', '', 'ecb', '');
        $ks = mcrypt_enc_get_key_size($td);
        
        $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
        $key = substr($this->encryption_key, 0, $ks);
        
        mcrypt_generic_init($td, $key, $iv);
        
        // Encrypt data
        $encrypted_data = mcrypt_generic($td, $session_data);
        
        mcrypt_generic_deinit($td);
        mcrypt_module_close($td);
        
        return base64_encode($encrypted_data);
    }
    
    /**
     * Session data decrypter
     * 
     * @access public
     * @param string $session_data
     * @return string
     */
    private function decrypt($session_data = '') {
        
        if (empty($session_data))
            return $session_data;
        
        $session_data = base64_decode($session_data);
        
        if (!$this->encryption)
            return $session_data;
        
        $td = mcrypt_module_open('rijndael-256', '', 'ecb', '');
        $ks = mcrypt_enc_get_key_size($td);
        
        $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
        $key = substr($this->encryption_key, 0, $ks);
        
        mcrypt_generic_init($td, $key, $iv);
        
        // Decrypt data
        $decrypted_data = mdecrypt_generic($td, $session_data);
        
        mcrypt_generic_deinit($td);
        mcrypt_module_close($td);
        
        $decrypted_data = rtrim($decrypted_data);
        
        return (string)$decrypted_data;
    }
}
 
/**
 * Simple Session Data
 * 
 * @package SimpleSession
 * @subpackage SimpleSessionData
 * @author Diego P. M. Baltar <[email protected]>
 * @copyright 2010
 * @version 0.1
 */
class SimpleSessionData {
    
    public function __set($var, $value) {
        $_SESSION[$var] = $value;
    }
    
    public function __get($var) {
        if (!isset($_SESSION[$var]))
            return null;
        else return $_SESSION[$var];
    }
    
    public function __isset($var) {
        return isset($_SESSION[$var]);
    }
    
    public function __unset($var) {
        unset($_SESSION[$var]);
    }
}
 
?>
 

[Nisrokh]

Nota: Para poder utilizar las clases de alli arriba, deben utilizar una para MySQL que yo mismo he hecho... Si despues quiren pueden adaptarlo a la suya... Pero el codigo fue hecho con la utilizacion de la siguiente clase para MySQL... Bien "Simple".

SimpleMySQL.php

Código PHP:

<?php
 
/**
 * @author estilodg.com <[email protected]>
 * @copyright 2009
 */
 
/**
 * MySQL Management Class
 * 
 * @author Diego P. M. Baltar <www.estilodg.com>
 * @package SimpleMySQL
 */
class SimpleMySQL
{
    /**
     * Link identifier
     * 
     * @access public
     * @var resource
     */
    public $link = null;
    
    /**
     * Selected database
     * 
     * @access public
     * @var string
     */
    public $database = null;
    
    /**
     * Query result resource
     * 
     * @access public
     * @var resource
     */
    public $result = null;
    
    /**
     * Query result data
     * 
     * @access public
     * @var array
     */
    public $query_result = array();
    
    /**
     * Query error
     * 
     * @access public
     * @var boolean
     */
    public $query_error = false;
    
    /**
     * Selected rows
     * 
     * @access public
     * @var integer
     */
    public $rows = null;
    
    /**
     * Number of affected rows
     * 
     * @access public
     * @var integer
     */
    public $affected_rows = null;
    
    /**
     * Last inserted id
     * 
     * @access public
     * @var integer
     */
    public $last_id = null;
    
    /**
     * MySQL connection state
     * 
     * @access public
     * @var boolean
     */
    public $ready = false;
    
    /**
     * Database tables
     */
    public $tables = array();
    
    public function __construct($hostname = 'localhost', $username = 'root', $password = '')
    {
        return $this->connect($hostname, $username, $password);
    }
    
    public function __destruct()
    {
        return true;
    }
    
    /**
     * MySQL connect
     * 
     * @param string $hostname MySQL server address/ip(port)
     * @param string $username MySQL username
     * @param string $password MySQL password
     * @return boolean
     */
    private function connect($hostname,$username,$password)
    {
        $this->link = @mysql_connect($hostname, $username, $password, true);
        if (!$this->link) return exit(mysql_error($this->link));
        else return $this->ready = true;
    }
    
    /**
     * MySQL select database
     * 
     * @param string $database MySQL database name to use
     * @return boolean
     */
    public function select_db($database = '')
    {
        if (!$this->link) return exit(mysql_error($this->link));
        else if (!@mysql_select_db($database)) {
            $this->ready = false;
            return exit(mysql_error($this->link));
        }
        else $this->database = $database;
        return true;
    }
    
    /**
     * MySQL query
     * 
     * @param string $sentence MySQL query sentence
     * @return integer Number of selected rows
     */
    public function query($sentence = '')
    {
        if (!$this->link) return exit(mysql_error($this->link));
        $this->result = @mysql_query($sentence, $this->link);
        if (!$this->result) {
            $this->query_error = true;
            return exit(mysql_error($this->link));
        }
        
        $this->affected_rows = mysql_affected_rows($this->link);
        
        if (preg_match('/^\s*(insert|replace)(.+)/is',$sentence))
            $this->last_id = mysql_insert_id($this->link);
        
        if (preg_match('/^\s*(select)(.+)/is', $sentence)) {
            if ($this->affected_rows > 0) {
                $rows = 0;
                while ($row = mysql_fetch_object($this->result)) {
                    $this->query_result[$rows] = $row;
                    $rows++;
                }
            }
        }
        
        @mysql_free_result($this->result);
        
        if ($this->query_error) $this->query_error = false;
        
        $this->rows = $rows;
        return true;
    }
    
    /**
     * Clean cached query result
     * 
     * @access public
     * @return void
     */
    public function clean()
    {
        $this->query_error = false;
        $this->query_result = array();
        $this->affected_rows = null;
    }
    
    /**
     * Espaces a string
     * 
     * @access public
     * @param string $string
     * @return string
     */
    public function escape($string)
    {
        if (!$this->link) return exit(mysql_error($this->link));
        $string = stripslashes($string);
        return @mysql_real_escape_string($string, $this->link) ;
    }
}
 
?>
 

[Nisrokh]

Cosas que deberán modificar:

1) La variable SimpleLogin::$auth_salt, en el archivo SimpleSession.php tienen que poner su propio salt, si desean encryptar las claves con crypt(), si quieren utilizar otro metodo sientanse libres de ir al metodo SimpleLogin::login() y cambiar este detalle...
2) En las consultas MySQL, los nombres de las tablas "_sessions" y "_users" se toman desde el arreglo (array) SimpleMySQL::$tables Solo deben armar ese arreglo de la siguiente manera para no tener que modificar todas las consultas... (Al menos para probarlo...)

Código PHP:

<?php
 
// Tablas
$_TABLES = array(
    'users' => '_users',
    'sessions' => '_sessions'
);
 
$MySQL = new SimpleMySQL('mysql_server', 'mysql_user', 'mysql_pass');
$MySQL->select_db('mysql_db_name');
$MySQL->tables = $_TABLES;
 
?>
 

3) Modifiquen a su gusto las llaves para utilizar mcrypt, para encryptar los datos de la sesion... En el archivo SimpleSession.php, al principio van a ver la definicion de estas dos constantes: SESSION_DATA_ENCRYPTION_KEY_1 y SESSION_DATA_ENCRYPTION_KEY_2

4) Pueden modificar el nombre del COOKIE enviado para las sesiones y la duracion:
SimpleSession::$name // Default: __SESSID
SimpleSession::$lifetime // Default: 1800 (30 minutos)

Una ves creado la base de datos con las tablas, ya podemos probar todo:
test.php

Código PHP:

<?php
 
include 'SimpleMySQL.php';
include 'SimpleSession.php';
 
// Creamos instancia de SimpleMySQL
$SimpleMySQL = new SimpleMySQL('localhost', 'root', 'pass');
$SimpleMySQL->select_db('test');
$SimpleMySQL->tables = array(
    'users' => '_users',
    'sessions' => '_sessions'
);
 
// Creamos instancia de SimpleSession, pasando como unico argumento,
// la instancia de SimpleMySQL
$SimpleSession = new SimpleSession($SimpleMySQL);
$SimpleSession->start();
 
if ((bool)$_POST['login'])
    $SimpleSession->login($_POST['username'], $_POST['password']);
 
if (isset($_GET['logout']))
    $SimpleSession->logout();
 
$_SESSION_ERROR = array(
    1 => 'La contraseña no coincide con el nombre de usuario ingresado.',
    2 => 'El nombre de usuario ingresado es inexistente.',
    3 => 'La cuenta con la que usted está tratando de ingresar, no está autorizada para acceder al área de administración.',
    4 => 'La cuenta con la que usted está tratando de ingresar, aún no ha sido validada. <br />Si usted es el dueño de esta cuenta, puede validarla haciendo clic <a href="#" class="blue">aquí</a>.',
    5 => 'La cuenta con la que usted está tratando de ingresar ha sido bloqueada por un administrador.',
    6 => 'No ha ingresado su nombre de usuario.',
    7 => 'No ha ingresado su contraseña.',
    8 => 'Se ha producido un error interno desconocido. Por favor, intente más tarde.'
);
 
// Si hay un error lo imprimimos
if ($SimpleSession->status > 0) {
    print '<p style="color: red;">' .$_SESSION_ERROR[$SimpleSession->status]. '</p>';
}
 
if ($SimpleSession->logged_in()) {
?>
<h4>Bienvenido, <span style="color: red;"><?php print $SimpleSession->data->account_name ?></span></h4>
<p>ID de sesión: <strong><?php print $SimpleSession->id ?></strong><br />ID de usuario: <strong><?php print $SimpleSession->data->account_id ?></strong><br /><a href="?logout">Cerrar sesi&oacute;n</a></p>
<h4>Datos almacenados en la superglobal $_SESSION</h4>
<pre>
<?php print_r($_SESSION) ?>
</pre>
<p><strong>Nota</strong>: Se pueden llamar y almacenar dato en $_SESSION a travé del objeto SimpleSessionData de la siguiente manera:</p>
<pre>
$SimpleSession->data->foo = 'bar';
 
// Lo cual es lo mismo a hacer:
 
$_SESSION['foo'] = 'bar';
 
// Por ahi les paresca tonto pero al menos ami
// Siempre me parecio mas facil manejar variables
// en forma de objeto que arreglos...
</pre>
<?php
} else {
?>
<fieldset style="display: inline-block;">
    <legend>Prueba de SimpleSession</legend>
    <form method="post">
        <input type="hidden" name="login" value="1" />
        <table>
            <tr>
                <td><label for="username">Usuario</label></td>
                <td><input type="text" id="username" name="username" maxlength="16" /></td>
            </tr>
            <tr>
                <td><label for="password">Contrase&ntilde;a</label></td>
                <td><input type="password" id="password" name="password" maxlength="16" /></td>
            </tr>
            <tr>
                <td>&nbsp;</td>
                <td><input type="submit" value="Iniciar sesi&oacute;n" /></td>
            </tr>
        </table>
    </form>
</fieldset>
<?php
}
 
?>
 

Como van a ver en el archivo test.php, explico que pueden llamar variables de $_SESSION a traves del objeto SimpleSessionData... Por ahi les parece inutil, pero a mi siempre me parecio mas facil utilizar variables en forma de objeto, en vez de arreglos...

Asi que pueden hacer de las dos maneras:

Código PHP:

<?php
 
// Esto:
$SimpleSession->data->foo = 'bar';
print $SimpleSession->data->foo;
 
// Es igual a esto:
$_SESSION['foo'] = 'bar';
print $_SESSION['foo'] ;
 
// Otro ejemplo...
if (isset($SimpleSession->data->foo)) {
    print 'Existe foo';
    unset($SimpleSession->data->foo);
}
 
 
?>
 

Simplemente acuerdense de usar este metodo despues de $SimpleSession->start();

Bueno... Espero que les sirva y comenten... ¡Si ven que algo anda mal avisen! De seguro yo mismo tambien tratare de mejorarlo...

¡Saludos a todos!

[Nisrokh]

Otras cosas que deben saber es que al autentificar un usuario, se guardan los siguientes datos en la sesion:

Código PHP:

<?php
 
// ID del la cuenta
$_SESSION['account_id'];
 
// Nombre de la cuenta
$_SESSION['account_name'];
 
// Tipo de la cuenta
// En mi caso lo utilize asi:
// 0 => Administrador, 1 => Moderador, 2 o mas => Usuario normal
// Pueden cambiar o sacar esto cambiando la tabla _users y modificando
// el metodo SimpleSession::login() y eliminando/cambiando la constante:
// LOGIN_ACCESS_ERROR_UNAUTHORIZED_ACCOUNT
$_SESSION['account_type'];
 
// Al estar logueado esto queda como true, pero ojo...
// Al checkear si alguien esta logueado con SimpleSession::logged_in()
// Se fija si existe el nombre usuario ($_SESSION['account_name'])
// Sino existe o esta vacio, se cierra la session del usuario
// eliminando todas las variables mencionadas aqui, incluso esta misma
$_SESSION['access'];
 
?>
 

Nota: Para determinar si el usuario esta logueado, se comprueba que:

* $_SESSION['account_name'] exista y no este vacia
* $_SESSION['access'] que como booleano siempre de true

¡Si les parece inseguro sugieran otro metodo para mejorarlo!

Al intentar un usuario loguearse, login se encarga de setear los errores utilizando las constantes definidas en SimpleSession.php

Código PHP:

<?php
 
define('LOGIN_ACCESS_NO_ATTEMPT', -1); // Solo para una referencia de que no se intento loguear...
define('LOGIN_ACCESS_GRANTED', 0); // Usuario se logue correctamente (no hay error)
 
// Error de login: contraseña incorrecta
define('LOGIN_ACCESS_ERROR_ATTEMPT_FAILED', 1);
 
// Error de login: cuenta inexistente
define('LOGIN_ACCESS_ERROR_NONEXISTENT_ACCOUNT', 2);
 
// Error de login: cuenta no autorizada
// Deben modificar el metodo SimpleLogin::login() y cambiar la parte en q solo deja entrar
// a usuarios con account_type = 0 || 1
// Ya que en mi caso solo keria dejar entrar admins y mods
// Si tienen dudas pregunten
define('LOGIN_ACCESS_ERROR_UNAUTHORIZED_ACCOUNT', 3);
 
// Error de login: cuenta sin validar
// De nuevo: modifiquen si kieren, el metodo SimpleLogin::login()
// Ya que solo deja entrar a usuarios validados
// con account_status = 1 (validado) || 0 (sin validar)
define('LOGIN_ACCESS_ERROR_UNVALIDATED_ACCOUNT', 4);
 
// Error de login: cuenta bloqueada
// cuando account_status < 0
define('LOGIN_ACCESS_ERROR_BLOCKED_ACCOUNT', 5);
 
// Error de login: no se ingreso usuario en el form
define('LOGIN_ACCESS_ERROR_MISSING_USERNAME', 6);
 
// Error de login: no se ingreso clave en el form
define('LOGIN_ACCESS_ERROR_MISSING_PASSWORD', 7);
 
?>
 

Si el logueo falla, podemos imprimir los errores de una menera muy simple, de acorde a los errores dados en las constantes:

Código PHP:

<?php
 
$SimpleSession = new SimpleSession($MySQL);
$SimpleSession ->start();
$SimpleSession->login('test', 'test');
 
$_SESSION_ERROR = array(
    1 => 'La contraseña no coincide con el nombre de usuario ingresado.',
    2 => 'El nombre de usuario ingresado es inexistente.',
    3 => 'La cuenta con la que usted está tratando de ingresar, no está autorizada para acceder al área de administración.',
    4 => 'La cuenta con la que usted está tratando de ingresar, aún no ha sido validada. <br />Si usted es el dueño de esta cuenta, puede validarla haciendo clic <a href="#" class="blue">aquí</a>.',
    5 => 'La cuenta con la que usted está tratando de ingresar ha sido bloqueada por un administrador.',
    6 => 'No ha ingresado su nombre de usuario.',
    7 => 'No ha ingresado su contraseña.',
    8 => 'Se ha producido un error interno desconocido. Por favor, intente más tarde.'
);
 
// Si hay un error lo imprimimos
if ($SimpleSession->status > 0) {
    print '<p>' .$_SESSION_ERROR[$SimpleSession->status]. '</p>';
}
 
?>
 

Y por último... Al utilizar el metodo SimpleLogin::logout() se destruyen TODAS las variables de la sesion... Si desean mantener datos aun despues de que un usuario cierre sesion, cambian el metodo SimpleLogin::logout() para que solo destruya las variables de las que hablamos anteriormente:

Código PHP:

$_SESSION['account_id'];
$_SESSION['account_name'];
$_SESSION['account_type'];
$_SESSION['access'];
 

Si tienen dudas, ya saben... ¡Pregunten!

[Nisrokh]

Bueno, si llegué a la página 6 sin ninguna respuesta, creo que a nadie le sirvio... xD Mi primer aporte ha fallado...

Saludos...

[genuine_carlosV2]

Buenas,

No he llegado a implementarlo pero me lo he mirado por encima. Si me permites, te haré una sugerencia:
No cifres los passwords, eso es un fallo de seguridad en tu web. Si por lo que sea, alguien lograse acceder a tu BD, haciendo la operación inversa obtendría los passwords (das la contraseña) de todos tus usuarios (incluyendo, si existen, administradores). Además, si no dieses la contraseña, alguien con mala leche, también podría sacarla por fuerza bruta (nunca creas que a ti no te va a pasar porque la gente se aburre mucho). Finalmente, desde un punto de vista moral y de confianza a tus usuarios, tu no deberías saber los passwords de éstos ya que eres el administrador de la web y, por tanto, ya tienes acceso a lo que quieras, saber los passwords de la gente te puede dar acceso a otros sitios web/ordenadores donde hayan puesto el mismo password (si, fallo de los usuarios, pero dime, seguro que tienes passwords distintos para TODO? si la respuesta es si, enhorabuena, eres de los pocos que le importan sus datos. En caso contrario, piensa que si a tu ya pones varias contraseñas iguales, imagínate la gente que no le gusta o no tiene curiosidad por la informática).

Que deberías hacer para solucionar esto? Usa un sistema de una sola dirección como, por ejemplo, los HASH. Basa tu sistema de passwords en MD5. Por ejemplo:
Si mi password fuese 'Nisrokh', guarda en tu base de datos 'a2aa89f25ae1392526ebf99e1e6bed01' de modo que no hay forma de saber si esa cadena proviene de 'Nisrokh' o de vete tu a saber donde.
Para verificar que un password sea correcto, tan solo haz:

Código PHP:

  if( md5( $campo_formulario ) == $password_guardado ) {
echo 'Aplicar un mismo hash dos veces a un mismo texto da el mismo resultado';
} else {
echo 'Si los hashes no son iguales, significa que no provienen del mismo texto';
} 
   

Si alguien pierde su password, tienes que verificar sus datos como sea y solicitarle un nuevo password o poner un password predefinido como md5( 'predefinido' ) o, incluso, una cadena aleatoria que ya le enviarás vía e-mail o como sea.

Finalmente, quiero hacer una reflexión sobre los sitios web en general y este tema. NUNCA y repito, NUNCA te fíes de una web en la cual, si te olvidas tu password, sean capaces de devolvertelo porque eso significa que ellos SABEN cual es tu password (no son correctos moralmente hablando) y, por tanto, si sufren un ataque, el atacante tiene una posibilidad de saber también tu password (no son correctos hablando de seguridad). De quien te puedes fiar pues? Pues de todas esas webs que, si olvidas tu password, te dan un período de X días para que introduzcas un password nuevo o cosas así.

P.D.: Según la actual ley española, revelar datos de una BD está castigado para el programador con 30.000 € por cada dato. Si uno entra en tu web y coge los passwords de 100 personas que tengas registradas, multiplica...

Saludos

[SainT90]

otro fallo que veo es que tienes en la db bigint20 en el campo id

99.999.999.999.999.999.999

tendrás tantos usuarios?

999.999.999.999

yo siempre pongo esos int 12.

ya es demasiado, pero por si las moscas ;)

también se complica demasiado para hacer un simple login

[genuine_carlosV2]

SainT90,

Según tengo entendido, el valor numérico después de 'int' no indica la cantidad de dígitos que acepta el número (esto si es así en el formato DECIMAL). Igualmente, coincido contigo en que usar un BIGINT es un poco excesivo.

Corrígeme si me equivoco.

Saludos

[Nisrokh]

genuine_carlosV2, me has informado bastante bien, gracias.

SainT90, el BIGINT no lo veo que sea un fallo, si esto es un aporte se supone que cada uno lo ajuste a su manera...

genuine_carlosV2, gracias por tu aporte...

Igualmente yo mismo me he dado cuenta de varias cosas que son necesarias modificar...

¡Saludos a todos y gracias por su ayuda!