14 abril 2012

Escaneo remoto de puertos



Muchas veces me ha pasado, que al hacer alguna instalación de un cortafuegos o cuando he hecho alguna modificación/movimiento de reglas con cierta complejidad, me gustaría saber si, al menos desde fuera, no he dejado abierto algo que antes estaba cerrado. En general, me conecto a la máquina de casa por VPN y SSH y lanzo un nmap con un chorro de opciones a la IP objetivo, para asegurar que lo que se ve, es lo que se tiene que ver, y nada más. En mi caso, que la conexión a mi casa requiero mi propio portátil, no siempre es posible en algunos clientes.

En uno de nuestros primeros posts en SbD ya hablamos sobre un sistema de escaneo remoto de puertos, muy útil a la hora de saber "cómo se ve nuestra IP pública desde fuera". De esta manera, y vía web, podemos ver qué puntos de entrada posibles tiene un atacante, así como si tenemos algún socket escuchando hacia Internet que no debería estar ahí. El sistema que mostrábamos en este post te permitía pasar los parámetros que quisieras a NMAP, además de que permite escanear cualquier IP, y no sólo la tuya. En mi caso, que conozco unos cuantos parámetros de la sintaxis más común de nmap, no hay mayor problema, pero ¿y si el cliente hace algún cambio por su cuenta y quiere comprobar si ha dejado abierto algo de más?   

Curiosamente, mi amigo argentino Matías Katz, al que conocí en el ACK Security CON en Colombia, me comentó el otro día que había montado un servicio muy sencillo de descubrimiento de puertos vía web en su servidor https://www.matiaskatz.com/nmap. Lo estuve probando y me resultó bastante interesante, a la par que sencillo.




No deja de ser más que un frontend web, público, que permite efectuar escaneos a la IP desde la que estás navegando, con diferentes tipos de escaneo, el top de puertos más conocidos que deseemos probar… y sin tener que conocer la sintáxis de Nmap. Matías me ha prometido que añadirá más funcionalidad al escaneo, a la hora de identificar servicios mediante NSE, fingerprinting de las aplicaciones, etc…

Una alternativa más a tener en cuenta a la hora de efectuar una buena práctica de seguridad, como puede ser el escaneo externo periódico de vuestras máquinas.
Leer más...

13 abril 2012

Blogger sin SSL

Blogger sin SSL
Soy usuario de Gmail y además, de Blogger (como tantos), pues bien, un día como otro cualquiera, accedo a gmail y me autentico, hasta ahí todo perfecto. Posteriormente entro en mis blogs (funsecurity.net, tecnomind.org) y claro, soy usuario de google y blogger es de google, pero las cookies son para el dominio google.com, por lo tanto, procedo a entrar mediante en enlace que se encuentra en la esquina superior derecha "Acceder". Automáticamente, se transfieren las sesiones de google.com a blogger.com y ya eres usuario autenticado en blogger. Muy bien, ¿verdad?, pero claro, tenemos un problema, si estamos en una red corporativa/pública, corremos el riesgo que nuestras conexiones sean esnifadas y se hagan con nuestras galletas(cookie/session hijacking), ya que las conexiones de blogger.com no van cifradas.

¿Recuerdan firesheep?, desarrollar un plugin para robar en redes públicas sesiones de bloggeros resulta trivial. En este caso no hay extensión para navegadores ni modo de forzar conexiones SSL, ya que google no lo tiene implementado, o lo hacen o estamos vendidos! Google debería de estar más concienciado con la seguridad de sus usuarios bloggeros. De que nos vale cifrar nuestras búsquedas si luego nuestros blogs están expuestos?!?!

Proceso de transferencia de sesiones entre google.com y blogger.com:

Al pinchar sobre "Acceder", seremos redireccionados a accounts.google.com con los parametros necesarios para indicarle a google que queremos iniciar sesión en blogger.

Cuando accounts.google.com verifica nuestra sesión mediante las cookies, nos responde para redireccionarnos a blogger.com con el parámetro "auth" que indica a blogger.com nuestra autenticidad mediante javascript o meta refresh.

 Petición a blogger.com pasando como parámetro "auth" SIN CIFRAR.

Respuesta de blogger.com con la tan ansiada cookie de blogger.com que nos autentica para realizar operaciones sobre nuestros blogs y que por supuesto viaja SIN CIFRAR.

Google ha sido notificado a la espera de alguna contestación, no obstante y mientras tanto, recomiendo acceder a blogger sólo por redes privadas que nosotros controlemos. El hecho de usar vpn, tor, etc tampoco ayuda, ya que el nodo final podría esnifar nuestras conexiones, a no ser que la red vpn sea controlada por nosotros. Igualmente nuestras conexiones en algún nodo estarán en texto plano, así que cuidadito.

He expuesto la forma en la que yo he descubierto el fallo y además nos ha servido para conocer como google transfiere sesiones. Si accedes a blogger directamente y te logas, igualmente tus conexiones siguen estando sin cifrar a posteriori del logado.

saludos,

Artículo cortesía de Adrián Ruiz Bermudo
Leer más...

12 abril 2012

Los fantasmas de Windows

Bienvenidos a la nave del misterio, hoy, vamos a hablar sobre Fantasmas.

Probablemente si preguntase ¿Crees en los fantasmas? la mayoría de los lectores dirían: NO, algunos tal vez no serían tan categóricos y una pequeña minoría diría que si.

Pero hoy, no vamos a hablar de fantasmas en el mundo terrenal, vamos a hablar de los fantasmas de Windows.

En Windows hay fantasmas y puedo demostrarlo. Cuando ejecutas windows, aparte de todo lo que ves (el escritorio, las ventanas que vas abriendo, etc) hay otras muchas ventanas que están ahí, ocultas, pero están. Estas ventanas forman parte de otros programas y por diversas razones no se muestran.

Si quieres hacerte una idea de cuantas ventanas ocultas hay en tu windows puedes descargar 'GhostBuster', herramienta que permite listar las ventanas ocultas y ver a que procesos pertenecen (además de ciertas propiedades de la ventana).

Un fragmento de la salida de GhostBuster sería este:

GhostBuster 1.0 [www.securitybydefault.com]

