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);
}

}

}