Archivo

Posts Tagged ‘i2p clientes’

Uso de Streaming Library para aplicaciones en I2P

mayo 6, 2015 2 comentarios

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.

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

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.

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.
                        }
                }
	}
}

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.

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

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.

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

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.

Preservando el Anonimato y Extendiendo su Uso – Arquitectura y Protocolos utilizados en I2P – Parte XXVIII

diciembre 12, 2011 1 comentario

Hasta este punto se ha hablado de una forma extensa sobre la arquitectura del I2P y la capa de aplicación resaltando los principales clientes y plugins que pueden ser instalados en una instancia I2P, se ha hablado sobre los detalles funcionales de I2P y como los mensajes son transferidos entre emisores y receptores, no obstante no se ha profundizado sobre los protocolos y las distintas capas que soportan todo esto para que la comunicación anónima entre dos entidades sea posible, la pila de protocolos que se soportan en I2P están agrupados por capas complejas que extienden de forma significativa el modelo de referencia estándar OSI para comunicaciones en entornos de red. En realidad esta es una de las razones por las cuales I2P es también considerado un proyecto con un alto nivel académico y técnico que para muchos resulta interesante y sumamente practico. Para explicar a grandes rasgos la arquitectura de red de I2P y con el objetivo de que sea fácil de comprender para el lector (y a la vez con un buen nivel de contenido técnico), se comenzará por indicar cada uno de los elementos de la pila de protocolos de I2P desde su capa más alta (aplicación) hasta las capas más bajas (transporte).

Leer más…

Preservando el Anonimato y Extendiendo su Uso – Servicios Anonimos, Plugins en I2P – Parte XXVII

diciembre 9, 2011 1 comentario

En I2P existen módulos adicionales que se pueden instalar en una instancia I2P en ejecución, los cuales permiten extender las funcionalidades que vienen incluidas en el sistema. Uno de los principales enfoques de estos Plugins son la seguridad de los mismos, dado que podría perfectamente ser un vector de ataque valido contra usuarios que los utilicen, por esta razón el equipo de desarrollo de este proyecto, antes de hacer publico cualquier plugin, primero realiza una comprobación sobre el código y obliga a que cualquier desarrollador firme digitalmente sus desarrollos antes de subirlos al repositorio de plugins de I2P.

Leer más…

Preservando el Anonimato y Extendiendo su Uso – Servicios Anonimos, EEPSITES y SSH en I2P – Parte XXVI

diciembre 7, 2011 3 comentarios

EEPSITES EN I2P

Una de las características que más llaman la atención en I2P es la capacidad de publicar diferentes tipos de servicios de forma anónima en la red de I2P, de tal forma que estos puedan ser consultados por cualquier cliente que se encuentre navegando en la red de I2P. Estos servicios publicados son equivalentes a los Hidden Services que se exponen en TOR, sin embargo, los Servicios que se pueden exponer en I2P son mucho más rápidos y de fácil acceso en comparación con los Hidden Services en TOR sin sacrificar características tan importantes como la seguridad y desde luego el anonimato. Como se ha explicado anteriormente, cada instancia de I2P viene con un sitio web configurado por defecto (cada sitio web es llamado en el mundo de I2P como un eepsite), este eepsite se ejecuta en un servidor web Jetty que permitirá ejecutar aplicaciones web basadas en Java, soportando tecnologías tales como Servlets y JSP, la ubicación por defecto de dicho eepsite esta determinada por el mecanismo de instalación de I2P, si se ha instalado en modo “PORTABLE” la ruta de dicho eepsite se encuentra el directorio especificado como portable, en el caso contrario la ubicación será ~/.i2p/eepsite.

Leer más…

Preservando el Anonimato y Extendiendo su Uso – Administración de I2P, Utilizando I2PTunnel, SusiDNS y comprendiendo el sistema de nombrado de I2P – Parte XXV

diciembre 5, 2011 4 comentarios

Utilizando I2PTunnel

En la entrada anterior ya se han mencionado las características que soporta esta herramienta y lo importante que es para I2P. Para utilizarla, es necesario iniciar la instancia de I2P con el comando

./i2prouter start

Y desde el navegador web dirigirse a http://127.0.0.1:7657/i2ptunnel/ o desde la interfaz de administración principal ubicada en http://127.0.0.1:7657/ ir a la opción “I2P Internals → I2PTunnel”. En la interfaz de I2PTunnel, aparecerán 3 secciones distintas, la primera enseña los mensajes de estatus, la segunda Túneles I2P de Servidor y la tercera Túneles de cliente, cada sección contiene botones que permiten administrar el estado de los servicios (iniciar, detener, reiniciar). En la instalación por defecto esta interfaz contiene las siguientes opciones:

Leer más…

Preservando el Anonimato y Extendiendo su Uso – Administración de I2P, aplicaciones y servicios incluidos – Parte XXIV

diciembre 2, 2011 1 comentario

Una vez que se ha instalado correctamente I2P, la herramienta principal para administrar todas las conexiones, túneles, aplicaciones, proxies, servicios, etc. Es la interfaz administrativa conocida como “I2P Router Console” esta consola de administración es una interfaz web que puede ser accedida desde cualquier navegador web, normalmente se inicia en el puerto “7657” y desde allí se cuenta con un menú bastante completo con todas las opciones disponibles en I2P, las cuales son:

Leer más…

A %d blogueros les gusta esto: