Cómo crear un sistema de administración de sesión segura en PHP y MySQL

Coescrito por Tyrone Showers

Esta guía te mostrará cómo guardar las sesiones de forma segura en una base de datos de mySQL. También aprenderás a cifrar todos los datos de la sesión que vayan a la base de datos, o sea que, si alguien logra hackear la base de datos, todos los datos de las sesiones estarán con un cifrado AES de 256 bits.

Método 1

Método 1 de 3:

Configurar la base de datos mySQL

Descargar el PDF

1
Crea una base de datos MySQL.
En esta guía crearemos una base de datos llamada sesiones_seguras .
Observa cómo se crea una base de datos en phpMyAdmin.
O puedes usar el código SQL que hay a continuación para crear una.

Crea el código de la base de datos:
```
 CREATE 
 DATABASE 
 ` 
 sesiones_seguras 
 ` 
 ; 
```
Nota: Algunos servicios de alojamiento no permiten crear una base de datos con phpMyAdmin, aprende a hacerlo en cPanel .
2
Crea un usuario que solo tenga privilegios para SELECT, INSERT y DELETE.
O sea que si llegara a haber alguna brecha en la seguridad de nuestro script, el hacker no podrá eliminar tablas de la base de datos. Si estás realmente paranoico, crea un usuario distinto para cada función.
- Usuario: "sec_user"
- Contraseña: "eKcGZr59zAa2BEWU"
Crea el código de usuario:
```
 CREATE 
 USER 
 'sec_user' 
 @ 
 'localhost' 
 IDENTIFIED 
 BY 
 'eKcGZr59zAa2BEWU' 
 ; 
 GRANT 
 SELECT 
 , 
 INSERT 
 , 
 UPDATE 
 , 
 DELETE 
 ON 
 ` 
 sesiones_seguras 
 ` 
 . 
 * 
 TO 
 'sec_user' 
 @ 
 'localhost' 
 ; 
```
Nota: una buena idea sería cambiar la contraseña del código de arriba al ejecutarlo en tu propio servidor (asegúrate de cambiar también el código PHP). Recuerda que no necesitas recordar la contraseña, así que la puedes hacer lo más difícil que puedas. Aquí hay un generador de contraseñas aleatorias .

3

Crea una tabla MySQL llamada "sesiones".
El código que hay a continuación creará una tabla con 4 campos (id, horario, data, clave_sesion).

Crea la tabla "sesiones":

 CREATE 
 TABLE 
 ` 
 sesiones 
 ` 
 ( 
 ` 
 id 
 ` 
 char 
 ( 
 128 
 ) 
 NOT 
 NULL 
 , 
 ` 
 horario 
 ` 
 char 
 ( 
 10 
 ) 
 NOT 
 NULL 
 , 
 ` 
 data 
 ` 
 text 
 NOT 
 NULL 
 , 
 ` 
 clave_sesion 
 ` 
 char 
 ( 
 128 
 ) 
 NOT 
 NULL 
 , 
 PRIMARY 
 KEY 
 ( 
 ` 
 id 
 ` 
 ) 
 ) 
 ENGINE 
 = 
 InnoDB 
 DEFAULT 
 CHARSET 
 = 
 latin1 
 ;

Usa el tipo de datos CHAR para los campos con longitud conocida, como los campos "id" y "clave_sesion" que siempre tendrán 128 caracteres de largo. Al usar CHAR ahorraremos potencia de procesamiento.

Anuncio

Método 2

Método 2 de 3:

Crear un archivo sesion.class.php

Descargar el PDF

1
Crea una clase.
Para inicializar una clase nueva, necesitarás ingresar el código que sigue:

Clase nueva:
```
 class 
 session 
 { 
```

2

Crea la función __construct.
Se llamará a esta función cada vez que crees una instancia nueva de un objeto usando la clase 'sesion'. Puedes leer sobre la función PHP _construct aquí .
Esta función configura nuestro manejador de sesión personalizado para que esté disponible ni bien se inicialice la clase (o sea, que se haga, se compile o se construya).

__construct function:

 function 
 __construct 
 () 
 { 
 // configura las funciones de la sesión personalizada. 
 session_set_save_handler 
 ( 
 array 
 ( 
 $this 
 , 
 'open' 
 ), 
 array 
 ( 
 $this 
 , 
 'close' 
 ), 
 array 
 ( 
 $this 
 , 
 'read' 
 ), 
 array 
 ( 
 $this 
 , 
 'write' 
 ), 
 array 
 ( 
 $this 
 , 
 'destroy' 
 ), 
 array 
 ( 
 $this 
 , 
 'gc' 
 )); 
 // Esta línea evita efectos inesperados al usar objetos como manipuladores de guardado. 
 register_shutdown_function 
 ( 
 'session_write_close' 
 ); 
 }

