:::: MENU ::::

La evolución: Local Storage & Session Storage

¡Hola programadores!
Como ya dije hace un tiempo, me niego a poner el cartelito de las cookies, pero bueno, luego en la práctica no es para nada necesario y en realidad… si os quedáis hasta abajo, veréis que en este tema, no influye.

Sea como fuere, no vengo a hablar de esto, si no de la evolución de la web. Y es que Local Storage y Session Storage (aunque personalmente desprecio completamente la segunda), nos permite ver hacia dónde apunta el desarrollo web, y es que estas no pueden ser accedidas por el servidor.

¿Qué significa esto?
Muy fácil: así como las cookies son accedidas por el servidor, normalmente, ya que se mandan junto a las cabeceras, para controlar el logueo de los usuarios; el Local Storage, que no es más que un objeto en JavaScript en el cual podemos guardar strings, u objetos (si contamos que podemos hacer uso de funciones como stringify o parse de JSON), que es almacenado en el navegador al igual que las cookies, no puede ser leído ni se envía mediante las cabeceras al servidor.
Esto último implica que tenemos que usar JavaScript sí o sí para poder interactuar con dichos objetos, de esa forma esto marca una tendencia hacia tener un cliente que muestra la web a base de pequeños datos, como pueden ser objetos JSON, XML (que ya va quedando obsoleto…) u otros métodos como la utilización de node.js, en lugar de que sea el servidor que pre-procese el HTML añadiéndole el contenido.
Obviamente con cookies ya se podía hacer esto, permitiendo además que el servidor leyera directamente de ellas la información que necesitaba para identificar al usuario, pero que las nuevas tecnologías como es LocalStorage apunten a evitarlo, implica y marca una tendencia a seguir.

¿Es mejor?
En caso de usar node.js/websockets, no nos va a afectar, puesto que podíamos leer las cookies desde JavaScript con el objeto docmuent.cookie, pero eso reduce en un pequeñísimo porcentaje la carga de la web, puesto que no tiene que enviar las cookies mediante las cabeceras.
Si usamos PHP puro, podemos olvidarnos, pero lo que sí que podemos hacer, al igual que antes (solo que ahora creando la necesidad implícita de transferir los tokens de las sesiones mediante el método get o post en una petición ajax, y siendo esto una práctica que utilizan servicios como Habbo Hotel para cargar, por ejemplo, las notícias) es enviar con ajax, como he mencionado anteriormente, una petición al servidor, adjuntando también un token, y que este nos devuelva todos los datos necesarios para la web, que además serán colocados con JavaScript.
Con esto último, reduciremos considerablemente el tiempo de carga de nuestra web, o como mínimo el de repuesta del servidor, ya que una vez servido el HTML y los scripts por primera vez, no necesitaremos obtenerlo de nuevo para cambiar su contenido, puesto que podremos hacerlo con solo obtener objetos JSON (u otras maneras) y reemplazando el contenido de elementos por otros, como por ejemplo un campo de nombre de usuario.
No solo, además, podremos cambiar solo el contenido en cuanto a texto, sino que podremos también cambiar el HTML, implicando así que podremos cargar páginas distintas en una sola página, y gracias a funciones como ‘location.pathname.replace’, podremos incluso cambiar la dirección en la barra de direcciones, de forma que si un usuario copia un link al visualizar una foto y se lo pasa a otra persona, podremos cargar la foto directamente al cargar la página (como ya hace twitter o facebook).

Por supuesto, para proyectos pequeños en los cuales la carga del servidor no sea tan importante (ya que obviamente la diferencia será de milisegundos, y que si solo se ve una página será contraproducente), no necesitamos usar dicha nueva tecnología, que además de ser más tediosa y larga a la hora de desarrollar, también aumenta la carga en el navegador, mucho más que una simple página estática en HTML puro, de forma que si hacemos un pequeño blog o una web de empresa, con ni tan solo un millón de visitas mensual, no recomiendo hacerlo bajo ningún concepto.

