martes, 10 de julio de 2012

Hashtables con hsearch_r y hcreate_r, hecho fácil


hsearch_r(), hcreate_r() y hdestroy_r() son funciones POSIX para el manejo de hashtables. No son las más intuitivas, ni tampoco las más portables, pero el hecho de que vengan con cualquier sistema GNU y no tengas que instalarlas las hace muy cómodas.

Dado que trabajar con ellas es poco práctico he creado unas macros que facilitan su uso y hacen el código más legible. Son las siguientes:


#define _GNU_SOURCE
#include <search.h>


#define HASHTABLE_CREATE(name, sz) \
   struct hsearch_data *name = calloc(sz, sizeof(struct htsearch_data*)); \
   hcreate_r(sz, name); 

#define HASHTABLE_DESTROY(name) hdestroy_r(name)

#define HASHTABLE_SET(name, strkey, value) \
{ \
   ENTRY e, *r; \
   e.key = strkey; \
   if(hsearch_r(e, FIND, &r, name)) \
   { \
      r->data = (void*) (value); \
   } \
   else \
   { \
      e.data = (void*) (value); \
      hsearch_r(e, ENTER, &r, name); \
   } \
}


#define HASHTABLE_GET(name, strkey, value) \
{ \
   ENTRY e, *r; \
   e.key = strkey; \
   if(hsearch_r(e, FIND, &r, name)) \
   { \
      value=(int)r->data; \
   } \
   else \
   { \
      value=(int)0; \
   } \
}


Pegando este código en el programa, se pueden usar fácilmente hashtables, como se muestra en el ejemplo:



   HASHTABLE_CREATE(ht, 100);

   HASHTABLE_SET(ht, "e1", 1);
   HASHTABLE_SET(ht, "e2", 2);
   HASHTABLE_SET(ht, "e3", 3);
   HASHTABLE_SET(ht, "e4", 4);
   HASHTABLE_SET(ht, "e5", 5);

   int i;
   HASHTABLE_GET(ht, "e1", i);
   printf("val: %d\n", i);
   HASHTABLE_GET(ht, "e2", i);
   printf("val: %d\n", i);
   HASHTABLE_GET(ht, "e3", i);
   printf("val: %d\n", i);
   HASHTABLE_GET(ht, "e4", i);
   printf("val: %d\n", i);

   HASHTABLE_DESTROY(ht);


Como se ve, el ejemplo es muy sencillo. Primero creamos una estructura con espacio para 100 elementos (caben más, pero habrá colisiones y no será óptimo). Después añadimos elementos, y posteriormente los consultamos. Finalmente, eliminamos la estructura.

A tener en cuenta que HASHTABLE_GET almacena el resultado en "i", lo cual puede confundir un poco al leer el código.

Las macros están hechas para trabajar con valores enteros, pero son fácilmente modificables.






jueves, 26 de enero de 2012

Sockets multiplataforma con GTK+

Recientemente hemos visto como realizar compilación cruzada con GTK+. Esto nos permite escribir aplicaciones que se ejecutan en diferentes plataformas, almenos a nivel gráfico.

Vamos a ver ahora como usar sockets TCP, algo que habitualmente suele estar muy ligado a una plataforma concreta. GTK+ (de hecho es GLIB) nos proporciona una API para acceder a la red. Esta API, al igual que GTK+ es multiplataforma.

Escribiremos un cliente TCP sencillo, que se conectará a un puerto, escribirá un mensaje, y leerá la respuesta.

Primero incluimos las cabeceras habituales en un programa C, junto con las cabeceras de GTK+.

#include <stdio.h>
#include <string.h>
#include <gtk/gtk.h>

Necesitamos las siguientes variables;

GError *err = NULL;
GSocket *sock = NULL;
GInetAddress *iaddr = NULL;
GSocketAddress *saddr = NULL;
GCancellable *cancel = NULL;

Usamos las siguientes funciones para inicializar las variables que contienen las direcciones de red. Lògicamente con la IP y puerto que convenga:

g_type_init();
iaddr = g_inet_address_new_from_string("192.168.1.1");
saddr = g_inet_socket_address_new(iaddr, 23);

Abrimos el socket y nos conectamos a el:

sock = g_socket_new(
   G_SOCKET_FAMILY_IPV4,
   G_SOCKET_TYPE_STREAM,
   G_SOCKET_PROTOCOL_TCP,
   &err);