3

Crea una función inicio_sesion.
Se llamará a esta función cada vez que alguien quiera iniciar una sesión nueva, en lugar de usar session_start();. Observa los comentarios del código para ver lo que hace cada línea.

función inicio_sesion:

 function 
 inicio_sesion 
 ( 
 $session_name 
 , 
 $secure 
 ) 
 { 
 // Asegúrate de que la cookie de sesión no pueda accederse por javascript. 
 $httponly 
 = 
 true 
 ; 
 // algoritmo hash para usar con sessionid. (usa hash_algos() para ver una lista de los hash disponibles) 
 $session_hash 
 = 
 'sha512' 
 ; 
 // Revisa si hay un hash disponible 
 if 
 ( 
 in_array 
 ( 
 $session_hash 
 , 
 hash_algos 
 ())) 
 { 
 // Configura la función hash. 
 ini_set 
 ( 
 'session.hash_function' 
 , 
 $session_hash 
 ); 
 } 
 // Cuántos bits por caracter del hash. 
 // Los valores posibles son '4' (0-9, a-f), '5' (0-9, a-v), y '6' (0-9, a-z, A-Z, "-", ","). 
 ini_set 
 ( 
 'session.hash_bits_per_character' 
 , 
 5 
 ); 
 // Fuerza a la sesión para que sólo use cookies, no variables URL. 
 ini_set 
 ( 
 'session.use_only_cookies' 
 , 
 1 
 ); 
 // Consigue los parámetros de la cookie de la sesión 
 $cookieParams 
 = 
 session_get_cookie_params 
 (); 
 // Configura los parámetros 
 session_set_cookie_params 
 ( 
 $cookieParams 
 [ 
 "lifetime" 
 ], 
 $cookieParams 
 [ 
 "path" 
 ], 
 $cookieParams 
 [ 
 "domain" 
 ], 
 $secure 
 , 
 $httponly 
 ); 
 // Cambia el nombre de la sesión 
 session_name 
 ( 
 $session_name 
 ); 
 // Ahora podemos iniciar la sesión 
 session_start 
 (); 
 // Esta línea regenera la sesión y elimina la anterior. 
 // También genera una nueva clave de cifrado en la base de datos. 
 session_regenerate_id 
 ( 
 true 
 ); 
 }

4

Crea una función abrir.
Las sesiones PHP llamarán a esta función al iniciar una sesión nueva, la usamos para iniciar una conexión nueva en la base de datos.

función abrir:

 function 
 abrir 
 () 
 { 
 $host 
 = 
 'localhost' 
 ; 
 $user 
 = 
 'sec_user' 
 ; 
 $pass 
 = 
 'eKcGZr59zAa2BEWU' 
 ; 
 $name 
 = 
 'sesiones_seguras' 
 ; 
 $mysqli 
 = 
 new 
 mysqli 
 ( 
 $host 
 , 
 $user 
 , 
 $pass 
 , 
 $name 
 ); 
 $this 
 -> 
 db 
 = 
 $mysqli 
 ; 
 return 
 true 
 ; 
 }

5

Crea una función cerrar.
This function will be called when the sesiones want to be closed.

función cerrar:

 function 
 cerrar 
 () 
 { 
 $this 
 -> 
 db 
 -> 
 cerrar 
 (); 
 return 
 true 
 ; 
 }

6

Crea una función leer.
PHP llamará a esta función cuando intentes acceder a una sesión, por ejemplo cuando uses echo $_SESSION['algo'];. Como puede haber muchas llamadas a esta función en una sola página, aprovecha las declaraciones preparadas, no solo por seguridad sino también por rendimiento. Solo prepara la declaración una vez y luego ejecútala muchas veces.
También descifra los datos de sesión cifrados en la base de datos. Usarás un cifrado AES de 256 bits en las sesiones.

función leer:

 function 
 leer 
 ( 
 $id 
 ) 
 { 
 if 
 ( 
 ! 
 isset 
 ( 
 $this 
 -> 
 read_stmt 
 )) 
 { 
 $this 
 -> 
 read_stmt 
 = 
 $this 
 -> 
 db 
 -> 
 prepare 
 ( 
 "SELECT data FROM sesiones WHERE id = ? LIMIT 1" 
 ); 
 } 
 $this 
 -> 
 read_stmt 
 -> 
 bind_param 
 ( 
 's' 
 , 
 $id 
 ); 
 $this 
 -> 
 read_stmt 
 -> 
 execute 
 (); 
 $this 
 -> 
 read_stmt 
 -> 
 store_result 
 (); 
 $this 
 -> 
 read_stmt 
 -> 
 bind_result 
 ( 
 $data 
 ); 
 $this 
 -> 
 read_stmt 
 -> 
 fetch 
 (); 
 $key 
 = 
 $this 
 -> 
 getkey 
 ( 
 $id 
 ); 
 $data 
 = 
 $this 
 -> 
 decrypt 
 ( 
 $data 
 , 
 $key 
 ); 
 return 
 $data 
 ; 
 }