Entonces… ¿Cookies o LocalStorage?
Fácil, como he aclarado en el párrafo anterior, según el tamaño del proyecto, cargar el cliente en exceso y/o si la carga del servidor no importa, usar LocalStorage es contraproducente. En cambio, si es un gran proyecto como Twitter o Facebook, entonces, usar el cliente como base para cargar toda la web puede ser la mejor opción. Por ende, yo usaría cookies si queremos tirar de servidor y LocalStorage si de JavaScript va la película.
A excepción de si usamos PHP, entonces usar LocalStorage no vale la pena del todo, de cualquier forma vamos a transferir los datos al servidor mediante cabeceras (ojo, si que nos puede servir para controlar qué datos le enviamos, y además, recordemos que si los datos son sensibles o solo se requieren para el funcionamiento temporal de la web, puede ser mejor usar LocalStorage).
Y sí, eso último que acabo de decir se hace posible con LocalStorage, pues este nos permitirá almacenar parámetros como el color de fondo que preferimos u otros detalles (incluso que pueden ser asignados por el servidor al iniciar sesión) y así no tener que cargarlos cada vez, reduciendo una petición al servidor por cambio/carga nueva de página.

Por ende, y contando que cada uno tiene sus pros y sus contras y que no nos vamos a saltar el cartelito de las cookies (puesto que este también es regulado por la famosa ‘ The Cookie Law’), va a depender del caso el hecho de usar uno u otro.

Para los que reclamen por la seguridad: ambos son IGUAL de seguros en cuanto a que el cliente los puede leer y modificar con tan solo la consola JavaScript, pero las cookies se enviarán al servidor en las cabeceras, mientras que el LocalStorage/SessionStorage permanece en el navegador si no lo enviamos nosotros con JavaScript.

Espero que os haya servido de ayuda esta pequeña reflexión.
¡Un saludo a todos!


Ensaïmada numérica, el bot que las resuelve

Pues sí queridos amigos,
Un año y medio después he vuelto y os traigo el post que tanto prometí.
En este caso se trata de un pequeño proyecto de PHP que resuelve las ensaïmadas numéricas (sí, con diéresis, que por algo estamos en Mallorca).
Una ensaïmada numérica es un circuito Hamiltoniano, matemáticamente hablando. En este caso es una tabla de 10×10 en cuyas celdas encontramos todos los valores del 1 al 100 ordenados de una forma específica.
Para empezar, colocamos el valor ‘1’ en cualquiera de las celdas que tiene la tabla, sin importar ningún factor, puro azar. A posteriori, tenemos que proseguir rellenando la tabla incrementando de uno en uno el valor que tenemos, y podemos ir distribuyéndolo de forma diagonal, horizontal y vertical, es decir, podemos ir rellenando hacia arriba, abajo, los lados y diagonal, pero siempre dejando un espacio en diagonal y dos en horizontal o vertical, de forma que sería: 1xx2 (siendo x espacios libres), o en diagonal solo uno. No vale “rebotar” o “atravesar” las paredes, y si deja de haber posiciones libres, no se puede continuar, simplemente hay que empzar con una tabla nueva (o volver atrás en la actual).

Para resolver este problema he optado por fuerza bruta y puro azar en vez de recursividad por pura pereza, pero es posible hacerlo con recursividad, y de hecho no sería demasiado difícil (así que… probablemente tendréis el proyecto modificado en un futuro).

Este programa ha sido realizado en PHP, y se recomienda abrir tantas instancias de este como núcleos/hilos tenga el procesador, para acelerar el proceso. En un futuro os lo traeré en C# y/o Java y con multithreading, de forma que podréis ahorraros el trabajo de abrir múltiples instancias.

Para que funcione, debéis crear una carpeta llamada ‘soluciones’ en la raíz del programa y dentro crear un archivo llamado ‘ultima.txt’. En dicha carpeta se guardarán las soluciones en formato HTML con tablas.

Aquí tenéis un ejemplo de ensaïmada numérica generada por el programa:

Resultado al azar del programa

Resultado al azar del programa

He aquí el código: (pastebin también disponible)

<?php
/* Hecho por Martín Durán – www.maduranma.com */

