Uso de Streaming Library para aplicaciones en I2P

Se ha hablado en varias ocasiones sobre los beneficios que aporta I2P al anonimato y en alguna ocasión se ha hablado sobre cómo crear rutinas simples que permitan acceder a I2P utilizando la librería “Streming Library”, la cual se encuentra escrita en Java. Si quieres hacer cualquier tipo de prueba con Python contra I2P, actualmente hay pocas librerías que realmente te lo permitan y que sean estables. Por lo que he podido apreciar en los foros oficiales de desarrolladores, al parecer las personas clave en el desarrollo de plugins, utilidades y el propio core de la red no muestran mucho interés en desarrollar otra librería en un lenguaje distinto para hacer lo que sobradamente ya hace la Streaming Library y francamente tienen toda la razón del mundo, ya que tienen un “roadmap” con cientos de frentes abiertos y es mucho más interesante crear cosas nuevas y mejorar las existentes que reinventar la rueda. Al equipo de I2P le ha costado muchísimo desarrollar la Streaming Library y la cantidad de errores que se reportaban al principio era enorme, es normal que después del número de horas invertidas y el nivel de estabilidad en el que se encuentra ahora, haya sido declarada como la librería de referencia para crear aplicaciones que requieran el uso del protocolo de control de I2P (I2CP) sobre TCP. No obstante, seguimos con los mismos problemas:

1. Aun sigue siendo poca, muy poca la documentación sobre su uso. Si realmente quieres aprender los elementos clave de la librería, tienes que meterte en los JavaDocs y empezar a crear un mapa mental de como están relacionadas las clases y cómo puedes usarlas.