f(!g_socket_connect(sock, saddr, cancel, &err))
{
   printf("Cannot connect\n");
   return -1;
}

Y finalmente, enviamos y recibimos datos:

   char buf[256];
   strncpy(buf, "lst\n", sizeof(buf));
   g_socket_send(sock, buf, strlen(buf), cancel, &err);
   g_socket_receive(sock, buf, sizeof(buf), cancel, &err);

   printf("received:\n%s\n", buf);


Sencillo, ¿no?


miércoles, 25 de enero de 2012

Sockets TCP con Bash

Es muy habitual, cuando se escriben scripts en Bash, recurrir a herramientas como "netcat" para realizar comunicaciones de red. Sin embargo, aunque no es muy conocido, Bash soporta sockets.

Veamos como conectarnos, por ejemplo, a google.
Abrimos el socket y le asociamos el descriptor 3. Recordemos que 0, 1 y 2 se usan habitualmente para la entrada y salida estándard y para la salida de error.

$ exec 3<>/dev/tcp/www.google.com/80

A continuación, enviamos un mensaje por el socket:

$ echo "GET /" >&3

Y finalmente, leemos la respuesta del servidor:

$ cat <&3

HTTP/1.0 302 Found
Location: http://www.google.es/
Cache-Control: private
Content-Type: text/html; charset=UTF-8
Set-Cookie: PREF=ID=a38d7ed8770f70cb:FF=0:TM=1327418982:LM=1327418982:S=0tgHEV7GxJaC6Wl7; expires=Thu, 23-Jan-2014 15:29:42 GMT; path=/; domain=.google.com
Date: Tue, 24 Jan 2012 15:29:42 GMT
Server: gws
Content-Length: 218
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN
... 


martes, 24 de enero de 2012

Compila en Linux y ejecuta en Windows con GTK+

Vamos a ver como realizar una compilación cruzada con las librerías de GTK+. Esto nos permitirá compilar el programa en Linux y ejecutarlo en Windows, por lo que podremos tener programas funcionando en Windows sin tener que usarlo.

Lo primero que tenemos que hacer es instalar el compilador mingw. En mi distribución vale con:

sudo apt-get install mingw32

A continuación tenemos que descargar las librerías necesarias de windows en nuestro Linux. Podemos encontrarlas en

$ wget http://ftp.gnome.org/pub/gnome/binaries/win32/glib/2.28/glib-dev_2.28.8-1_win32.zip
$ wget http://ftp.gnome.org/pub/gnome/binaries/win32/atk/1.32/atk-dev_1.32.0-2_win32.zip
$ wget http://ftp.gnome.org/pub/gnome/binaries/win32/pango/1.29/pango-dev_1.29.4-1_win32.zip
$ wget http://ftp.gnome.org/pub/gnome/binaries/win32/dependencies/cairo-dev_1.10.2-2_win32.zip
$ wget http://ftp.gnome.org/pub/gnome/binaries/win32/dependencies/libpng-dev_1.4.3-1_win32.zip
$ wget http://ftp.gnome.org/pub/gnome/binaries/win32/dependencies/gettext-runtime-dev_0.18.1.1-2_win32.zip
$ wget http://ftp.gnome.org/pub/gnome/binaries/win32/gtk+/2.24/gtk+-dev_2.24.8-1_win32.zip
$ wget http://ftp.gnome.org/pub/gnome/binaries/win32/dependencies/fontconfig-dev_2.8.0-2_win32.zip
$ wget http://ftp.gnome.org/pub/gnome/binaries/win32/gdk-pixbuf/2.24/gdk-pixbuf-dev_2.24.0-1_win32.zip

Descomprimiremos los zip dentro del directorio donde se instala mingw. Habitualmente:
/usr/i586-mingw32msvc/

Entramos en dicho directorio y realizamos algunos ajustes:

sed -i 's|^prefix=.*$|prefix=/usr/i586-mingw32msvc|g' lib/pkgconfig/*.pc
cd ./lib
for f in *.lib;
   do mv $f lib${f%%lib}a;
done

En mi caso faltaba un archivo en pkgconfig, lo he corregido con:

$ cp /usr/lib/i386-linux-gnu/pkgconfig/freetype2.pc  pkgconfig/

Pero podría estar ubicado en otro sitio en otras distros.

Llegados a este punto ya deberíamos poder compilar tanto para windows como para linux.

Si compilamos con el siguiente comando:

i586-mingw32msvc-gcc main.c `PKG_CONFIG_LIBDIR=/usr/i586-mingw32msvc/lib/pkgconfig PKG_CONFIG_PATH=/usr/i586-mingw32msvc/lib/pkgconfig pkg-config --cflags --libs gtk+-2.0`

generaremos un ejecutable para Windows. En este caso "a.exe".

Y si compilamos con este comando:

gcc main.c `pkg-config --cflags --libs gtk+-2.0 gmodule-export-2.0`

Obtendremos un ejecutable para Linux "a.out". Ya tenemos pues, nuestro sistema de compilación cruzada preparado.

Ya podemos trasladar nuestro ejecutable a Windows y probarlo. Para que funcione es necesario haber instalado GTK+ para Windows.

sábado, 21 de enero de 2012

Esteganografía LSB en imágenes bitmap

Uno de los métodos más populares de Esteganografía consiste en modificar el valor del bit menos significativo de cada píxel, el LSB (Least Significant Bit). En este artículo vemos como hacerlo en imágenes de tipo bitmap, es decir, aquellas que estan estructuradas como matrices de números donde cada número representa un píxel (eso solo es cierto en imágenes en escala de grises. En imágenes en color existen varias representaciones como la RGB donde cada píxel está representado por tres valores, correspondientes a la cantidad de color rojo, la cantidad de color verde y la cantidad de color azul).

El motivo de usar el LSB es que su alteración no sueles ser perceptible visualmente (a menos que la imagen sea muy baja resolución)

Inserción secuencial:

El método más sencillo consiste en separar los bytes que forman el mensaje en bits individuales. A continuación se recorren los píxeles de la imagen modificando su LSB de manera que quede igual que el del mensaje. Supongamos que queremos esconder un mensaje que empieza por 'H'. El valor en binario de la letra 'H' es 1001000. Por lo tanto tendremos que insertar:

1 0 0 1 0 0 0

Imaginemos ahora que los primeros 8 píxeles de la imagen corresponden a los bytes:

100 101 101 102 102 101 103

El primer píxel, correspondiente al valor 100 se representa en binario como 1100100. Dado que tenemos que modificar su LSB y ponerlo a uno, como el primer bit del mensaje, tendremos 1100101, que corresponde al valor de píxel 101. La operación es muy sencilla, si tenemos un valor de píxel par y queremos insertar un cero, no modificaremos el valor del píxel, pero si queremos insertar un uno, le sumaremos uno. Si por el contrario tenemos un píxel impar y queremos insertar un uno, no modificaremos su valor, pero si queremos insertar un cero, le restaremos uno.

Así, el primer byte queda como 101, el segundo como 100, el tercero como 100, etc

101 100 100 103 102 100 102

Para leer el mensaje solo tendremos que extraer los LSB de todos los píxeles.



Inserción aleatoria:

Insertar el mensaje de forma secuencial no es una forma muy acertada de hacerlo. Esto permite al atacante extraer el mensaje, por lo que, si no está cifrado, solo tiene que verificar que es legible (en una imagen sin mensaje oculto no lo sería).

Por este motivo es más aconsejable usar un generador pseudoaleatorio PRNG basado en una clave o contraseña, que eliga aleatoriamente los píxels en los que incrustar datos. De esta manera no bastaría con una simple extracción de todos los LSB.


Reducción del bitrate:

Aún y la enorme dificultad de conseguir el mensaje que ha sido ocultado usando un PRNG (necessitaríamos adivinar la contraseña), el objetivo de la esteganografía es hacer el mensaje indetectable, no indescifrable (de eso se encarga la criptografía). Por ello tenemos que intentar que la distribución estadística de los píxeles de la imagen se vea alterada lo menos posible. Si usamos bitrate 1, es decir, si modificamos todos los píxeles de la imagen, la distribución estadística se verá tan alterada que sermoes detectados sin demasiada dificultad. Por ello es conveniente reducir en la medida de lo posible el bitrate de inserción.

Los ataques existentes en la actualidad a los sistemas LSB son tan sofisticados que detectan alteraciones por encima de bitrates de 0,03. Es decir, que si no queremos ser detectados, deberíamos modificar como mucho el 3% de la imagen y hacerlo de forma aleatoria.



viernes, 20 de enero de 2012

Introducción a Arduino Ethernet: Hello World

Arduino es una plataforma de Hardware abierto cada vez más popular. Permite, de forma sencilla, realizar montajes electrónicos y programarlos. Recientemente ha aparecido en escena Arduino Ethernet, que a diferencia de los anteriores (Arduino Uno y Arduino Duemilanove, entre otros) tiene conexión RJ45 y soporte TCP/IP.



En este post vamos a realizar una breve introducción a Arduino Ethernet, viendo como dar los primeros pasos.

El programador:

A difernecia de los arduinos anteriores, que tenían una conexión USB que permitía cargar el firmware y depurar, el Arduino Ethernet solo tiene la conexión RJ45. Por ello es necesario usar el conector de la foto para programarlo:



Para poder usar este conector es necesario usar un programador. Existen multitud en el mercado. Por ejemplo este de Atmel.

Otra opción más económica consiste en usar el adaptador a USB.

El programa:

El programa más sencillo que se puede hacer con Arduino, y que nos muestre su funcionamiento, es hacer parpadear un led. Concretamente el led 13, que es el único que tiene. Seria el equivalente al típico "Hello World". El programa es el siguiente:

void setup()
{
   pinMode(13, OUTPUT);
}

void loop()
{
   digitalWrite(13, HIGH);
   delay(1000);
   digitalWrite(13, LOW);
   delay(1000);
}

El entorno  de Arduino llama a la función setup() al iniciar. Aprovechamos esta función para configurar el pin 13 como salida. La función loop() es llamada indefinidamente, por lo que en ella ponemos el cuerpo del programa. Lo que hacemos es encender el led, esperar un segundo, apagar el led y esperar de nuevo.

Cargar el firmware:

Una vez tenemos el programa podemos  cargarlo al Arduino de dos formas, en función de si disponemos del adaptador USB o del programador. 

En el primer caso podemos usar el software de Arduino.  Es la forma más sencilla, simplemente escribimos el programa en el entorno de programación y lo cargamos con la opción "Upload". 



Si queremos usar el programador, la forma más sencilla de hacerlo consiste en usar el entorno de programación de Arduino para compilar el programa y el programa avrdude para subir el firmware. Podemos hacerlo con el siguiente comando:

sudo avrdude -c avrispmkII -p m328p -u -U flash:w:firmware.hex -P usb

Donde firmware.hex es el archivo generado por el entorno de programación de Arduino.

Resultados:

Si todo ha funcionado como es debido, veremos como el led de la placa parpadea. Ya tenemos nuestro "Hello World"!


jueves, 19 de enero de 2012

Esteganografía moderna


La primera aparición de la Esteganografía en medios digitales la realizó G. J. Simmons  en 1983 [1]. En el se habla de las posibles implicaciones políticas de enviar datos a través de canales encubiertos y se plantea el problema del prisionero.

El problema del prisionero: 

Alice y Bob son encarcelados en celdas separadas. Pueden comunicarse y quieren planear una fuga, pero sus mensajes son monitorizados por el carcelero Eve. Si Eve descubre que Alice y Bob están intercambiando mensajes secretos no dejará que vuelvan a comunicarse. Por ello, Alice y Bob recurren a la Esteganografía para comunicarse.

En el problema el prisionero hay que destacar que Eve cortará la comunicación si detecta que Alice y Bob se comunican de manera secreta. No es necesario que Eve tenga acceso al mensaje, sólo que lo detecte. Así, un sistema de Esteganografía se considerará roto si puede ser detectada la existencia de un mensaje. No es necesario acceder a su contenido, esto formaría parte del Estegoanálsisis forense (extracción del mensaje) y del criptoanálisis (descifrado del mensaje).


En el problema del prisionero se asume que Eve conoce el algoritmo usado para esconder los datos pero no la clave. Este es un requisito tomado de la Criptografía, que forma parte de los conocidos Principios de Kerchhoff

Referencias: 

[1] G. J. Simmons. The prisoner's problem and the subliminal channel. D. Chaum editor, advances in Criptology, CRYPTO '83, pages 51-67, Santa Barbara, CA, August 22-24, 1983. New York: Plenum Press.

miércoles, 29 de diciembre de 2010

Control del Árbol de Navidad con OpenDomo


Vemos en OpenDomo un video donde se muestra paso a paso como usar el Kit de desarrollo de  OpenDomo para controlar un árbol de Navidad. Aunque serviría para controlar cualquier dispositivo eléctrico.

Os dejo la URL del video.


jueves, 11 de noviembre de 2010

Cryptoland

Cryptograms, puzzles, programming and other challenges.

http://twitter.com/#!/cryptoland

domingo, 13 de junio de 2010

OpenDomo 0.8.3 publicado

La versión 0.8.3 de OpenDomo ha visto la luz recientemente. Para el que todavía no lo sepa, OpenDomo es un sofware de domótica completamente libre, que permite entre otras cosas, controlar dispositivos eléctricos o disponer de un sistema de videovigilancia. Así que si no lo has probado todavía, a qué esperas!!!

A continuación dejo una lista de los cambios más importantes, respecto a la versión anterior.

La distribución incluye:

Además de incluir gran parte de los paquetes habituales, las principales novedades son:

  • Nueva arquitectura de gestión de discos con libata, el nuevo controlador del kernel de linux
  • Múltiples actualizaciones de las herramientas del sistema base, con importantes mejoras de estabilidad
  • Cherokee incluido en el repositorio local, para un mayor rendimiento y seguridad en las conexiones
  • Nuevo formato unificado de configuración, empezando por los archivos network.conf y opendomo.cfg, afectando también a la videovigilancia
  • Scripts de uso común optimizados para un máximo rendimiento en equipos pequeños
  • División por zonas soportada por odvideo y odcontrol, permitiendo configurar las cámaras y dispositivos que se encuentran en cada una de ellas
  • Actualización manual desde ISO soportada, permitiendo una mejor transición entre versiones
  • Interfaz web parcialmente reescrita incorporando funciones complementarias en Javascript. Scripts de configuración de la interfaz integrados y temas visuales renovados. Caché habilitada, reduciendo en un 20% la transferencia por HTTP
  • Posibilidad de almacenar librerías y archivos log en disco, permitiendo la instalación de paquetes de gran tamaño sin riesgo de agotar el ramdrive
  • Mejoras en la gestión de almacenaje, permitiendo el arranque desde CD/ISO, almacenando la configuración en disco

jueves, 10 de junio de 2010

Acceso 'tipo BSD' al histórico de Bash


Una cosa que siempre añoré de la shell de los sistemas BSD es la posiblidad de recorrer el histórico de comandos que empiezan con los caracteres tecleados en consola. En ocasiones mucho más práctico que el Ctrl+R habitual de Bash.

Pues bien, ahora puedo tenerlos los dos :)

Solo es necesario añadir a /etc/inputrc estas dos lineas.

"\e[5~": history-search-backward
"\e[6~": history-search-forward


Lo que le dará a Bash esta interesante funcionalidad con las teclas RePag y AvPag.



domingo, 30 de mayo de 2010

Criptograma 30/05/010


CSQSQ TLTDR UTOHT CRVHP WYETU SWSHT RYSHP

LETYT OSVSW RHHPW YETRE LTOCT PVHCT PVXXX


viernes, 19 de febrero de 2010

Criptograma 19/02/10

Después de algun tiempo de descanso, vamos con uno de facilito:

 LDDOF ENADR AOCSL ASSGX APENU GZLEO DDYEL CAAAR HALSE AATMU
 INAOA LMTIA URAUR DRAIC NEDLH ASORM MTNSZ OLSSH AIAOO AACEO

jueves, 31 de diciembre de 2009

Criptograma 30/07/09: Solución

Viendo que acaba el año y el criptograma continúa inexpugnable, aquí os dejo la solución.

CIFRADO:
BPJTALUJBPUPRFBIISASIYRTJTMSAKGMCPCRRPPBALC
AAKTPSOCUPFAPKIFKRNOPRSKABPUPSMDFSOKETCPFCP

CLAVE:
CRISIS

MENSAJE:
EN LOS MOMENTOS DE CRISIS SOLO LA IMAGINACION
ES MAS IMPORTANTE QUE EL CONOCIMIENTO
ALBERT EINSTEIN


Aprovecho para desearos un feliz comienzo de año!

domingo, 25 de octubre de 2009

Criptograma 30/07/09: Pista

Dado que se resiste, y ni el increible Altair consigue dar con la solución, ahí va una pista.

Se trata de un cifrado Playfair.

Criptograma 30/07/09

Criptograma 16/07/09: Solución

Cada par de letras del criptograma correspondía a una letra del mensaje en claro. Tomando esto como hipótesis se podía recurrir a un análisis de frecuencias tradicional.

Enhorabuena Altair.

HO LA BU HO DE MI MA HO LA SI TU MA
E S M E J O R E S T A R

CE TU NA NA TU BI MI CI RU TU MA HO
C A L L A D O Y P A R E

CE HO MA SI MI RU SI MI RE FA HO DO
C E R T O N T O Q U E H

TU BL NA TU MA CI BI HO LA RU HO SS
A B L A R Y D E S P E J

TU MA NA TU LA BI FA BI TU LA BI HO
A R L A S D U D A S D E

GR UX RU UX SI UX GU TU BU HO RU SI
F I N I T I V A M E N T

HO RR MA MI FA YY MI BU TU MA YY
E G R O U X O M A R X

viernes, 4 de septiembre de 2009

ssh en batch sin expect

Ssh y scp no permiten pasar la contraseña como parámetro, lo que complica las cosas a la hora de automatizar tareas. Normalmente se suele recurrir a dos tipos de soluciones: distribuir claves sin password y/o usar expect. La primera no siempre es posible, pues a veces no se tiene el control del servidor. La segunda es más habitual, aunque en ocasiones no se dispone de 'expect', problema con el que me he encontrado recientemente en el proyecto OpenDomo.

 
Como consecuencia he desarrollado la herramienta sshbatch, que permite realizar comandos ssh y scp pasando la passwd como parámetro.

 
Dejo aquí una copia del programa en C y un enlace al grupo de OpenDomo donde expliqué como funciona.


 

domingo, 16 de agosto de 2009

Cómo funciona el exploit sock_sendpage()

 
Tavis Ormandy y Julien Tinnes, del equipo de seguridad de Google, han descubierto un bug en el kernel Linux que nadie ha sido capaz de ver en los últimos ocho años. Este bug, que afecta a todas las versiones del kernel desde la 2.4.4 a la 2.4.37.4 y desde la 2.6.0 a la 2.6.30.4 permite escalar privilegios en el sistema. En este artículo vamos a analizar su funcionamiento.


Primer error:
Todo comienza en la función sock_sendpage() situada en net/socket.c. El problema reside en la llamada a sendpage() pues no se ha verificado que el puntero esté inicializado.


static ssize_t sock_sendpage(struct file *file, struct page *page,
              int offset, size_t size, loff_t *ppos, int more)
{
   struct socket *sock;
   int flags;

   sock = file->private_data;

   flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
   if (more)
      flags |= MSG_MORE;

   return sock->ops->sendpage(sock, page, offset, size, flags);
}


A continuación, dejo una copia de la función sock_splice_read() que no tiene nada que ver ni con el bug ni con el exploit, pero nos sirve para ver como se podría haber evitado la vulnerabilidad.  En esta función se verifica el puntero a la función mediante unlikely() antes su llamada.


static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
                 struct pipe_inode_info *pipe, size_t len,
            unsigned int flags)
{
   struct socket *sock = file->private_data;

   if (unlikely(!sock->ops->splice_read))
      return -EINVAL;

   return sock->ops->splice_read(sock, ppos, pipe, len, flags);
}


Segundo error:
Hemos visto que no se verifica si el puntero a sendpage() esta correctamente inicializado. Sera necesario ahora, encontrar situaciones en las que el puntero a la función sendpage() no se haya inicialiado.

Tavis Ormandy y Julien Tinnes en su investigación localizaron deficiencias en la incialización del puntero para la macro SOCKOPS_WRAP, definida en include/linux/net.h, que incluye PF_APPLETALK, PF_IPX, PF_IRDA, PF_X25 y PF_AX25. Tambien encontraron deficiencias en otros protocolos  como  PF_BLUETOOTH, PF_IUCV, PF_INET6 (con IPPROTO_SCTP), PF_PPPOX y PF_ISDN.


Veamos por ejemplo el caso del protocolo bluetooth. En net/bluetooth/bnep/sock.c nos encontramos con la estructura bnet_sock_ops en la que vemos que no se inicializa sendpage con sock_no_sendpage(), por lo que quedará apuntando a NULL.

static const struct proto_ops bnep_sock_ops = { 
        .family         = PF_BLUETOOTH,
        .owner          = THIS_MODULE,
        .release        = bnep_sock_release,
        .ioctl          = bnep_sock_ioctl,
#ifdef CONFIG_COMPAT
        .compat_ioctl   = bnep_sock_compat_ioctl,
#endif
        .bind           = sock_no_bind,
        .getname        = sock_no_getname,
        .sendmsg        = sock_no_sendmsg,
        .recvmsg        = sock_no_recvmsg,
        .poll           = sock_no_poll,
        .listen         = sock_no_listen,
        .shutdown       = sock_no_shutdown,
        .setsockopt     = sock_no_setsockopt,
        .getsockopt     = sock_no_getsockopt,
        .connect        = sock_no_connect,
        .socketpair     = sock_no_socketpair,
        .accept         = sock_no_accept,
        .mmap           = sock_no_mmap
};



El caso de SOCKOPS_WRAP es mas sutil, pues en net/ipx/af_ipx.c todo parece correcto. Podemos ver la inicialización en la última linea.


static const struct proto_ops SOCKOPS_WRAPPED(ipx_dgram_ops) = {
        .family         = PF_IPX,
        .owner          = THIS_MODULE,
        .release        = ipx_release,
        .bind           = ipx_bind,
        .connect        = ipx_connect,
        .socketpair     = sock_no_socketpair,
        .accept         = sock_no_accept,
        .getname        = ipx_getname,
        .poll           = datagram_poll,
        .ioctl          = ipx_ioctl,
#ifdef CONFIG_COMPAT
        .compat_ioctl   = ipx_compat_ioctl,
#endif
        .listen         = sock_no_listen,
        .shutdown       = sock_no_shutdown, /* FIXME: support shutdown */
        .setsockopt     = ipx_setsockopt,
        .getsockopt     = ipx_getsockopt,
        .sendmsg        = ipx_sendmsg,
        .recvmsg        = ipx_recvmsg,
        .mmap           = sock_no_mmap,
        .sendpage       = sock_no_sendpage,
};