echo “Buscando soluciones…\n”;
$intentos = 0;
while(true)
{
// Todos los números a 0 (para tener algo, si no ya se borrará)
for($d = 1; $d <= 100; $d++)
$r[$d] = 0;

// ¿Dónde ponemos el 1?
$intentos++;
$rs = rand(1,100);
$r[$rs] = 1;
$l = $rs; // Definimos que la última posición es dónde está el uno, hasta un futuro muy cercano

$can = true; // Para que el while continue

while($can)
{
// Obtenemos el número de posición horizontal
if(strlen($l) > 1)
$h = (substr($l, -1) == 0) ? 10 : substr($l, -1);
else
$h = $l;

// Obtenemos el número según el vertical
if(strlen($l) > 1)
if($l == 100)
$v = 10;
else
$v = ($h == 10) ? substr($l, 0, 1) : substr($l, 0, 1) + 1;
else
$v = 1;

// Ponemos que todos los valores del array $m sean true, para comprobarlos luego
for($c = 1; $c <= 8; $c++)
$m[$c] = 1;

// — Movimientos horizontales —
if($h == 8 || $h == 9 || $h == 10 || (($l + 3 > 100) ? true : (($r[$l + 3] != 0) ? true : false)))
$m[1] = 0;

if($h == 1 || $h == 2 || $h == 3 || (($l – 3 < 1) ? true : (($r[$l – 3] != 0) ? true : false)))
$m[5] = 0;

// — Movimientos verticales —
if($v == 8 || $v == 9 || $v == 10 || (($l + 30 > 100) ? true : (($r[$l + 30] != 0) ? true : false)))
$m[3] = 0;

if($v == 1 || $v == 2 || $v == 3 || (($l – 30 < 1) ? true : (($r[$l – 30] != 0) ? true : false)))
$m[7] = 0;

// — Movimiento arriba derecha —
if($h == 9 || $h == 10 || $v == 1 || $v == 2 || (($l – 18 < 1) ? true : (($r[$l – 18] != 0) ? true : false)))
$m[8] = 0;

// — Movimiento arriba izquierda —
if($h == 1 || $h == 2 || $v == 1 || $v == 2 || (($l – 22 < 1) ? true : (($r[$l – 22] != 0) ? true : false)))
$m[6] = 0;

// — Movimiento abajo derecha —
if($h == 9 || $h == 10 || $v == 9 || $v == 10 || (($l + 22 > 100) ? true : (($r[$l + 22] != 0) ? true : false)))
$m[2] = 0;

// — Movimiento abajo izquierda —
if($h == 1 || $h == 2 || $v == 9 || $v == 10 || (($l + 18 > 100) ? true : (($r[$l + 18] != 0) ? true : false)))
$m[4] = 0;

$cm = null;
$cm = array();
foreach($m as $ia => $ib)
if($ib == 1)
$cm = array_merge($cm, array($ia));

// Comprobamos que han salido movimientos
if(($cm != null) ? count($cm) >= 1 : false)
$fm = array_rand($cm); // Movimiento elegido
else
$can = false; // Aquí paramos

if($can)
foreach($cm as $ba => $bb)
if($ba == $fm)
$fm = $bb;

// Nos movemos (si podemos)
if($can)
switch($fm)
{
case 1:
$nl = ($l) + 3;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 2:
$nl = ($l) + 22;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 3:
$nl = ($l) + 30;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 4:
$nl = ($l) + 18;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 5:
$nl = ($l) – 3;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 6:
$nl = ($l) – 22;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 7:
$nl = ($l) – 30;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 8:
$nl = ($l) – 18;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

default:
echo ‘<script>alert(\’error\’);</script>’;
$can = false;
break;
}
}

if($r[$l]  == 100)
{
$nombre_fichero = ‘soluciones/ultima.txt’;
$gestor = fopen($nombre_fichero, ‘r’);
$contenido = fread($gestor, 11);
fclose($gestor);
$contenido = $contenido + 1;
$fp = fopen(‘soluciones/ultima.txt’, ‘w’);
fwrite($fp, $contenido);
fclose($fp);

$d = ”;
$d .= ‘<!DOCTYPE html>
<head>
<title>Soluci&oacute;n ‘ . $contenido . ‘ del circuito Hamiltoniano – Ensaimada num&eacute;rica</title>
</head>
<body style=”margin:3 0;”>
<center>
<table border=”1″ style=”font-size: 57pt;text-align: center; border: 2px solid black;” cellpadding=”2″ cellspacing=”0″>’;
for($a = 1; $a <= 10; $a++)
{
$d .= “\n\t\t\t\t<tr>”;
for($b = 1; $b <= 10; $b++)
{
$d .= “\n\t\t\t\t\t<td width=\”90\” height=\”75\” style=\”height: 89px; text-align: center; border: 2px solid black;\” >”;
$d .= ($r[(($a-1)*10)+$b] == 0) ? “\n\t\t\t\t\t\t&nbsp;” : (“\n\t\t\t\t\t\t” . $r[(($a-1)*10)+$b]);
$d .= “\n\t\t\t\t\t</td>”;
}
$d .= “\n\t\t\t\t</tr>”;
}
$d .= “\n\t\t\t</table>”;
echo “Sol. $contenido encontrada y guardada. Intentos: $intentos”;
$intentos = 0;
echo “\nBuscando soluciones…\n”;
$fp = fopen(‘soluciones/’ . $contenido . ‘.html’, ‘w’);
fwrite($fp, $d);
fclose($fp);
}
}
?>