Found Hidden Window
Window Class WorkerW
Caption
Process name & PID: explorer.exe 1672
Found Hidden Window
Window Class #43
Caption MCI command handling window
Process name & PID: explorer.exe 1672
Found Hidden Window
Window Class tooltips_class32
Caption
Process name & PID: explorer.exe 1672
Found Hidden Window
Window Class ComboLBox
Caption
Process name & PID: explorer.exe 1672
Found Hidden Window
Window Class tooltips_class32
Caption
Process name & PID: procexp.exe 2580
Found Hidden Window
Window Class tooltips_class32
Caption
Process name & PID: procexp.exe 2580
Found Hidden Window
Window Class WinAMRestoreWndClass
Caption WinAMRestoreWnd
Process name & PID: iTunesHelper.exe 424
Found Hidden Window
Window Class GuestHostIntegrationClass
Caption GuestHostIntegrationWindow
Process name & PID: vmtoolsd.exe 440
Found Hidden Window
Window Class UnitySetTopWindowGroupClass
Caption UnitySetTopWindowGroupWindow
Process name & PID: vmtoolsd.exe 440

Como se puede ver, las ventanas que permanecen invisibles pertenecen a procesos legítimos y de hecho, es normal que estén ahí.

Pero en el mundo de los fantasmas de Windows, hay fantasmas buenos y fantasmas malos. Un tipo de fantasma del que deberíamos cuidarnos mucho es un cmd.exe ejecutándose en modo oculto.

Muchos troyanos hacen uso de esa técnica para ofrecer acceso a la linea de comandos 

Otro ejemplo, es una ventana de navegación de Internet Explorer. El troyano Folklorica (del que hablamos aquí) emplea una ventana de Internet Explorer en modo oculto para pasar y recibir comandos desde fuera.

GhostBuster permite buscar esa clase de ventanas sospechosas con el flag -r que identifica ventanas ocultas cuya clase sea 'IEFrame' o 'ConsoleWindowClass'

Aquí un ejemplo de un par de ventanas ocultas cmd.exe e internet explorer


GhostBuster, además de buscar e identificar el nombre del proceso y su PID, también identifica el PID del proceso padre, lo que es bastante útil para investigar de donde sale esa ventana.

Podéis descargar el binario y el código fuente de GhostBuster desde aquí

PD: Patriot NG, también detecta esta clase de ventanas ocultas 'raras' :)
Leer más...

11 abril 2012

Infección de ejecutables en Linux: ELF y código PIC (1/6)

Durante años, desde que los ordenadores han estado al alcance de las más calenturientas mentes de los hackers de antaño, multitud de extrañas ideas han pasado por sus cabezas, muchas de las cuales fueron llevadas a la práctica y de entre todas ellas, una que creó escuela (sobre todo allá por los años ochenta y principios de los noventa) fue la de infección de binarios. Escribir un programa que puede inocularse a otro, pegársele como un parásito y extenderse por ahí, suena casi a ciencia ficción, ¿cómo resistirse?

A lo largo de la historia de la computación, fueron múltiples las implementaciones prácticas de la infección de archivos ejecutables. Algunos veteranos recordarán las historias del paquistaní Brain, el Virdem, el Vienna, el WHALE y el más moderno CIH.

Todos estos son diversos tipos de virus de DOS/Windows que infectaban ejecutables tipo COM y EXE, y hay mucha literatura acerca de infección sobre este tipo de binarios. Sin embargo, ya no hay tanto (y menos en español) acerca de infección bajo Unix. Lo bueno -o malo, según se mire- de Unix es que de aquí a hace unos años existe un estándar de facto en lo que al tema de formato de ejecutables se refiere. Hablo, por supuesto del Executable and Linkable Format (ELF) cuyo éxito motiva el siguiente artículo.

Y es a partir de aquí cuando debo introducir el DISCLAIMER de rigor para que los geos no me hagan una desagradable visita a la puerta de mi casa. La única finalidad de esta publicación es ilustrar por cuántos sitios un ELF puede ser explotado para a) securizar nuestras aplicaciones incluyendo diversas comprobaciones al arranque o b) aplicar lo expuesto como alguna retorcida técnica a utilizar en algún CTF o como simple curiosidad para aquellos a los que nos gusta jugar con cosas así de raras. El hacer algo más allá ya no es que me limite a decir que es responsabilidad del que lo usa, que cae de cajón, si no que afirmo categóricamente que es mala idea. No es la primera vez que un bicho de estos se escapa de la cámara de incubación para la que ha sido diseñado, y sus desafortunadas leyendas perduran.

Y aclarado esto, saquemos nuestras herramientas de doctor Frankenstein. Vamos a pensar cómo se podría crear un monstruo.

Como este artículo toca tantas cosas, y probablemente me enfrento a un conjunto de lectores con muy diversos grados de conocimiento, he decidido dividirlo en 5 entregas para que cada cual salte a la que le interese:
  1. Introducción al formato ELF y el código PIC
  2. Técnicas de inyección.
  3. Técnicas de activación.
  4. Técnicas de armouring y antidebug.
  5. Securización.

Estas entregas van a ser en general bastante técnicas, por lo que sería bueno que el lector estuviese familiarizado con:
  • El lenguaje C y el compilador de C de GNU
  • Unix en general, y Linux en particular.
  • Programación en ensamblador para x86 (32 bits)
  • El inline assembly de GCC.
Hay mucho que escribir sobre este tema, y dedicar el humilde espacio que una entrada de blog puede darme me obligará a saltarme muchas cosas. Aún así, espero poder aproximarme a la realidad de la explotación de un binario ELF.

El formato ELF
El formato ELF es un estándar que nació en el seno de los Unix System Laboratories de AT&T Bell allá por el 1997 con la intención de superar las limitaciones del antiguo formato a.out. A día de hoy es usado por la mayoría de sistemas *nix como Linux, BSD o Solaris sobre procesadores tanto de 32 como de 64 bits, little endian o big endian, dando como resultado la existencia de dos grandes subconjuntos de formatos: El ELF de 32 bits y el ELF de 64 bits, cuyas cabeceras son ligeramente diferentes debido a las diferencias en el ancho de palabra.

El formato ha sido pensado tanto para ejecutables como para bibliotecas dinámicas, pasando por ficheros objeto y volcados de memoria, aunque este artículo va a estar enfocado sobre todo hacia el primero.

