Seguridad en PHP: XSS o Scripting de Sitios Cruzados

De los ataques para sistemas web, los XSS (Cross-site Scripting) suelen ser letales, pero no para el sitio, sino para lo usuarios, los ataques XSS se aprovechan de las fallas en la validación de código HTML por parte del servidor para así extraer información del usuario.

¿pero si mi vista no me falla seria CSS y NO XSS?: estas en lo cierto, se les denominó así debido a que podría confundirse con el ya establecido lenguaje de definición de estilos en cascada o Cascading Style Sheets.

Imagina que estas en un sitio con un típico buscador que se basa en un recuadro y el clásico botón "buscar", es un simple formulario pero si desde el servidor no se valida debidamente la data enviada con el fin de evitar la introducción de código html o scripts, podrás colocar lo siguiente:

<script>alert("Hola no estoy protegido contra XSS XD");</script>

Cuando presiones en el botón buscar, es muy probable que el resultado que envié el servidor sea que no se ha encontrado dicho texto, y por gajes del oficio se muestre el mismo texto buscado, es decir un clásico echo $_GET['texto_buscado']; en php; y como lo ingresado es una declaración de script, el resultado en tu navegador seria el cuadro de alerta con el mensaje en cuestión

Te resultará gracioso y te preguntarás ¿¡pero esta cosa tan infantil puede hacerme tanto daño!? y soltarás alguna risa, ¿pero si resulta que te llega un correo o das click en un mensaje publicitario (que o muy bien pudo ser inyectado en el sitio, o lo abres desde otra página que tienes abierta) que contenga algún link+javascript, preparado para hacer uso de ese formulario no validado, que en lugar de ese inocente alert trate de robar tus datos de las cookies del sitio para ser almacenados en otro sitio atacante?: el resultado sera que el mismo podría enviar todos los datos de las cookies almacenados en el navegador a un servidor y con los mismos datos podrían hacerte mucho daño, ¡sobre todo si el formulario tuviese relación alguna con dinero!.

Ahora el tema se vuelve un poco más interesante, pero aclaremos una cosa, esto es sólo la punta del isberg, porque los ataques XSS se clasifican en dos tipos:

XSS indirecto o reflejado: tal como el ejemplo anterior, se basa en enviar código javascript que trate de robar las cookies de la sesión del usuario, de manera que el mismo sea ejecutado por el navegador debido a que o bien sea impreso en la salida del html (<script> embebido) o sea el destino (src="javascript:") de un iframe que sea llamado con la pagina HTML, permitiendo una exitosa ejecución de scripts

XSS Directo o persistente: a diferencia del anterior se basa en tratar de explotar la debilidad el filtro de HTML con etiquetas y métodos que permiten ejecutar código y que no son muy conocidos. dependen también del navegador, por ejemplo, en Wikipedia aparecen muy buenos ejemplos:

<BR SIZE = "&{alert('XSS')}" >
<FK STYLE = "behavior: url(http://yoursite/xss.htc);" >
<DIV STYLE = "background-image: url(javascript:alert('XSS'))">
<div fu = "alert('Hola mundo');" STYLE = "background-image: url(javascript:eval(this.fu))" >

¿¡SOLUCIONES!?: muchas, y dependen mucho de como tienes desarrollado tu site php, las más sofisticadas son las que proveen algunos frameworks php como symfony en el mecanismo que pasa variables a la vista desde el controlador, de no usar un framework un simple htmlentities o htmlespecialchars serian una solución rápida para tal lío, o si te comprometes a realizar un avanzado filtro para eliminar todo vestigio de html con script peligrosos para tu sistema.

Como dije este artículo solo es la punta del isberg, todavía se siguen descubriendo nuevas y novedosas formas de ataques XSS, pero siempre es bueno estar preparado para las batallas a venir, mucha suerte!

Seguridad en PHP: CSRF o Falsificación de petición en sitios cruzados

