Cracking biciambiental

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

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

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

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

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

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

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

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

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

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

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

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

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

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!