P.D: He dejado un problema de optimización en los IFs para ver si alguien es capaz de encontrarlo, es simplemente que hay algo que no hace falta que esté. Quien lo encuentre se lleva una camiseta gratis :P


Cómo crear una Base de Datos de Hashes

¡Muy buenas amantes de la informática!
Bueno, la verdad es que ya hace siglos hice un generador de Hashes que generaba hashes en MD5 siguiendo un orden específico, el orden en cuestión era como el Excel (A, B… AZ, BA… ZZ, AAA..) pero incluyendo números y caracteres que se ponen comunmente en las contraseñas: ªº\|!@”#~$%&/()=’?

Ese generador iba metiendo todas las contraseñas en una base de datos con su respectivo hash MD5, de forma que si buscaba el hash en cuestión en la base de datos me lo devolvía desencriptado (por decirlo de alguna forma, puesto que realmente no se puede hacer eso, pero si conseguir una coincidencia a fuerza bruta, que además son infinitamente múltiples en todos los casos posibles).

El código es sencillo y os lo dejo a todos para que lo aprovechéis. En un principio hice una versión para MySQL y luego una versión Flat File. Ambos son de uso recomendado en SSDs o dispositivos de almacenamiento flash por que en discos duros es muuuuy lento y tedioso.

Código Flat File (Pastebin para mejor formato)

$c = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ªº\\|!@”#~$%&/()=\’?’;
$k = strlen($c);
function c($n)
{
global $k, $c;
$s = ”;
$r = 1;
$b = $n;
while($b > pow($k, $r))
$b -= pow($k, $r++);
for($i = 0; $r > $i; $i++)
$s = substr($c, ($n/pow($k,$i)-1)%$k, 1) . $s;
return $s;
}

$x = scandir(‘C:\\txt’);
if($x[count($x)-1] == ‘..’)
$i = 0;
else
$i = count($x)-2;
echo number_format($i, 0, ‘.’, ‘.’);
while(true)
{
$i++;
$m = c($i);
$alg = hash_algos();
$sb = ”;
$sa = ”;
foreach(hash_algos() as $b => $al)
$sa .= hash($al, $m) . ((count(hash_algos()) > ($b + 1)) ? ‘ ‘ : ”);
file_put_contents(‘C:\\txt\\’ . $i, $m . ‘ ‘ . $sa);
if($i%1000 == 0)
echo “\n” . number_format($i, 0, ‘.’, ‘.’);
}

Código para MySQL (Pastebin para mejor formato)

$x = mysqli_connect(‘127.0.0.1’, ‘root’, ‘contraseña’, ‘db’);
$c = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ªº\\|!@”#~$%&/()=\’?’;
$k = strlen($c);
function c($n)
{
global $k, $c;
$s = ”;
$r = 1;
$b = $n;
while($b > pow($k, $r))
$b -= pow($k, $r++);
for($i = 0; $r > $i; $i++)
$s = substr($c, ($n/pow($k,$i)-1)%$k, 1) . $s;
return $s;
}
$q = mysqli_query($x, ‘SELECT id FROM hashes ORDER BY id DESC LIMIT 1’);
if(mysqli_num_rows($q) == 0)
$i = 0;
else
{
$p = mysqli_fetch_assoc($q);
$i = $p[‘id’];
}
echo number_format($i, 0, ‘.’, ‘.’);
while(true)
{
$i++;
$m = c($i);
$alg = hash_algos();
$sb = ”;
$sa = ”;
foreach(hash_algos() as $b => $al)
{
$sb .= ‘, `’ . $al . ‘`’;
$sa .= ‘\” . hash($al, $m) . ((count(hash_algos()) > ($b + 1)) ? ‘\’,’ : ‘\”);
}
mysqli_query($x, ‘INSERT INTO hashes (`value`’ . $sb . ‘) VALUES (\” . mysqli_real_escape_string($x, $m) . ‘\’, ‘ . $sa . ‘)’);
if($i%100 == 0)
echo “\n” . number_format($i, 0, ‘.’, ‘.’);
}