De entre todos los ataques que puede recibir tu sistema en PHP los CSRF o (Cross-site request forgery) son los más fáciles de implementar, ya que éstos se aprovechan de la "confianza" que le tiene el sistema al usuario.

¿pero como que mi sistema confía en el usuario?: pues es simple, si lo miras desde el punto de vista del servidor, cuando éste recibe un formulario, simplemente recibe los datos del formulario, porque se supone que el usuario ya está logueado (o ha iniciado sesión, cosa que procesas previamente obvio) y por ende él solo se encarga de una cosa: procesar la data y generar la salida.

Supongamos que nuestro querido usuario está ingresando registros nuevos en un CRUD de nuestro sistema, y por cosas del destino se dispone a chatear en messeger o hasta en el mismo facebook, como estos sitios te permiten compartir links, un atacante puede simplemente pasarle un link a nuestro usuario para que ingrese en determinada página, cuya página esta preparada para hacer un submit de un formulario oculto hacia el url de nuestro servidor, pudiendo enviar data hacia el archivo php que se encarga de "crear" ese nuevo registro, como el usuario está logueado y generalmente el navegador mantiene la cookie de la sesión (depende del navegador), el ataque maestro logra pasar el sistema de login y pudiendo afectar a nuestro sistema; en ningún caso el código de nuestro php espera una identificación del formulario, porque simplemente validamos las sesiones; otra modalidad consisten en colocar links de peticiones hacia el mismo domino en imágenes, por ejemplo (<img src="http://mydomain/archivo.php?dato=valor" alt="" />) en cuyo caso del lado del servidor (php por ejemplo) no verifique el tipo de petición Post o Get, ¿donde se evidencia?: en el mal uso de $_REQUEST en el caso de PHP.

¡¡¡OMG ¿y como lo resuelvo?!!!: pues por suerte la solución es tan simple que da risa, este pequeño (y menudo) inconveniente se resuelve con los llamados tokens; los tokens son simplemente un ID único que podremos generar al momento que nuestro usuario solicita el formulario, de esta forma al crear nuestro formulario añadimos un dato oculto adicional que nos permitirá verificar (cuando el formulario sea recibido) que dicha data es confiable, para ello ese mismo ID necesitamos registrarlo en el servidor y nada mejor que con una variable de sesión, y no sólo eso para darle más gusto a la sopa es preferible marcar el tiempo justo en que el form se creó, para así verificar cuanto tiempo se demoró (depende de la cantidad de data en el formulario) y hacerlo más seguro, es inverosímil que un formulario tan simple se demore tanto en ser enviado, así sancionamos además a los usuarios perezosos XD.

Pero, si tengo que crear un ID para cada formulario, ¿necesito abrir todos los php relacionados y añadírselos manualmente, ¡menuda tarea!?: sí, es lamentable, pero es la única forma, aunque gracias a la re-utilización de código la tarea es más fácil, simplemente creamos una clase que automatice esta tarea y así ahorrarnos muchas lineas de código en cada formulario que tengamos:

archivo tokenform.php: (PHP 5.0+)