En cualquier caso, se suele decir que un fichero ELF se compone de una cabecera al principio del archivo con unos números mágicos apropiados e información general (del tipo "yo soy un ELF ejecutable para tal procesador y me ejecuto a partir de aquí") y de (hasta) dos tablas de cabeceras que sirven para dotar al fichero ELF de dos "vistas": una vista de segmentos (la cual es indexada mediante un array de estructuras llamado tabla de cabeceras de programa) y una vista de secciones (indexada por otro tipo de array de estructuras llamado tabla de cabeceras de sección). Si bien las dos sirven para definir de algún modo el tipo de información que alberga nuestro fichero ELF, la primera es necesaria para decirle al kernel (o al enlazador si nuestro binario es dinámico) qué porciones de nuestro fichero se cargan en qué partes del espacio de direcciones virtuales y con qué permisos (lectura / escritura / ejecución), y la segunda tiene como finalidad darle al enlazador información sobre qué bibliotecas necesita cargar, qué símbolos debe importar, qué símbolos exporta, etc.

Lo importante de ambas tablas es que no cubren todo el binario, y en la tabla de segmentos habrá zonas que incluso se solapen. Esto tiene como consecuencia que existirán zonas no referenciadas por ninguna de las dos tablas, existirán espacios vacíos o gaps que podríamos modificar a nuestro antojo de forma totalmente asintomática de cara al funcionamiento del binario (aquí probablemente ya haya alguno al que se le pongan los dientes largos).