El SQL que debéis hacer para crear la tabla es tan fácil como ejecutar un script con un foreach en el cual por cada valor de hash_algos() (función que viene en PHP para obtener un array que nos indica todos los tipos de hashes disponibles) cree una fila varchar 255 y listo. En cualquier caso, aquí lo tenéis:

CREATE TABLE IF NOT EXISTS `hashes` (
`id` int(11) NOT NULL,
`value` varchar(255) NOT NULL,
`md2` varchar(255) NOT NULL,
`md4` varchar(255) NOT NULL,
`md5` varchar(255) NOT NULL,
`sha1` varchar(255) NOT NULL,
`sha224` varchar(255) NOT NULL,
`sha256` varchar(255) NOT NULL,
`sha384` varchar(255) NOT NULL,
`sha512` varchar(255) NOT NULL,
`ripemd128` varchar(255) NOT NULL,
`ripemd160` varchar(255) NOT NULL,
`ripemd256` varchar(255) NOT NULL,
`ripemd320` varchar(255) NOT NULL,
`whirlpool` varchar(255) NOT NULL,
`tiger128,3` varchar(255) NOT NULL,
`tiger160,3` varchar(255) NOT NULL,
`tiger192,3` varchar(255) NOT NULL,
`tiger128,4` varchar(255) NOT NULL,
`tiger160,4` varchar(255) NOT NULL,
`tiger192,4` varchar(255) NOT NULL,
`snefru` varchar(255) NOT NULL,
`snefru256` varchar(255) NOT NULL,
`gost` varchar(255) NOT NULL,
`gost-crypto` varchar(255) NOT NULL,
`adler32` varchar(255) NOT NULL,
`crc32` varchar(255) NOT NULL,
`crc32b` varchar(255) NOT NULL,
`fnv132` varchar(255) NOT NULL,
`fnv1a32` varchar(255) NOT NULL,
`fnv164` varchar(255) NOT NULL,
`fnv1a64` varchar(255) NOT NULL,
`joaat` varchar(255) NOT NULL,
`haval128,3` varchar(255) NOT NULL,
`haval160,3` varchar(255) NOT NULL,
`haval192,3` varchar(255) NOT NULL,
`haval224,3` varchar(255) NOT NULL,
`haval256,3` varchar(255) NOT NULL,
`haval128,4` varchar(255) NOT NULL,
`haval160,4` varchar(255) NOT NULL,
`haval192,4` varchar(255) NOT NULL,
`haval224,4` varchar(255) NOT NULL,
`haval256,4` varchar(255) NOT NULL,
`haval128,5` varchar(255) NOT NULL,
`haval160,5` varchar(255) NOT NULL,
`haval192,5` varchar(255) NOT NULL,
`haval224,5` varchar(255) NOT NULL,
`haval256,5` varchar(255) NOT NULL
) ENGINE=InnoDB AUTO_INCREMENT=486089 DEFAULT CHARSET=utf8;