<?php
/**
* administra un ID único (tokens) para un formulario previamente registrado
* GPL versión 1
* @author Maycol Alvarez
*/
class tokenForm {

/**
 * Constante para prefijos de la las variables de sesion
 */
const _prefix = 'token_';

/**
 * Nombre del formulario
 * @var string
 */
private $_formname;
/**
 * Tiempo en segundos para validar caducidad del token
 * @var int
 */
private $_seconds=300;

/**
 * Construye un manejador de tokens
 * @param string $nameForm Nombre del formulario
 * @param bool $preventSessionStart previene el inicio de sesion omitido
 */
public function  __construct($nameForm,$preventSessionStart=true) {
  if($preventSessionStart){
    @session_start();
  }
  $this->_formname=self::_prefix.$nameForm;
  //genera el token si no existe
  if(!isset($_SESSION[$this->_formname])){
    $this->create();
  }
}

/**
 * Crea los datos de sesion del token
 */
public function create(){
  $token= md5(uniqid(rand(), true));
  $timestamp = mktime();
  $_SESSION[$this->_formname]['uid']=$token;
  $_SESSION[$this->_formname]['mkt']=$timestamp;
}

/**
 * Devuelve el UID del token
 * @return string token
 */
public function getToken(){
  return $_SESSION[$this->_formname]['uid'];
}

/**
 * Devueve la fecha de creacion del token
 * @return int mktime
 */
public function getTime(){
  return $_SESSION[$this->_formname]['mkt'];;
}

/**
 * Valida si el token del formulario enviado es confiable
 * @param mixed $source permite cambiar el origen del array con la data del
 * formulario, por defecto es null y se utiliza $_POST
 * @return bool true en caso de exito
 */
public function validate($source=null) {
  if($source==null){    
    $srctoken=$_POST[$this->_formname];
  }else{
    $srctoken=$source[$this->_formname];
  }
  //valida si los tokens coinciden:
  if($this->getToken()==$srctoken){
    //valida si se evalua caducidad:
    if($this->_seconds!=0){
      //ahora valida si estan el el rango de tiempo
      if((mktime() - $this->getTime())<= $this->_seconds){
        $returned= true;
      }else{
        $returned= false;
      }
    }else{
      $returned= true;
    }
  }else{
    $returned= false;
  }
  $this->clear();
  return $returned;
}

/**
 * Devuelve el input correspondiente al token para el form
 * @return string Input HTML tag
 */
public function getInput(){
  return sprintf(
          '<input type="hidden" name="%s" value="%s" />',
          $this->_formname,
          $this->getToken()
  );
}

/**
 * Imprime el input correspondiente al token para el form
 */
public function dump() {
  echo $this->getInput();
}

/**
 * Borra el token
 */
public function clear(){
  unset($_SESSION[$this->_formname]);
}

/**
 * Establece el margen de segundos para considerar caduco un token
 * @param int $seconds 0 para omitir esta validacion
 */
public function setTime($seconds){
  $this->_seconds=$seconds;
}
}
?>

Con esta simple clase resolvemos muchas de las funciones que debe cumplir un token, para ejemplo veamos su funcionamiento en el archivo que crea el formulario, y el que lo procesa:

archivo formulario.php:

<?php
require_once 'tokenform.php';
$formulario = new tokenForm('form1');
?>
<form action="proceso.php" method="POST">
<input type="text" name="dato1" />
<input type="text" name="dato_n" />
<?php $formulario->dump(); ?>
<input type="submit" />
</form>

archivo proceso.php:

<?php
//procesando el token
require_once 'tokenform.php';
$formulario = new tokenForm('form1');
if(!$formulario->validate()){
echo 'Formulario no valido';
}
?>

Y con tan pocas líneas por archivo ya resolvemos semejante problema y hacemos a nuestro sistema más seguro XD.

Compilando en PHP

Aunque esto no sea novedad para algunos, en PHP también podemos "compilar" el código, gracias a una extensión de PEAR(PHP Extensión and Application Repository) llamada bcompiler; ¿el porqué coloco compilar entre comillas?: porque en realidad bcompiler no compila, sino que genera los "bytecodes" que php normalmente genera para ejecutar los scripts en memoria.

Para los que conocen JAVA sabemos que los bytecodes son un semi-lenguaje de máquina optimizado para una rápida lectura y ejecución por medio de las denominadas "Máquinas Virtuales" como lo es JAVA, y últimamente .NET Framework, entre otras.

En el manual sobre bcompiler (en inglés) se trata de la compresion del bytecode, y para configurarlo se requiere de muchas cosas que decidí omitir; lo que pasa es que el bytecode resultante del script puede ser incluso más del doble del tamaño (en bytes) que el archivo fuente original, ¿por qué?: simplemente porque en el bytecode se especifican muchos más datos, además del algoritmo en sí, de modo que la máquina virtual pueda traducirlo al lenguaje de máquina de la máquina (valga la redundancia) en donde se ésta ejecutando, como la mundialmente conocida arquitectura x86.