7

Crea una función escribir.
Se usará esta función cuando asignes un valor a una sesión, por ejemplo $_SESSION['algo'] = 'otra cosa';. La función cifra todos los datos para insertarlos en la base de datos.

función escribir:

 function 
 escribir 
 ( 
 $id 
 , 
 $data 
 ) 
 { 
 // Consigue una clave única 
 $key 
 = 
 $this 
 -> 
 getkey 
 ( 
 $id 
 ); 
 // Cifra los datos 
 $data 
 = 
 $this 
 -> 
 encrypt 
 ( 
 $data 
 , 
 $key 
 ); 
 $time 
 = 
 time 
 (); 
 if 
 ( 
 ! 
 isset 
 ( 
 $this 
 -> 
 w_stmt 
 )) 
 { 
 $this 
 -> 
 w_stmt 
 = 
 $this 
 -> 
 db 
 -> 
 prepare 
 ( 
 "REPLACE INTO sesiones (id, horario, data, clave_sesion) VALUES (?, ?, ?, ?)" 
 ); 
 } 
 $this 
 -> 
 w_stmt 
 -> 
 bind_param 
 ( 
 'siss' 
 , 
 $id 
 , 
 $time 
 , 
 $data 
 , 
 $key 
 ); 
 $this 
 -> 
 w_stmt 
 -> 
 execute 
 (); 
 return 
 true 
 ; 
 }

8

Crea una función destruir.
Esta función elimina la sesión de la base de datos, la usa PHP cuando llamas a funciones como session__destroy();.

función destruir:

 function 
 destruir 
 ( 
 $id 
 ) 
 { 
 if 
 ( 
 ! 
 isset 
 ( 
 $this 
 -> 
 delete_stmt 
 )) 
 { 
 $this 
 -> 
 delete_stmt 
 = 
 $this 
 -> 
 db 
 -> 
 prepare 
 ( 
 "DELETE FROM sesiones WHERE id = ?" 
 ); 
 } 
 $this 
 -> 
 delete_stmt 
 -> 
 bind_param 
 ( 
 's' 
 , 
 $id 
 ); 
 $this 
 -> 
 delete_stmt 
 -> 
 execute 
 (); 
 return 
 true 
 ; 
 }

9

Crea una función gc (recolector de basura, por sus siglas en inglés).
Se llama a la función recolector de basura para eliminar las sesiones antiguas. La frecuencia con la que se llame a esta función estará determinada por las dos directivas de configuración, session.gc_probability y session.gc_divisor.

función gc():

 function 
 gc 
 ( 
 $max 
 ) 
 { 
 if 
 ( 
 ! 
 isset 
 ( 
 $this 
 -> 
 gc_stmt 
 )) 
 { 
 $this 
 -> 
 gc_stmt 
 = 
 $this 
 -> 
 db 
 -> 
 prepare 
 ( 
 "DELETE FROM sesiones WHERE horario < ?" 
 ); 
 } 
 $old 
 = 
 time 
 () 
 - 
 $max 
 ; 
 $this 
 -> 
 gc_stmt 
 -> 
 bind_param 
 ( 
 's' 
 , 
 $old 
 ); 
 $this 
 -> 
 gc_stmt 
 -> 
 execute 
 (); 
 return 
 true 
 ; 
 }

10

Crea una función getkey.
Se usa esta función para obtener la clave única para cifrar la tabla de sesiones. Si no hay una sesión, simplemente devuelve una clave aleatoria nueva para cifrar.

función getkey():

 private 
 function 
 getkey 
 ( 
 $id 
 ) 
 { 
 if 
 ( 
 ! 
 isset 
 ( 
 $this 
 -> 
 key_stmt 
 )) 
 { 
 $this 
 -> 
 key_stmt 
 = 
 $this 
 -> 
 db 
 -> 
 prepare 
 ( 
 "SELECT clave_sesion FROM sesiones WHERE id = ? LIMIT 1" 
 ); 
 } 
 $this 
 -> 
 key_stmt 
 -> 
 bind_param 
 ( 
 's' 
 , 
 $id 
 ); 
 $this 
 -> 
 key_stmt 
 -> 
 execute 
 (); 
 $this 
 -> 
 key_stmt 
 -> 
 store_result 
 (); 
 if 
 ( 
 $this 
 -> 
 key_stmt 
 -> 
 num_rows 
 == 
 1 
 ) 
 { 
 $this 
 -> 
 key_stmt 
 -> 
 bind_result 
 ( 
 $key 
 ); 
 $this 
 -> 
 key_stmt 
 -> 
 fetch 
 (); 
 return 
 $key 
 ; 
 } 
 else 
 { 
 $random_key 
 = 
 hash 
 ( 
 'sha512' 
 , 
 uniqid 
 ( 
 mt_rand 
 ( 
 1 
 , 
 mt_getrandmax 
 ()), 
 true 
 )); 
 return 
 $random_key 
 ; 
 } 
 }