ALTER TABLE `hashes`
ADD PRIMARY KEY (`id`), ADD UNIQUE KEY `value` (`value`), ADD KEY `md2` (`md2`), ADD KEY `md4` (`md4`), ADD KEY `md5` (`md5`), ADD KEY `sha1` (`sha1`), ADD KEY `sha224` (`sha224`), ADD KEY `sha256` (`sha256`), ADD KEY `sha384` (`sha384`), ADD KEY `sha512` (`sha512`), ADD KEY `ripemd128` (`ripemd128`), ADD KEY `ripemd160` (`ripemd160`), ADD KEY `ripemd256` (`ripemd256`), ADD KEY `ripemd320` (`ripemd320`), ADD KEY `whirlpool` (`whirlpool`), ADD KEY `tiger128,3` (`tiger128,3`), ADD KEY `tiger160,3` (`tiger160,3`), ADD KEY `tiger192,3` (`tiger192,3`), ADD KEY `tiger128,4` (`tiger128,4`), ADD KEY `tiger160,4` (`tiger160,4`), ADD KEY `tiger192,4` (`tiger192,4`), ADD KEY `snefru` (`snefru`), ADD KEY `snefru256` (`snefru256`), ADD KEY `gost` (`gost`), ADD KEY `gost-crypto` (`gost-crypto`), ADD KEY `adler32` (`adler32`), ADD KEY `crc32` (`crc32`), ADD KEY `crc32b` (`crc32b`), ADD KEY `fnv132` (`fnv132`), ADD KEY `fnv1a32` (`fnv1a32`), ADD KEY `fnv164` (`fnv164`), ADD KEY `fnv1a64` (`fnv1a64`), ADD KEY `joaat` (`joaat`), ADD KEY `haval128,3` (`haval128,3`), ADD KEY `haval160,3` (`haval160,3`), ADD KEY `haval192,3` (`haval192,3`), ADD KEY `haval224,3` (`haval224,3`), ADD KEY `haval256,3` (`haval256,3`), ADD KEY `haval128,4` (`haval128,4`), ADD KEY `haval160,4` (`haval160,4`), ADD KEY `haval192,4` (`haval192,4`), ADD KEY `haval224,4` (`haval224,4`), ADD KEY `haval256,4` (`haval256,4`), ADD KEY `haval128,5` (`haval128,5`), ADD KEY `haval160,5` (`haval160,5`), ADD KEY `haval192,5` (`haval192,5`), ADD KEY `haval224,5` (`haval224,5`), ADD KEY `haval256,5` (`haval256,5`);

Espero que os sirva de ayuda para vuestros proyectos,
Saludos :B


Cookies VS Session en PHP

Si eres programador de PHP sabrás que existen cookies y session, y, seguramente, habrás usado ambas.
Para hacer una web “tonta”, o de prueba, o en la que simplemente te vayas a loggear tu y no la conozca nadie y no tengas nada interesante, ¿para qué usar cookies si es mucho más tedioso?
Pero bueno, quiero hacer este post para discutir sus ventajas, desventajas, etc.

Session
Las sesiones de PHP es un sistema que lleva incluido el cual crea una cookie en el navegador llamada PHPSESSID que contiene un código de 32 caracteres generados al azar, y luego crea una carpeta donde para cada sesión guarda un archivo que contiene todos los parámetros que guardes en los conocidos $_SESSION[‘algo’].
Sí, es tan cómodo como poner session_start(); y empezar a guardar datos en el usuario, y para desloguearle es tan sencillo como un simple session_destroy();.La cosa es que también podemos intentar robar sesiones a base de fuerza bruta u obteniendo la cookie del navegador (pero lo último es algo irremediable, si tenemos acceso al ordenador del usuario, da igual si son cookies, sesiones, etc. que si queremos robar la sesión, podemos). Incluso con un analizador de de protocolo de red podemos sacar las cookies muchas veces, si no entran con SSL está chupado, y si no tan fácil como usar nuestra amiga, la foquita malvada, y hacer un SLAAC attack, pero bueno, olvidemos eso peusto que pasa lo mismo con las cookies.

Cookies
Volviendo al debate entre Cookies y Session (puesto que en la anterior me he ido por los cerros de Úbeda hablándoos de la Foca), las Cookies nos ofrecen más posibilidades a los programadores para jugar. Básicamente podemos crear cookies de la duración que queramos, con el nombre que queramos, que funcionen en la carpeta que queramos y encima los que almacenan la información temporal son los usuarios y no nosotros. Aun así, no es recomendable leer la información de las cookies y basarse en ella. Si es algo que el usuario pueda editar desde la web (como por ejemplo, el primer paso de un registro de dos pasos, siempre verificando la información dada), entonces sí que podemos confiar en que si editan algo, no nos perjudicará, ya que como buenos programadores comprobaremos que todo lo almacenado en las cookies sea válido como en el confirmación del primer paso del registro ¿verdad? (si no ya sabéis, ahí tenéis unas vulnerabilidades que arreglar YA).
Una vez sabemos los fundamentos de las cookies, sabemos que si almacenamos el ID de un usuario pueden simplemente cambiarlo por otro ID, y así entrar por ejemplo en el ID 1 que será seguramente el creador/administrador de la web. Pero para solucionar eso lo que se hace es crear otra cookie con números, letras, otros caracteres o lo que sea generados al azar y muy largos (de 100 o más caracteres) y almacenarlos junto al usuario en la base de datos, de modo que si el ID y el código creado coincide con las cookies se permite que vea la web logueado. Y sí, con eso también se puede hacer fuerza bruta, pero a más caracteres, más seguridad y además nos permite a los programadores tener el sistema de seguridad que queramos.
La cosa de las cookies es que podemos personalizar la duración, le podemos dar algunos flags que “aumentan la seguridad”, poner la ruta que queramos, y en fin, tenemos más control sobre las sesiones, y al fin y al cabo, cada programador tiene su estilo.