2. Si eres un desarrollador en Python o tienes alguna herramienta para acceder a la web profunda de I2P aunque sea para consultar “Destinations”. Bueno, lo tienes un poco complicado por lo que comentaba antes. Aunque existe el proyecto python-i2cp (https://github.com/majestrate/python-i2cp) para utilizar directamente el protocolo interno de I2P, pero no avanza al ritmo que se esperaría y aun no funciona correctamente a la hora de consultar un destination. Además, utilizar directamente I2CP está desaconsejado por el equipo de I2P. Nos queda utilizar Jython o la JSR de Java correspondiente para ejecutar código de scripting con Python desde la máquina virtual de Java.

Es este artículo intentaré centrarme en el primer punto y explicaré algunas características interesantes en Streaming library para Java y en un próximo articulo, intentaré explicar algunas alternativas a la hora de acceder a I2P desde Python.

No en todos los casos resulta viable utilizar la Streaming Library de I2P, pero por norma general, cuando se habla de aplicaciones punto a punto, como es el caso de descargas de torrents y cosas similares, resulta bastante conveniente y óptimo utilizar esta librería, de hecho, un ejemplo bastante claro lo tenemos con el proyecto I2PSnark, un cliente bittorrent que utiliza la Streaming Library para descargar y compartir torrents utilizando la red de I2P. El código fuente del proyecto se encuentra licenciado con la GNU/GPL y se está disponible en el siguiente repositorio GitHub: https://github.com/i2p/i2p.i2p/tree/master/apps/i2psnark Si se mira con atención las clases y métodos que se incluyen en el proyecto, es mucho más fácil comprender el funcionamiento de la Streaming Library y cómo utilizarla.

En primer lugar, cualquier rutina de código utilizando esta librería puede funcionar en uno de dos modos, o bien como cliente que consulta “destinations” (un destino en I2P es similar a la combinación de una dirección IP y un puerto) o simplemente como servidor. Las principales clases disponibles en la API son “wrappers” de las clases SocketServer y Socket de Java, aunque evidentemente las clases en la Streaming Library adicionan las funcionalidades necesarias para que todas las conexiones se lleven a cabo utilizando la red de I2P.
Por otro lado, en una instancia de I2P, un programa escrito en Java y utilizando la Streaming Library puede actuar como emisor o receptor (recordar que I2P es una red que basada en paquetes y no en circuitos como TOR), con lo cual desde un programa se puede generar el “destination” para que otros usuarios envíen paquetes a la instancia o se pueden buscar (lookup) destinos y enviarles paquetes. El siguiente código sería la clase más simple que se puede crear utilizando la Streaming Library para crear un emisor.

[sourcecode language=»java»] import net.i2p.client.streaming.I2PSocket; import net.i2p.client.I2PSession; import net.i2p.client.streaming.I2PServerSocket; import net.i2p.client.streaming.I2PSocketManager; import net.i2p.client.streaming.I2PSocketManagerFactory; public class Server { public static void main(String[] args) { I2PSocketManager manager = I2PSocketManagerFactory.createManager(); I2PServerSocket serverSocket = manager.getServerSocket(); I2PSession session = manager.getSession(); System.out.println(session.getMyDestination().toBase64()); } } [/sourcecode]

Como se puede apreciar, se crea una instancia de la clase “I2PSocketManager” utilizando la factoría “I2PSocketManagerFactory” y posteriormente se crea un objeto “I2PServerSocket”, el cual será utilizado para atender a las peticiones de otros usuarios en la red de I2P. Finalmente, se pinta por pantalla el destination local del proceso recién iniciado. La clase “net.i2p.data.Destination” cuenta con los métodos “toBase64” y “toBase32” que serán utilizados por el cliente para comunicarse con la instancia de I2P.

El código anterior solamente se encarga de obtener una sesión I2P y pintar por pantalla el destination generado, pero una vez hecho esto, el hilo principal del programa termina. Las siguientes instrucciones que se deben añadir, deben permitir que el proceso se quede en estado de escucha para procesar los mensajes que envían los clientes, para ello la clase I2PThread permite crear un hilo de ejecución ininterrumpido que permitirá al emisor actuar como servidor y recibir mensajes.

[sourcecode language=»java»] import net.i2p.client.I2PSession; import net.i2p.client.streaming.I2PServerSocket; import net.i2p.client.streaming.I2PSocketManager; import net.i2p.client.streaming.I2PSocketManagerFactory; import net.i2p.util.I2PThread; public class Server { public static void main(String[] args) { I2PSocketManager manager = I2PSocketManagerFactory.createManager(); I2PServerSocket serverSocket = manager.getServerSocket(); I2PSession session = manager.getSession(); System.out.println(session.getMyDestination().toBase64()); I2PThread thread = new I2PThread(new ClientHandler(serverSocket)); thread.setDaemon(false); thread.start(); } private static class ClientHandler implements Runnable { private I2PServerSocket socket; public ClientHandler(I2PServerSocket socket) { this.socket = socket; } public void run() { while(true) { //Procesar las conexiones de los clientes. } } } } [/sourcecode]

En este caso se crea una nueva clase que procesará los mensajes de los clientes de forma indefinida en un bucle “while true”. En dicho bucle se aceptarán las conexiones de los clientes por I2P y posteriormente, se realizará algún tipo de procesamiento, el cual, típicamente consiste en recibir las conexiones por parte de los clientes y responder a los mensajes.

[sourcecode language=»java»] while(true) { try { I2PSocket sock = this.socket.accept(); if(sock != null) { //Receive BufferedReader br = new BufferedReader(new InputStreamReader(sock.getInputStream())); //Send BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(sock.getOutputStream())); String line = br.readLine(); if(line != null) { System.out.println(line); bw.write(line); bw.flush(); } sock.close(); } } catch (I2PException ex) { System.out.println("General I2P exception!"); } catch (ConnectException ex) { System.out.println("Error connecting!"); } catch (SocketTimeoutException ex) { System.out.println("Timeout!"); } catch (IOException ex) { System.out.println("read/write-exception!"); } } [/sourcecode]

Por otro lado, el cliente debe conocer cuál es la dirección (destination) del emisor para poder transmitirle un mensaje y recibir su respuesta. El código necesario en la parte del cliente es mucho más simple, ya que solamente requiere utilizar la clase I2PSocket y conectarse con el destination especificado.

[sourcecode language=»java»] package testing.i2p; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.InterruptedIOException; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.net.ConnectException; import java.net.NoRouteToHostException; import net.i2p.I2PException; import net.i2p.client.streaming.I2PSocket; import net.i2p.client.streaming.I2PSocketManager; import net.i2p.client.streaming.I2PSocketManagerFactory; import net.i2p.data.DataFormatException; import net.i2p.data.Destination; public class Client { public static void main(String[] args) { I2PSocketManager manager = I2PSocketManagerFactory.createManager(); System.out.println("Destination:"); BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String destinationString; try { destinationString = br.readLine(); } catch (IOException ex) { System.out.println("Failed to get the Destination."); return; } Destination destination; try { destination = new Destination(destinationString); } catch (DataFormatException ex) { System.out.println("Destination string incorrectly formatted."); return; } I2PSocket socket; try { socket = manager.connect(destination); } catch (I2PException ex) { System.out.println("General I2P exception occurred!"); return; } catch (ConnectException ex) { System.out.println("Failed to connect!"); return; } catch (NoRouteToHostException ex) { System.out.println("Couldn’t find host!"); return; } catch (InterruptedIOException ex) { System.out.println("Sending/receiving was interrupted!"); return; } try { //Write to server BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); bw.write("Hello I2P!\n"); BufferedReader br2 = new BufferedReader(new InputStreamReader(socket.getInputStream())); String s = null; while ((s = br2.readLine()) != null) { System.out.println("Received from server: " + s); } socket.close(); } catch (IOException ex) { System.out.println("Error occurred while sending/receiving!"); } } } [/sourcecode]

El código anterior es la base para crear cosas mucho más elaboradas, por ejemplo, en lugar de utilizar las clases BufferedReader y BufferedWriter se podría utilizar clases como ObjectInputStream y ObjectOutputStream que permiten enviar objetos serializados (aquellos que extienden de la interfaz java.io.Serializable) y de esta forma, construir aplicaciones muy robustas al interior de I2P. Por otro lado, también se puede utilizar para crear plugins que se puedan desplegar directamente desde la consola de administración de I2P. Sobre estas cosas hablaré en un próximo articulo.

Saludos y Happy Hack!
Adastra.