Sin embargo, si estudiamos con detenimiento la macro SOCKOPS_WRAP en include/linux/net.h vemos que mietras otras llamadas se inicializan correctamente, no se realiza la inicialización de sendpage.
No pego el código por que es demasiado largo, consultar en include/linux/net.h y ver que la última inicialización es la de mmap(), olvidando sendpage().



Cómo explotarlo?
Lo primero que necesitaremos para explotar esta vulnerabilidad es una función que podamos ejecutar en espacio de usuario que use sock_sendpage(). Hay muchas funciones que lo hacen, una de ellas es sendfile().



Tavis Ormandy y Julien Tinnes y proponen como secuencia válida de llamadas para forzar el uso de sendpage(), la siguiente:

/* ... */
int fdin = mkstemp(template);
int fdout = socket(PF_PPPOX, SOCK_DGRAM, 0);

unlink(template);

ftruncate(fdin, PAGE_SIZE);

sendfile(fdout, fdin, NULL, PAGE_SIZE);
/* ... */



Cuando se ejecute la función sendpage(), si esta no está inicializada y apunta a NULL, el kernel intentará ejecutar las instrucciones que hay en la dirección 0. Podemos aprovechar esto mapeando la dirección 0 y almacenando allí las instrucciones que queremos que ejecute el kernel. Así, cuando se intente ejecutar sendpage() realmente se ejecutará nuestro código en espacio de kernel. Podremos escalar privilegios haciendo que el código almecando en la dirección 0 ponga nuestros uid a cero (root).

Este tipo de bugs son muy comunes en el kernel Linux y se conocen como bugs por 'NULL pointer dereference'. Ya vimos aquí uno de estos con el exploit vmsplice.


En las referencias dejo un ejemplo de exploit.




referencias:
- http://www.securityfocus.com/archive/1/505751
- http://blog.cr0.org/2009/08/linux-null-pointer-dereference-due-to.html
- exploit: http://www.frasunek.com/proto_ops.tgz

 

miércoles, 5 de agosto de 2009

Criptograma Principiantes 05/08/09


RJ BZR KWPSJHLMHZR CJMJLRLG LAJVJMJZR AL BK NJRNK VZWNK LG PSL BZR UWZOWKNKAZWLR LRMWJTLG UWZOWKNKR, LB UWJNLW UKQKWZ MKWUJGHLWZ PSL UKRKRL UZW KPSJ ALRHWSJWJK BK MJXJBJFKMJZG.

OLWKBA ILJNTLWO

jueves, 30 de julio de 2009

Criptograma 30/07/09

BPJTALUJBPUPRFBIISASIYRTJTMSAKGMCPCRRPPBALC
AAKTPSOCUPFAPKIFKRNOPRSKABPUPSMDFSOKETCPFCP