En definitiva: yo opto por usar cookies, siempre que vayamos con cuidado, aun que me niego rotundamente a poner el cartelito de ‘esta web usa cookies’, es una obviedad que si te vas a loguear por narices vas a usar cookies, dudo que haya alguna web que con el navegador, el sistema operativo y la IP ya te permita loguearte, por que si no tu herman@, padre, madre o lo que sea con el mismo ordenador vería tu cuenta, con lo cual, cookies always, ya sea por la sesión del PHP que crea una sola cookie, o por las cookies que cree una página personalizadas.

Y por último quiero pedir disculpas por haber estado tanto tiempo sin escribir nada, la verdad es que el tiempo no es algo que abunde, sobretodo cuando tienes pendientes 20mil trabajos de programación y 10 personas pidiéndote cada día por Skype cómo los llevas ejem. Y también os recuerdo que en mi canal estoy subiendo una serie de Minecraft (que no tiene nada que ver con informática, pero en mi canal hago lo que me da la gana, ¿no?) así que ya sabéis, si os gusta, ahí está :P

Buenas tardes y feliz fin de semana a todos :D


Easter Egg de PHP, un peligro a tener en cuenta

Como ya sabréis, los Easter Egg son bromas que incluyen algunas compañías de Software en sus productos para reirse un rato. Obviamente, si vemos un Easter Egg en un juego no va a pasar nada, hay Easter Eggs en la mayoría de juegos, e incluso en sitios web, por ejemplo en Google o Youtube (haciéndo click los veréis). Incluso hay algunos más currados en videojuegos que han interferido en la vida real, por ejemplo este Easter Egg de Trials explicado por Alexelcapo, el cual, personalmente, me emocionó.

Una vez sabemos lo que son los Easter Eggs, vamos a ver en que afecta a PHP. PHP posée un easter egg en el cual si entras en una página web (que use php) con este GET: ‘?=PHPE9568F36-D428-11d2-A769-00AA001ACF42‘ podremos apreciar una imágen (hay más Easter Eggs, pero no los indicaré aquí). Lo primero que nos dice esta imagen es que usamos PHP, y lo segundo es la verisón, puesto que cada par de versioens PHP cambia la imagen según el esquema que tenemos aquí abajo:

Tabla de versiones e Easter Eggs.

Tabla de versiones e Easter Eggs.

¿En qué nos perjudica esto?
Al saber nuestra versión de PHP, el atacante puede buscar vulnerabilidades de dicha versión y utilizarlas en nuestra contra, por ello es recomendable desactivar el Easter Egg (como indicaré aquí abajo) y además conviene actualizar siempre a la última versión. Además, en este artículo de Detectify podrás encontrar listas de vulnerabilidades para cada ‘imagen’ proporcionadas por CVE.
Además apareceremos como vulnerables en la mayoría de escáneres de pentesting, podemos ver un ejemplo del mismo Detectify aquí abajo.

Detectados por Detectify

Detectados por Detectify

¿Cómo lo desactivo, entonces?
Muy fácil, solo tenemos que poner a ‘Off’ el parámetro ‘php_expose’ del archivo de configuración de PHP, conocido como php.ini.

Además
Con eso también desactivas el ‘X-Powered-By’ de PHP, que es un header que envía PHP al procesar la página en el cual se indica su versión.

X-Powered-By

Header X-Powered-By

Disfrutad del fin de semana :D