Instalación

Windows: En paquetes como WAMP y XAMMP (windows), ésta librería ya viene incluida, sólo basta instalar/configurar primero PEAR y luego incluir en el archivo de configuración php.ini la línea: extensión=php_bcompiler.dll en "dynamic extensions", PEAR no es realmente necesario, pero puede ser que necesiten de algunas funciones de PEAR.

GNU/Linux: aquí es otra Historia, pueden probar si el paquete XAMMP para linux trae la librería, pero no se los aseguro, además con PEAR lo puende instalar, de todos modos intente añadir al archivo de configuración php.ini: extensión=bcompiler.so y luego pruebe con phpinfo(); si la extensión bcompiler aparece (debe reiniciar apache).

Ubuntu 8 LTS: con el APACHE/PHP instalados por synaptic, instale los siguiente paquetes por synaptic:

• pear
• php5-dev
• bzip2
  
• libbz2-1.0
• libbz2-dev
• libzip1
• libzip1-dev
• pbzip2

Una vez instalados abra el terminal (consola) y ejecute (le solicitará contraseña del administrador):

sudo pecl install bcompiler-0.8.tgz

Añada al archivo de configuración php.ini: extensión=bcompiler.so
Reinicie apache y compruebe que aparece la extensión bcompiler por phpinfo();

¡Manos a la Obra!

Para precompilar nuestro primer script necesitamos 3 archivos (origen.php, destino.php, compila.php); en origen.php estará el código fuente, a destino.php debe otorgarle PERMISOS DE ESCRITURA (GNU/Linux), y en compila.php coloque lo siguiente:

<?php
$fh = fopen("destino.php", "w");
bcompiler_write_header($fh);
bcompiler_write_file($fh, "origen.php");
bcompiler_write_footer($fh);
fclose($fh);
?>

Sólo basta ejecutar desde el explorador http://localhost/compila.php y si no aparecen errores está listo!: ejecute http://localhost/destino.php y aparecerá lo mismo que en origen.php, pero si revisa el código de destino.php notará que ya no es el mismo código, sino un conjunto de datos incomprensibles.

Puede incluso compilar todo tu sistema en php y puede utilizar ambos archivos: los bytecodes o los normales, bcompiler se encarga de todo, puede incluso hacer include y require a un archivo bytecode php de bcompiler, ambos pueden tener la extensión ".php".

Eso sí: se puede duplicar el tamaño en bytes del sistema, pero el rendimiento es el mismo: los no-compilados deben de interpretarse y luego compilarse en memoria antes de ser ejecutados; los precompilados "pesados" pasan a memoria inmediatamente, y si utiliza bytecodes comprimidos tienen que "descomprimirse" y ejecutarse. así que básicamente el rendimiento de su sistema no variará mucho.

El único detalle sería el comportamiento de __LINE__ y de los reportes de errores, como es una extensión experimiental puede ser que el valor retornado por éstas funciones no sea el mismo que cuando se ejecuta un script normal (no precompilado); por eso le recomiendo evaluar bien todo su código antes de precompilarlo.

Seguridad en PHP: Inyecciones SQL

Como lo prometido es deuda, voy a segmentar el tema Seguridad PHP en varias partes, debido a que es un tema delicado y en que debo enfatizar en el porqué de cada medida de seguridad.

Entrega 1: Inyecciones SQL

¿que qué es una SQL Inyection?: es un método para alterar la cadena SQL y que el interprete de la base de datos ejecute otras acciones perjudiciales para el sistema; la más simple que voy a explicar aquí trata de vulnerar a la mayoría de los sistemas que INICIAN SESIÓN desde una tabla en su base de datos; debo aclarar que ésta técnica NO ES CORRECTA para empezar, pero como la mayoría lo ha echo así, no me queda más remedio que indicarles las providencias necesarias para resolver éste problema.