Este estudio se centrará en el ELF ejecutable para x86, o sea que trabajaremos con ELFs de 32 bits y little endian. En teoría, esto se podría extrapolar a otros formatos (de hecho, me habría gustado probar esto en un UltraSPARC IIe a 64 bits, pero el router que lo saca a Internet ha muerto :( espero poder hacer un anexo más adelante cuando tenga el cacharro de nuevo en mis manos), pero de momento nos conformaremos con esta arquitectura, a día de hoy todavía muy extendida y bien conocida por muchos.

A lo largo de esta serie de entregas voy a referirme constantemente a las diversas estructuras que son contenidas por los ficheros ELF, así que a modo de referencia rápida incluiré una pequeña referencia de las mismas. Para trabajar con ellas desde C bastará con incluir el fichero de cabecera <elf.h>. La cabecera del ELF32 es tal que así:




Las cabeceras de programa empiezan en el desplazamiento e_phoff y es un array con e_phnum elementos del tipo:



A nosotros nos van a interesar sobre todo aquellos segmentos de tipo PT_LOAD, que son los que realmente se van a cargar en memoria. El resto de segmentos son meras subdivisiones de los anteriores explicitando el tipo de información que en ellos se guarda.

Las cabeceras de sección, por contra, empiezan en e_shoff y hay e_shnum cabeceras con el siguiente formato:




Hay muchos tipos de sección, cada uno de ellos haciendo referencia a diversos tipos de datos que podemos encontrar en el fichero ELF. Como mencioné antes, la utilidad que se le da es sobre todo información para el enlazador y depuración (ayuda muchísimo saber dónde empiezan los datos de sólo lectura de los datos normales, por ejemplo, algo que no se puede ver en las cabeceras de segmentos). Algunas secciones que encontraremos mucho en estos binarios son:
  • .text: aquí es donde se encuentra el código máquina ejecutable.
  • .data: donde podemos encontrar datos de lectura/escritura, normalmente variables estáticas o globales.
  • .bss: variables estáticas y globales sin inicializar (que por defecto son iguales a 0)
  • .rodata: datos de sólo lectura, normalmente cadenas y constantes.
  • .hash: tablas hash para la resolución rápida de símbolos.
  • .plt: trampolines para poder acceder a funciones externas importadas de bibliotecas dinámicas.

El procedimiento de carga
¿Cómo se carga un ELF en memoria? En la práctica se dan muchas situaciones diversas, pero en la mayoría de casos sólo nos debemos de preocupar de qué tipo de ELF se trata (¿es una biblioteca dinámica o un ejecutable?) y de si el ELF es estático o no (es decir, si depende o no de bibliotecas ajenas)

Se podría escribir todo un libro sólo sobre la carga de un ELF, pero voy a intentar resumirlo en los dos grandes casos que suelen darse en el mundo real: el ejecutable ELF estático -todo lo que el ELF necesita ya está codificado en el ELF y no usará nada más- y los ejecutables / bibliotecas ELF dinámicos -que importan / exportan objetos que otros módulos puedan necesitar-.

El binario ELF estático: es el más fácil de cargar (además de que suelen ser los más grandes y más fáciles de infectar). De entre los ejecutables y las bibliotecas, sólo los ejecutables pueden tener enlazado estático, y eso tiene sentido ya que las bibliotecas las usas para exportar dinámicamente símbolos. Este tipo de fichero es el que el kernel abre, se cerciona de que no existen cabeceras de tipo PT_INTERP o PT_DYNAMIC y que carga religiosamente cada PT_LOAD que encuentra si se lo puede permitir, saltando a ep_entry una vez que ha terminado la carga.

El binario ELF dinámico: este tiene un poco más de chicha, ya que bajo el nombre de ELF dinámico abarcamos tanto ejecutables como bibliotecas. En el caso de los ejecutables, tan pronto el kernel encuentra un segmento de tipo PT_INTERP, lee su contenido (que debe incluir una ruta absoluta a un "intérprete", normalmente algo como /lib/ld-linux.so) y lo carga en memoria en el mismo proceso que el binario dinámico que estamos cargando. El kernel pasa el control a este intérprete, que examina el binario cargado, analiza qué bibliotecas necesita, las intenta cargar, carga las bibliotecas que las otros bibliotecas necesita, y una vez que ha terminado de recorrer todo el árbol de dependencias comienza a resolver todos los símbolos que deban ser resueltos en el momento de carga. Una vez listo, salta al punto de entrada del ejecutable.

Nótese que en este último caso, las bibliotecas dinámicas no las carga el kernel, si no el propio intérprete mediante reads y mmaps. Los casos en los que el kernel carga directamente una biblioteca dinámica son tan concretos que los vamos a obviar. A la hora de infectar debemos tener en cuenta que hay muchas cosas que no se van a cargar en el mismo sitio, y esto suele complicar las cosas de cara a una infección exitosa. Sin embargo, este proceso tan complejo involucra la ejecución de constructores, destructores, funciones de inicialización y llamadas a punteros en general, lo cual nos abre la puerta a hacer llamadas al código inyectado.

Esta situación además nos dice algo interesante: es posible escribir código que pueda funcionar en cualquier punto de la memoria (puesto que una misma biblioteca puede cargarse en puntos distintos del espacio de direcciones) sin tener que recurrir a programar directamente en ensamblador. Y esto lo necesitaremos ya que en última instancia vamos a inyectar código en otro ejecutable, código que necesariamente se cargará en sitios distintos en función de donde lo inyectemos. Esta técnica, necesaria para que las bibliotecas dinámicas funcionen se llama PIC (Position-Independent Code), y nos lleva al siguiente punto:

El código independiente de la posición (PIC)
Esta es la clave del funcionamiento de las bibliotecas dinámicas. Un ejecutable suele escribirse para una determinada dirección de carga (en GNU/Linux-x86 suele ser a partir de 0x08048000), por lo que puede hacer las referencias absolutas que le plazca. Sin embargo, en una biblioteca ya no es así, porque entre que dos binarios pueden cargarla en puntos distintos, y que si tenemos ASLR activado entonces ya en un mismo binario se nos va a cargar en Cuenca, lo único que tenemos estable son las distancias relativas a cada punto del código. Y esto es precisamente con lo que juega PIC.

En x86, cuando GCC compila un binario con PIC (sea un ejecutable o una biblioteca), el binario resultante intenta llevar a cabo lo que se conoce como "direccionamiento relativo al EIP", concepto que a los programadores de x86-64 les sonará bastante. La idea viene a ser que, ya que no sabemos a priori dónde nos cargamos, podemos calcular la dirección en la que nos encontramos y sumarle (o restarle) un desplazamiento que será siempre el mismo para saber dónde se encuentran las funciones o variables que nos interesan.

Como dije antes, en x86-64 esta idea es familiar, y hay numerosas instrucciones que permiten acceder a datos tomando el puntero de instrucción (%rip) como base. En x86 (32 bits) tal direccionamiento no está tan pulido, y sólo puede utilizarse con instrucciones de salto siempre y cuando el punto al que queramos saltar no nos quede demasiado lejos. En el resto de casos, tenemos que llamar a una función que nos calcule la dirección en la que nos encontramos. Esta función GCC la llamará __i686.get_pc_thunk.bx, que meterá en %ebx la dirección de retorno desde la que se llama. Como consecuencia de este hack, tenemos una ligera pérdida de rendimiento a la hora de compilar para PIC:

Un inocente programa que muestra un mensaje, compilado bajo x86 con la opción -fPIC de GCC


El mismo programa compilado para x86-64, nótense los direccionamientos relativos al %rip


La razón por la que los chicos de GCC decidieron utilizar %ebx para este fin en una arquitectura en la que los registros de propósito general ya escasean, complicando mucho su uso como registro genérico teniendo en cuenta además que es donde se coloca el primer argumento de las syscalls, es bastante oscura (las directivas de inline assembly de GCC no nos van a dejar utilizar %ebx como registro de entrada), pero ahí está. En cualquier caso, esto quiere decir que si queremos que nuestro código PIC funcione, vamos a tener que incluir esa función en él. El problema es que esa función la pone directamente el compilador donde le cuadre y tampoco es un weak symbol (o sea que tampoco podremos sobreescribirla para colocarla donde nos guste). Veremos técnicas para medir nuestro código incluyendo esta molesta función en el siguiente punto:

Nuestro primer código PIC que se mide a sí mismo.
La mejor forma de estudiar hasta qué punto se puede explotar la infección de un binario es poniéndola en práctica nosotros mismos. Lo primero que necesitamos es poder inyectar código (y no datos) en un ejecutable. O sea, que nada de variables globales.

Esto debe hacerse así debido a que las variables globales para nuestros propósitos son un impedimento bastante gordo, estas suelen empezar mucho después del segmento de código (esto lo veremos luego, sobre todo por requerimientos de alineamiento de página del procesador, no podemos tener una página que sea una mitad ejecutable y la otra no) y además de que ocupan un espacio innecesario cuando no están siendo usadas.

Lo que vamos a inyectar debe ser puro segmento de código, y el resto de información debe ir incrustada en nuestras funciones como variables locales. Como las variables locales se reservan dinámicamente en la pila tan pronto la función que las contiene es llamada, no hay que reservar espacio previamente para ellas. La función correspondiente hace todo el trabajo.

Otra cosa muy importante es que necesitamos que el código a inyectar no dependa de bibliotecas externas. Esto es importantísimo ya que en tal caso necesitaríamos toda la información dinámica que el GCC generaría, la cual se encuentra principalmente en el segmento de datos -primera pega- y además tendría que ser visible al enlazador dentro de un binario infectado, lo cual es muy difícil por no decir imposible. Nuestro código ha de ser estático, y para reducir espacio no utilizaremos la libc. Trabajaremos directamente con syscalls.

Y por último, cómo no, que sea independiente de la posición.

Para poder inocular nuestro código, independientemente de cómo lo hagamos (que ya veremos técnicas, tranquilos :P) es saber cuánto medimos sin tener que incluir esa información a fuego en el binario. Que se puede, pero después de varias modificaciones sucesivas acaba ralentizando el desarrollo. Está claro que esto va a aumentar su tamaño, pero de momento servirá para su intención didáctica.

Primer intento (fallido)
Una primera aproximación podría ser esta: podemos definir un símbolo al principio de nuestro programa con la sección .text (siempre y cuando trabajemos con un único fichero y que es donde empieza nuestro código realmente, no el segmento de código, que ese empieza mucho antes e incluye hasta las cabeceras del ejecutable), y el final de nuestro código podemos medirlo con la dirección de _etext (que la define el compilador y marca donde acaba el código realmente, no sólo el segmento de datos). Esto parece buena idea, ya que esa __i686.get_pc_thunk.bx está dentro del .text. Tenemos algo como lo que sigue:




Aquí hay varias cosas que pueden llamar la atención. La primera, es que hay una función write que hace la llamada a la llamada al sistema correspondiente y una función long2hex. Además de la ausencia de main y una tal _start. Las dos primeras son consecuencia de la ausencia de la biblioteca estándar de C. Todo lo que necesitemos vamos a tener que codificarlo nosotros mismos si lo queremos realmente portable, en este caso la función write (para escribir por pantalla, por ejemplo) o long2hex (para convertir un número a cadena).

La función _start es el punto de entrada. Cuando al GCC enlaza contra la libc se añade una suerte de funciones extra al binario que hace inicializaciones previas (entre ellas, su propia _start) que se encargan, entre otras cosas, de llamar al main de C de toda la vida. Como nosotros no podremos disponer de la libc vamos a tener que escribir directamente a partir del punto de entrada, y ahí sí que no tenemos nada. Ni argumentos, ni variables de entorno arregladas, ni nada.

Este código, para cumplir todos los requisitos que hemos impuesto, debe compilarse de esta forma:
% gcc first.c -o first -nostdlib --static -fPIC
Donde --static sirve para generar un binario estático (sin dependencias de bibliotecas), -nostdlib evita enlazarnos la biblioteca estándar de C y -fPIC (quizá la más importante) obliga a GCC a generar código independiente de la posición. Ejecutándolo, cumple religiosamente su cometido:
% ./standalone
080480f8
08048241
00000149
^C
La primera dirección es donde empieza, la segunda donde acaba, y lo último es el tamaño (en hexadecimal).

Si desensamblamos lo que hemos generado, vemos esto:
% objdump -d first
first:     file format elf32-i386

Disassembly of section .text:
080480f8 <write>:
[...]
8048186:       e8 b2 00 00 00          call   804823d <__i686.get_pc_thunk.bx>
804818b:       81 c3 69 1e 00 00       add    $0x1e69,%ebx
[...]
8048195:       8b 83 fc ff ff ff       mov    -0x4(%ebx),%eax
[...]
8048240:       c3                      ret
Las direcciones cuadran con lo que nuestro binario ha dicho, podemos ver direcciones absolutas que realmente el código ignora, pero hemos cometido un tremendo FAIL. ¿Por qué? Lo que GCC suele hacer con %ebx es tan pronto tiene el %eip, calcular la dirección de la tabla de desplazamientos globales (GOT, la cual debería estar en el segmento de datos) relativa al %eip, para luego direccionar de nuevo a partir de la GOT. Esto en sí no es un problema, ya que el único papel que desempeña la GOT (que no copiaremos) es como una especie de "referencia imaginaria" a partir de la cual direccionar cosas. Normalmente, cuando se tiene que acceder al código, se suele sumar a %ebx un desplazamiento de una magnitud similar pero negativa, ya que el código está antes del segmento de datos y por tanto de la GOT.

El problema aparece cuando nuestro código accede realmente a la GOT, cosa que está pasando en 0x8048195 para leer en ella las direcciones de _stext y _etext. Esto quiere decir que el código depende del segmento de datos. Entonces no nos vale.

Segundo intento (este ya funciona mejor)
Ya no podíamos usar variables globales, ahora hemos descubierto que tampoco podemos utilizar los símbolos externos de tipo _etext, _stext ni nada que se le parezca. Tampoco vamos a codificar los límites del código a fuego. Por lo tanto, vamos a tener que ingeniárnoslas para calcular dichos límites. Una forma chapucera pero funcional es acotar nuestro código con un par de cadenas de bytes que hagan de marcadores que podamos identificar, cadenas que deben aparecen como bytes dentro del código ejecutable (siguen sin tratarse como datos, ojo). Allá donde encontremos dichos bytes sabremos que de ahí hacia adelante (o hacia atrás) no hay más código.

Aún así, esto implica una serie de problemas que debemos (y podremos) sortear. El primero es el de las colisiones, debemos tomar una secuencia de bytes lo suficientemente larga y extraña para que no aparezca en el código, y que el código que comprueba dichos bytes no provoque una colisión por el hecho de utilizar dicha información para comparar. El segundo es que no tenemos forma de asegurar desde nuestro código que dicho marcador se va a colocar exactamente al principio o al final. Aunque acotemos nuestro código con esas cadenas mediante el inline assembly, el enlazador del GCC puede recolocarlas después como le plazca. Y el tercero, ¿dónde se carga __i686.get_pc_thunk.bx? ¿Al principio, al final, en medio de nuestra sección .text?

Pues como dijo Jack el Destripador, "vamos por partes". La primera parte tiene fácil solución: tomamos un par de enteros de 32 bits como dicha secuencia de bytes, de forma que tenemos una marca de 4 bytes al principio y otra al final. Para que la comprobación no genere dichos enteros, podremos comprobar separadamente las dos mitades de 16 bits de cada una, de forma que no se generará una instrucción con exactamente la misma palabra que buscamos. Si 32 bits fuesen insuficientes (cosa que dudo) podríamos tomar dos enteros de 32 bits. Pero cuanto menos usemos, mejor.

Para lo segundo y lo tercero tenemos un remedio común: scripts del enlazador. Los scripts del enlazador nos permiten configurar aspectos más oscuros del binario que estamos generando, como por ejemplo qué hay en cada sección, que símbolos se exportan, en qué formato debe generarse el binario, en qué dirección se carga... lo que haremos será generar dos secciones, una para el marcador de inicio y otra para el marcador final, y haremos que se carguen justo antes y después de .text. Así matamos dos pájaros de un tiro, por una parte colocamos correctamente los marcadores, y por otra aseguramos que __i686.get_pc_thunk.bx queda ubicado entre ellos.

El plan de acción es este: definimos un par de secciones (.code_bottom y .code_top) que contendrán esos marcadores, mediante un script del enlazador forzamos a que se coloquen justo antes y después de la sección de código (.text) y escribimos una función llamada get_code_limits que se encargará de buscarlos.

He utilizado la cadena "KPAX" como marcador de inicio y final por dos razones. La primera es que, pese a tener sólo 4 bytes, es prácticamente imposible encontrarla en ninguna parte de la memoria de ningún binario, aunque bastaba con que no saliese en toda la extensión del código. He buscado esa cadena con grep en /bin, /usr/bin y /usr/lib y el número de coincidencias asciende a 0. La segunda, que me ha molado mucho esa película, o sea que a tomar por saco :P

El código funcional (second.c) es el siguiente:



Y el script del enlazador (second.lds) este:




Nuestro programa se compilará con:
% gcc second.c -o second -fPIC -static -nostdlib -Wl,-Tsecond.lds
Y al ejecutar veremos que se mide correctamente:
% ./second
080480d8
080482a4
000001cc
^C
Estos límites los podemos comprobar con objdump -sdx second. Además, no hay referencias al segmento de datos, o sea que todo bien.


Artículo cortesía de BatchDrake
Leer más...

10 abril 2012

En la pasada Rooted CON 2012 tuve el enorme placer de compartir escenario con Raúl Siles, en una charla programada para el sábado a última hora, en la que hablamos sobre Seguridad de aplicaciones web basadas en el DNIe. En ella se darían a conocer una serie de vulnerabilidades que se encontraban en las aplicaciones web que hacen uso del DNIe, tanto para autenticación e identificación, como para firma. Además del caso de las aplicaciones, se expuso la problemática en ciertos componentes que también son utilizados para realizar operaciones con el DNIe (como si de otro certificado se tratase...), los cuales se solicita al usuario su instalación o utilización desde su navegador.

La presentación ya se encuentra alojada en la cuenta de Slideshare de RootedCON, y la incluímos a continuación. Raúl ha publicado información acerca de la primera parte de la charla en el blog de taddong.com, en la cual además de presentar los resultados de su investigación, pone a disposición de todos un módulo para que OWASP ZAProxy reconozca el certificado del DNIe y así permitir utilizar esta herramienta de interceptación de peticiones web en aplicaciones que hagan uso de él en su negociación SSL. A partir de la diapositiva 53 accederéis a la sección de la charla en la que se exponen las vulnerabilidades en los componentes cliente:


Raúl Siles y José A. Guasch - Seguridad Web de aplicaciones
basadas en DNI-e [RootedCON 2012]




En este primer post realizaremos una introducción a los tipos de componentes que existen (en general), y con qué herramientas poder analizarlos.

Tipos de componentes cliente

Realizaremos el estudio sobre dos tipos de tecnologías utilizadas para la programación de componentes cuyas operaciones deban realizarse en el lado del cliente/navegador del usuario: ActiveX de Microsoft y Java Applets.
  • ActiveX = Software en forma de componente que funciona únicamente en navegadores Internet Explorer, y sobre plataformas Microsoft Windows (el sistema operativo puede utilizar ActiveX para otras funciones, pero en este caso nos centraremos en los utilizados mediante el navegador). Su programación se realiza en la mayoría de los casos sobre Visual Basic y C++. Los ficheros suelen tener la extensión .CAB o .EXE y se instancian mediante  una etiqueta OBJECT de HTML, con los siguientes atributos necesarios:
    • CLSSID - identificador único del componente, mediante el cual se determina si el componente existe en el sistema para su reutilización, en caso negativo, se descarga del servidor.
    • ID - identificador con el que se identificará posteriormente en el código, para la llamada a sus funciones y procedimientos.
    • CODEBASE - Ruta remota dónde se encuentra alojado el componente si se requiere su descarga.

    Los siguientes diálogos identifican la existencia de ActiveX, su solicitud de instalación, aviso al usuario por requerir su carga, etc:
Aviso en el navegador sobre la instalación de un componente ActiveX por parte de una aplicación web

  • Java Applets = A diferencia de los ActiveX, los applets de Java son multiplataforma y multinavegador, requiriendo la máquina virtual de Java para su ejecución. Estos applets avisan al usuario sobre sus requisitos a nivel de permisos antes de su ejecución, depende de si se encuentran firmados, no firmados o firmados mediante una entidad propia. Para los controles firmados se delega en el desarrollador los requisitos y accesos necesarios para el correcto funcionamiento de la aplicación, para el resto, al usuario se le muestra un aviso informando sobre la necesidad del applet. Los applets tienen extensión .JAR, y se pueden instanciar tanto por la etiqueta OBJECT de HTML como por APPLET, con los siguientes atributos:
    • CODEBASE - Dirección base desde la cual descargar el applet
    • CODE - Clase concreta del applet (en .class) que se necesita cargar, y que ofrecerá una serie de procedimientos y funciones con la que realizar operaciones.
    • ARCHIVE - Dependencias previas de clases necesarias para la carga del applet
    • NAME - identificador con el cual el applet podrá posteriormente ser utilizado mediante código Javascript.
    Se puede identificar la carga de applets cuando aparezcan los siguientes diálogos en el navegador Uno de los primeros indicadores viene cuando vemos aparecer la consola de Java, siempre que ésta se encuentre activada, en el systray de nuestro sistema:
Ejemplo de Applet de Java, cuya firma ha sido verificada correctamente, y en el que se avisa de su ejecución sin restricciones
Aviso de necesidad de ejecución de un Applet de Java cuya firma no puede ser verificada
    Otra forma de desplegar applets, de una forma mucho más sencilla, es utilizando el protocolo JNLP (Java Network Launching Protocol) mediante el cual, con un simple fichero en formato XML, es posible instanciar por completo un applet, con todas sus dependencias y parámetros iniciales.
Seleccionemos por tanto un componente de cada tecnología sobre los cuales aplicar lo que vayamos mostrando: para el ActiveX utilizaremos el .cab del CAPICOM, librería utilizada para facilitar la interactuación con la CryptoAPI Windows. Para los ejemplos con el Applet Java, utilizaremos este HelloWorld que se encuentra en este enlace de la web de Oracle sobre la introducción a la programación de applets.

En primer lugar resaltar que ambos contenedores base (el .cab para ActiveX y el .jar en Applets de Java) pueden ser desempaquetados con un simple descompresor de ficheros, como si de un .zip se tratase. Para el caso de los ActiveX (.cab) veremos un conjunto de librerías DLL u OCX, así como otros recursos.

Fichero .cab correspondiente con el componente ActiveX

Descompresión del archivo mediante descompresor

Contenido del fichero .cab

Dentro de los applets Java (.jar), obtendremos todos los recursos (iconos, imágenes, propiedades...) incluyendo los ficheros .class, dónde se encuentra la lógica y programación de la aplicación.


Fichero de Applet en .jar

Descomprimir como si se tratase de cualquier fichero comprimido en ZIP

Contenido del fichero .jar

Una vez tenemos los ficheros que conforman los componentes, podremos realizar las típicas tareas de análisis de aplicaciones, como si de cualquier otra pieza de software se tratase. A continuación recopilamos herramientas que nos servirán para poder realizar un análisis más en profundidad, como son visores de funciones, debuggers/depuradores y fuzzers.

Herramientas para analizar componentes ActiveX

Visores de funciones disponibles en ActiveX

OLE/COM Object Viewer - Aplicación perteneciente al Windows Resource Kit de Microsoft tanto de Windows Server 2000 como de Windows Server 2003. Con ella podremos acceder a información acerca de los controles presentes en el sistema, información de sus interfaces, etc. Para poder ver información más detallada, como por ejemplo parámetros y tipos aceptados por las funciones disponibles, necesitaremos incluir la librería iViewers.dll para obtener toda la información del componente, y no sólo sus propiedades.


COMRaider - Si bien esta aplicación de iDefense está ideada principalmente para el fuzzing de componentes ActiveX, podemos aprovecharla también para tener una visión completa de las funciones  con sus correspondientes parámetros aceptados. Todas las herramientas muestran los entresijos de los componentes, pero personalmente es la que más me gusta, y eso que se ha quedado un poco anticuada en cuanto a interfaz...Podréis descargarla del siguiente repositorio, ya que su enlace a los labs de iDefense ya no se encuentra disponible.

Abriendo la .dll del CAPICOM con COMRaider, obteniendo funciones y parámetros permitidos por el componente

Debuggers de componentes ActiveX

En esta ocasión, como si de cualquier otra librería se tratase, las DLL principales de los ActiveX pueden ser procesadas mediante un debugger como puede ser OllyDBG, IDA de Hex-Rays o el Immunity Debugger. Estas herramientas nos permitirán realizar ingeniería inversa sobre las librerías y poder buscar vulnerabilidades asociadas a estos componentes que se incluyen en la ejecución de Internet Explorer cuando son instanciados.

Fuzzers para ActiveX

Para el que no lo sepa, diremos que los fuzzers son programas encargados de probar la integridad de aplicaciones y componentes, realizando llamadas a los procedimientos que contienen, en base a multitud de casuísticas y diferentes tipos de valores para los parámetros. Una vez se identifican las funciones disponibles (y que obviamente acepten parámetros) se obtiene el tipo asociado a dichos parámetros y se crea un banco de pruebas instanciando el componente y controlando su comportamiento durante el flujo de ejecución.

Para realizar fuzzing sobre ActiveX, tenemos varias herramientas, entre las que destacamos la anteriormente mencionada COMRaider de iDefense Labs, además de dranzer del CERT, AxMan de HDMoore, etc.

Os recomiendo este post de Alex titulado "Seguridad en ActiveX" con información detallada sobre cómo realizar pruebas sobre componentes ActiveX utilizando estas y otras herramientas. 

Herramientas para analizar componentes Applets Java

Una vez disponemos de un directorio con el contenido del fichero .jar tras ser descomprimido, veremos una jerarquia de directorios en los que se incluyen ficheros con extensión .class.

Contenido del fichero .jar, con dos ficheros .class y la carpeta de meta-información META-INF.

Decompiladores de Applets Java

A diferencia con los ActiveX, los .class de los Applets de Java pueden ser decompilados, mostrando el código fuente "casi" completo del applet, algo que nos viene genial para poder identificar más rápidamente posibles vulnerabilidades sin tener que recurrir a métodos de prueba y error como los que se utilizan realizando fuzzing a las aplicaciones. Dos de los decompiladores más famosos de ficheros .class son el JD-GUI, el JADClipse que integra el decompilador jad con Eclipse, y el DJ Java Decompiler (obsoleto, GUI para el comando jad).

A continuación vamos a decompilar el simple HelloWorld.class mediante JD-GUI:

Decompilación del código HelloWorld.class mediante JD-GUI

Importante destacar los iconos que se encuentran a la izquierda de la función init(), cuyo color (verde en este caso) indica el tipo de declaración realizada de las funciones. En caso de disponer de un ícono verde, la función es pública y puede ser instanciada de forma externa. Ya tenemos el código fuente completo, en el que si sabemos interpretar mínimamente código Java, veremos una gestión de excepciones y una función que se encarga de crear una etiqueta con el texto "Hello World" en él dentro del applet cuando éste sea cargado en la aplicación. 

Debugger para Applets Java

JavaSnoop fue presentado en la BlackHat de Las Vegas en el 2010 por Arshan Dabirsiaghi, director de investigación de la empresa Aspect Security. Esta herramienta nos permite adjuntarnos al proceso del applet en su ejecución, como ocurre con los típicos debuggers de binarios, instalando "hooks" en los métodos disponibles. Si bien los decompiladores de Applets nos dan todo el código, con esta herramienta se facilita enormemente la realización de pruebas concretas sobre los métodos soportados por el Applet.

Una vez tenemos la aplicación en nuestro sistema, lo iniciamos mediante el correspondiente fichero de inicialización (startup.bat/.sh):

Inicio de JavaSnoop 1.0
Se pueden realizar dos funciones, abrir un nuevo proceso sobre el que adjuntarse, o adjuntarse a un proceso ya existente. Para el ejemplo, nos adjuntaremos al proceso que se encuentra ejecutando el applet de HelloWorld dentro de la página de ejemplo de la propia web de Oracle mediante el botón "Attach & Snoop Process":

Seleccionando el proceso sobre el que nos adjuntaremos y realizaremos la depuración

Adjuntados al proceso correctamente
Añadiendo un hook en las funciones disponibles del applet.

La aplicación nos permite añadir "hooks" a funciones. En el ejemplo de la captura anterior se reconoce la función HelloWorld, entre otras propias de librerias cargadas por el componente (parte gráfica de la etiqueta dónde se muestra el mensaje).

Y bien, ya hemos presentado algunas herramientas que nos permitirán preparar un entorno con el cual comenzar el análisis de componentes ActiveX y applets Java. En el siguiente post comenzaremos a revisar vulnerabilidades típicas que se encuentran en este tipo de componentes.
Leer más...

09 abril 2012

Curso de Perito Informático Forense por la ANTPJI


Disclaimer: Estimado lector, si has llegado a este artículo buscando ayuda con relación a algún análisis forense, formación relativa al tema o a una asociación existente, yo, Lorenzo Martínez, a título personal, te quiero hacer saber que ya no me encuentro en la ANTPJI. Por ello, si piensas que puede darte ciertas garantías que yo pertenezca a la misma, te ruego que leas el post relacionado con ANCITE, Asociación Nacional de Ciberseguridad y Pericia Tecnológica.

------------------------------------------------------------------------------------------------------------------------------

Es la primera vez que la ANTPJI (Asociación Nacional de Tasadores y Peritos Judiciales Informáticos) propone, a todos aquellos que así lo deseen, la asistencia a un curso presencial de Perito Informático Forense en Madrid.

Dicho curso se llevará a cabo el fin de semana del 21 y 22 de Abril por parte de expertos en seguridad y auditoría informática forense que expondrán a los asistentes las últimas técnicas de extracción de evidencias digitales, así como el protocolo oficial para la realización de dictámenes judiciales.

El plantel de profesores que impartirán dicho curso, cuenta con profesionales reconocidos del sector como nuestros habituales camaradas Chema Alonso, autor del blog Un Informático en el lado del mal y Pedro Sánchez, del blog Conexión Inversa. Además contará con expertos como Ángel Bahamontes (presidente de la ANTPJI), Alfredo Díaz (Abogado tecnológico), José Luis Narbona (Profesor Asociado a la Universidad de Alcalá de Henares), Miguel Ángel Ramos (profesor de auditoría informática, sistemas de información, Auditoría y Certificación en la Universidad Carlos III de Madrid), Emilio Aced (Subdirector general en APDC), Nicholas Green (Director de la empresa Kroll Ontrack, especializada en recuperación de datos) y Ángel Ponce de León (Director académico de los títulos de Dirección de Seguridad UCJC)

El curso, que constará de 10 horas de duración, tendrá el siguiente temario:
  • El perito informático forense
  • Aspectos legales de la LOPD
  • La evidencia telemática
  • Laboratorio informático forense. Aspectos legales y jurídicos
  • Recuperación y extracción de datos
  • Análisis de metadatos
  • Redacción de un informe pericial
Las plazas son limitadas. Para apuntarse hay que informarse en la página de cursos de la ANTPJI. Los costes de inscripción son los siguientes:
  • Los socios de ANTPJI: 60 euros
  • Universitarios (acdreditados con su carnet de estudiante de alguna Universidad, ya sean estudiantes de Grado o de Máster): 120 euros
  • Otros profesionales: 225 euros
  • Si se está desempleado actualmente, se hará un 20% de descuento
Leer más...

08 abril 2012

Flashback botnet: ¿Vulnerabilidad de Java? No, de Mac OS X


He de confesar que mi motivación para escribir este post en la tarde de un domingo, es expresar mi visión ante el artículo que escribió Eduardo Arcos en el archiconocido blog de Tecnología ALT1040 "Flashback botnet: ¿Vulnerabildad de Mac OS X? No, de Java".

En él, el popular blogger ecuatoriano, culpaba a Oracle (propietario de Sun, y por ende de la tecnología JAVA) del fallo de moda que ha causado que más de 600.000 equipos con sistema operativo Mac OS X, hayan sido infectados por el troyano Flashback, exculpando a Apple del tema. Asimismo en dicho artículo, el autor afirmaba categóricamente: "Pero Mac OS X al ser basado en UNIX es sumamente seguro y por lo tanto mucho menos vulnerable".

Con estas premisas, me gustaría dar mi punto de vista sobre lo que, a mis ojos (y parece ser que ante los de los lectores de ALT1040 que dejaron sus comentarios al controvertido artículo también), es una opinión equivocada. Para empezar, y por desmitificar el título del artículo: La culpa de esta vulnerabilidad, es de Apple! ¿Por qué? pues principalmente, porque el motor Java incluido en el sistema operativo Mac OS X lo implementa Apple y no ORACLE. Es por eso que la organización encargada de publicar los parches necesarios para corregir las vulnerabilidades que surjan para este módulo es Apple, y no ORACLE.    

Apple, gracias al boom de sus equipos informáticos (portátiles, sobremesa, ipads, iphones, etc,…) ha ido ganando cada vez más cuota de mercado. Evidentemente, y por qué no decirlo, desgraciadamente, el porcentaje de mercado para los dispositivos con sistema operativo Mac OS X, es irrisoria comparada con el todopoderoso parque de PCs con Windows, distribuidos por el Mundo. Sin embargo, dada la gran aceptación de este sistema operativo por parte de un público, harto de pantallazos azules, que busca funcionalidad de serie y estabilidad en un sistema operativo de escritorio, ha levantado la bandera para que los desarrolladores de malware pongan en su punto de mira la explotación de vulnerabilidades de Mac OS X. 

Hasta hace unos años, los early adopters usuarios de Apple, vivían felices, viendo como los usuarios de Windows eran constantemente atacados por malware específico para explotar sus vulnerabilidades. ¿Se podía decir que Mac era seguro? Categóricamente NO. Lo que se podía decir es que no había virus, o la proporción era muy baja, o simplemente que sentarse a buscar vulnerabilidades para un público tan reducido no era rentable para los desarrolladores de malware. Sin embargo, y debido a esta explosión de márketing hacia Apple, los "gusanos para las manzanas" se han multiplicado y, el mejor ejemplo de que las amenazas están ahí, es que prácticamente todas las casas de software antivirus han publicado una versión específica para Mac OS X.
 
Ante este panorama, a Apple no le ha quedado más remedio que empezar a ponerse las pilas con la seguridad de sus soluciones, materia en la que no eran precisamente expertos. Cuando Windows ya implementaba tecnologías como DEP Data Execution Prevention en el Service Pack 2 de Windows XP en 2004 o ASLR Address Space Layout Randomization en aquella decepción consumidora de recursos que era Windows Vista (en Enero de 2007), Apple introducía DEP en 2006 y una implementación decente en Mac OS X Lion (en 2011). Es decir que en este sentido, Windows ha tenido una conciencia de seguridad mucho mayor que Apple a la hora de implementar tecnologías más seguras en cuanto a la ejecución de aplicaciones.

Como se puede observar con este último ejemplo en el troyano Flashback, la celeridad en el publicación de parches no es precisamente algo de lo que Apple, ni sus usuarios, podamos vanagloriarnos, habiendo sido publicado el parche para esta vulnerabilidad de JRE, por parte ORACLE, en Febrero de 2012. En este caso, hasta mes y medio después, no ha existido solución por parte de Apple. Incluso el primero de los parches, presumiblemente no debió ser todo lo acertado/fino posible por lo que Apple tuvo que re-publicar un parche para esta vulnerabilidad, al día siguiente.

Asimismo, los usuarios de Tiger y Leopard, actualmente se encuentran indefensos ante esta y otras futuras  vulnerabilidades, al haberse detenido el desarrollo de parches para dichas versiones de OS X.

Así pues, queda demostrado que la afirmación de que "Mac OS X, al ser basado en UNIX, es sumamente seguro y mucho menos vulnerable" es completamente incierta, fruto de la impulsividad de un fanboy, incondicional a una marca que, efectivamente hace dispositivos y sistemas operativos muy atractivos, muy usables, muy estables y muy funcionales,… pero cuyo nivel de seguridad es cuanto menos mejorable, al igual que el de TODOS los demás sistemas operativos, y los módulos involucrados en los mismos.

Quiero indicar que, en mi situación personal, usé Windows como sistema operativo de escritorio hasta el 2003. A partir de ahí, empecé a utilizar KDE sobre Linux, y a mediados de 2008 relegué Linux a mi uso diario en mi servidor, pasando a usar Mac OS X como herramienta de trabajo diario hasta el día de hoy, estando además muy satisfecho con sus niveles de rendimiento y usabilidad.

La seguridad es un proceso, y como tal, debe evolucionar a la vez que lo hace la propia innovación de los productos de la marca. Estoy seguro que Apple, como el gigante innovador que es, tendrá esta experiencia en cuenta y se pondrá las pilas, como hizo Microsoft en su día, para disponer de niveles de seguridad acordes con la calidad estética y funcional de sus productos.
Leer más...