11

Crea las funciones cifrado y descifrado.
Estas funciones cifran los datos de las sesiones con una clave de cifrado de la base de datos que es distinta para cada sesión. No se usa directamente la clave de cifrado, pero la usarás para crear el hash de clave de forma más aleatoria aún.

fuciones encrypt() y decrypt():

 private 
 function 
 encrypt 
 ( 
 $data 
 , 
 $key 
 ) 
 { 
 $salt 
 = 
 'cH!swe!retReGu7W6bEDRup7usuDUh9THeD2CHeGE*ewr4n39=E@rAsp7c-Ph@pH' 
 ; 
 $key 
 = 
 substr 
 ( 
 hash 
 ( 
 'sha256' 
 , 
 $salt 
 . 
 $key 
 . 
 $salt 
 ), 
 0 
 , 
 32 
 ); 
 $iv_size 
 = 
 mcrypt_get_iv_size 
 ( 
 MCRYPT_RIJNDAEL_256 
 , 
 MCRYPT_MODE_ECB 
 ); 
 $iv 
 = 
 mcrypt_create_iv 
 ( 
 $iv_size 
 , 
 MCRYPT_RAND 
 ); 
 $encrypted 
 = 
 base64_encode 
 ( 
 mcrypt_encrypt 
 ( 
 MCRYPT_RIJNDAEL_256 
 , 
 $key 
 , 
 $data 
 , 
 MCRYPT_MODE_ECB 
 , 
 $iv 
 )); 
 return 
 $encrypted 
 ; 
 } 
 private 
 function 
 decrypt 
 ( 
 $data 
 , 
 $key 
 ) 
 { 
 $salt 
 = 
 'cH!swe!retReGu7W6bEDRup7usuDUh9THeD2CHeGE*ewr4n39=E@rAsp7c-Ph@pH' 
 ; 
 $key 
 = 
 substr 
 ( 
 hash 
 ( 
 'sha256' 
 , 
 $salt 
 . 
 $key 
 . 
 $salt 
 ), 
 0 
 , 
 32 
 ); 
 $iv_size 
 = 
 mcrypt_get_iv_size 
 ( 
 MCRYPT_RIJNDAEL_256 
 , 
 MCRYPT_MODE_ECB 
 ); 
 $iv 
 = 
 mcrypt_create_iv 
 ( 
 $iv_size 
 , 
 MCRYPT_RAND 
 ); 
 $decrypted 
 = 
 mcrypt_decrypt 
 ( 
 MCRYPT_RIJNDAEL_256 
 , 
 $key 
 , 
 base64_decode 
 ( 
 $data 
 ), 
 MCRYPT_MODE_ECB 
 , 
 $iv 
 ); 
 return 
 $decrypted 
 ; 
 }

12
Cierra las clases.
Aquí simplemente cierra las clases con llaves:

Cerrar las clases:
```
 } 
```
Anuncio

Método 3

Método 3 de 3:

Crear páginas con sesiones

Descargar el PDF

1

Usa sesiones con el administrador de sesiones personalizado.
A continuación se muestra cómo iniciar una sesión nueva; necesitarías incluir esto en todas las páginas que quieras acceder con las sesiones, úsala en vez de session_start();

Inicia una sesión:

 require 
 ( 
 'sesion.class.php' 
 ); 
 $session 
 = 
 new 
 session 
 (); 
 // Ponlo en true si usas https 
 $session 
 -> 
 inicio_sesion 
 ( 
 '_s' 
 , 
 false 
 ); 
 $_SESSION 
 [ 
 'algo' 
 ] 
 = 
 'Un valor.' 
 ; 
 echo 
 $_SESSION 
 [ 
 'algo' 
 ];

Iniciar sesión

Cómo crear un sistema de administración de sesión segura en PHP y MySQL

Pasos

Configurar la base de datos mySQL

Crear un archivo sesion.class.php

Crear páginas con sesiones

wikiHows relacionados

Acerca de este wikiHow

¿Te ayudó este artículo?

Artículos relacionados

¡Suscríbete al boletín gratuito de wikiHow!

Compartir

Artículos destacados

Tendencias de tutoriales

Artículos destacados

Vídeos destacados

Artículos destacados

Artículos destacados

Artículos destacados

Explore Categories