Supongamos que su sentencia para iniciar sesión sea esta:
$usuario=$_POST['usuario'];
$contra=$_POST['contra'];
$sql = "SELECT * FROM usuarios WHERE user='".$usuario."' AND password='".$contra."';";
if (mysql_fetch_array(mysql_query($sql,$coneccion))) {
//acceso al sistema
}

Como podemos ver ésta sentencia devuelve TRUE en el caso de que se encuentre el usuario y la contraseña correctos dándole acceso al sistema, pero en el caso de que sea un cracker el que envía un formulario falso en donde coloque en la variable del POST $usuario el siguiente valor: ' OR 1=1 #
Pues sencillamente el carácter de apóstrofo (') cerraría la cadena en SQL y con el OR 1=1 quedaría que user='' OR 1=1 que devuelve TRUE y para rematar el carácter numeral (#) que en la mayoría de las bases de datos es el de comenzar comentarios, lo que significaría que se ignoraría el resto de la consulta quedando así para el interprete SQL: SELECT * FROM usuarios WHERE user='' OR 1=1 y por ende el resultado sería TRUE, otorgándole acceso al sistema.

¿Cómo puede ser?, ¿hay manera de evitarlo?, Las Magic Quotes activadas en PHP en la MAYORÍA DE LOS CASOS lo resuelven, pero ésta no es la única forma de SQL Inyection que existe y las Magic Quotes no lo resuelven todo, consulten el manual de PHP (Tópico: Seguridad en bases de datos/Inyección SQL) y verán lo que es bueno...; en fin, les daré los consejos fundamentales para evitar un SQL Inyection:

• Revisa que no existan cadenas ni caracteres como éstos: (OR, AND, ', -- y #) en las variables del POST.
• Escapa las cadenas con mysql_real_escape_string o addslashes ¡es mejor que las magic quotes!
  
• Si la variable es numérica, verifica que lo sea con is_numeric().
• NUNCA utilices al usuario administrador de la base de datos, crea uno con el acceso y privilegios necesarios.
• HASHEA las contraseñas ¡por favor!, si no sabes de que te hablo busca en google Hash o MD5 y con eso te digo todo.
• No vuelvas a iniciar sesión así en tus futuros sistemas, de ser posible utiliza el sistema de privilegios de usuario y crearle un usuario de base de datos a cada usuario; ésta es la forma correcta de hacer las cosas, tarda mucho lo sé pero te da un sinfín de ventajas.

Y con esto doy por terminada la primera entrega de Seguridad en PHP ¡No apto para novatos!, espero que tu cerebro quede lo suficientemente aturdido como para seguir mis consejos, ¡hasta la proxima!.

Confirmado! resuelto el Problema del Path en JAVA con JAR's

Desde que me quedé con la espinita de lograr el App.Path en Java con un *.JAR en Ubuntu 8.04 por otros medios, investigué más y lo encontré, el problema es que NO FUNCIONA cuando ejecutas el proyecto en NetBeans porque él lo ejecuta desde memoria, pero SI FUNCIONA DESDE FUERA jajajaja, pruébalo y veraz, en windows también funcionó igual ejecutando el *.JAR fuera del NetBeans. Eres muy Afortunado, muy pocos lo han conseguido y en Google solo aparecen 2 link's en inglés que se acercan. Bueno, como lo prometido es deuda:

java.io.File arc = new java.io.File(System.getProperty("java.class.path"));
try{
this.jTextField2.setText(arc.getAbsolutePath().replace(arc.getName(), ""));
catch (Exception ex){}

a diferencia del System.getProperty("user.dir") el System.getProperty("java.class.path") le indica al JRE de Java que devuelva la identificación de la ruta en donde las clases se almacenan, que es por ende el directorio donde está nuestro *.JAR.

Recuerda que sólo funciona fuera del NetBeans, así que para depurar podrías utilizar una variable pasada como argumento y utilizar user.dir que dentro del NetBeans si devuelve el path del proyecto, asi que concatena con "/dist/turecurso.ext".

Funcionó perfectamente en Ubuntu 8.04 y Windows XP con cuentas limitadas. Hasta la próxima y corre la voz sin olvidar dar crédito a mis aportes.

¿Cómo crear un JAR facilito en JAVA?, con un IDE porsupuesto

Primero debemos saber que es un *.JAR, simplemente es un “ejecutable” de nuestra aplicación en Java, pero en realidad, aunque ustedes no lo crean es un archivo contenedor que comprime todos los archivos *.class de nuestro programa; si no me crees intenta abrir uno con WinZip y verás. La tecnología Java se basa en el uso de la denominada “máquina virtual” que se encarga de procesar los byte-codes (archivos compilados en lenguaje intermedio de java o *.class) y llevarlos al código de máquina de la plataforma donde se instaló el VM de Java o JRE (Java Runtime Environment), es el mismo principio que ahora sigue el .NET Framework, pero Java como todos sabemos es más robusto y eficiente, además que funciona PERFECTAMENTE en Windows, Unix, Solaris, MacOS, GNU/Linux y en varias plataformas x86, AMD2, AS400, etc.

IDE's (Entorno de desarrollo integrado) hay muchos, eclipse, websphere, etc. pero el que está marcando la diferencia es el NetBeans, que va ya por su versión 6 y lo mejor que ofrece es su diseñador visual de Formularios Swing intuitivo y manejable; ¿que qué es Swing? Pues es una librería que hereda las funcionalidades básicas de awt (X windows toolkit) que ofrece controles para generar GUI's (Interfaces de usuario) dinámicas y extensibles; lo malo de Netbeans es que ésta disponible sólo en Inglés.

¿Donde consigo NetBeans?, para Ubuntu y Debian GNU/Linux es sencillo, puedes buscarlo por aptitude o synaptic, además se instala el Java2 SDK6.x porque el paquete de NetBeans lo marca como requerido, no creo que tengas problemas con GNU/Linux.

Para Windows, descarga PRIMERO el Java2 SDK6.x: https://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/ViewProductDetail-Start?ProductRef=jdk-6u7-oth-JPR@CDS-CDS_Developer pesa aproximadamente 200 MB.
Ahora descarga el NetBeans 6.x: http://download.netbeans.org/netbeans/6.1/final/ selecciona el tipo de windows, y preferiblemente la ultima opción “all”, pesa aproximadamente 260 MB.

MANOS A LA OBRA

En NetBeans crear un *.JAR es sencillo: menu File/New project, eliges categoria “Java” de ésa “Java Desktop Application”, das clic en Next y elije el nombre, directorio, etc. después “Finish”.

El NetBeans te crea el dialogo principal y el código de arranque necesario para tu aplicación, solo basta crear la aplicación (algo papita XD jajaja) y para crear el *.JAR sólo basta: menú Build/Build main Proyect y listo, aparecerá el directorio “dist” en el directorio donde creaste tu proyecto, en él se encontrará el JAR de tu programa: nombreprograma.jar.

¿Como lo ejecuto fuera del NetBeans?, en windows el JRE lo configura automáticamente, solo basta darle doble click y listo, en Ubuntu.. es otra historia, hay que usar el comando: “java -cp . -jar rutaarchivo.jar” exactamente como ésta desde la consola, pero para hacerlo que funcione con doble clic como en windows, sigue los siguientes pasos:

1 – con el botón derecho has click en el archivo *.JAR de tu programa. Selecciona: “Abrir con otra aplicación” o “Abrir con”
2 – en el dialogo “Abrir con” despliega la lista inferior “Usar un Comando Personalizado” y escribe exactamente: “java -cp . -jar ” CON UN ESPACIO AL FINAL INPRESCINDIBLE. (como en la imágen anterior)
3 – has clic en Abrir y listo!!!, automáticamente todos tus JAR se abrirán al doble clic como en windows.

Esto es todo por hoy, luego publicaré las primeras conchitas de mango con Swing como la de los formularios Modales, ¡hasta pronto!