P2P--bittorent, eD2K, Gnutella...

Introduzione

Il peer-to-peer(P2P) è da tempo diventato il modo preferenziale di scambio file in rete; Ci sono ormai diversi protocolli, software e tecnologie per sfruttare le connessioni degli utenti.

Una rete P2P si basa appunto sul concetto di assenza di un server centrale: ossia ogni nodo della rete comunica con gli altri con connessioni dirette (nodo-nodo). Come vedremo fra un po' non tutte le implementazioni seguono fedelmente questo concetto-principio.

L' FTP nacque per lo scambio ottimizzato di grosse quantità di dati:

1. un server conforme al protocollo FTP mette a disposizione una serie di file
2. un client FTP si connette al suddetto server e richiede il download di uno di questi file
3. viene instaurata una connessione su un canale dati dedicato (differente dal canale di controllo ove il client e server si mettono d'accordo su come mandare i dati richiesti, e in genere ove si impartiscono comandi come GET... etc.) ove transitano i dati richiesti

I tre passi succitati si ripetono per ogni client FTP connesso, quindi il server deve disporre di banda(KB/s) sufficiente per distribuire i suoi file a tutti gli utilizzatori (client FTP) che lo richiedono.

Nelle reti P2P il concetto di client e server viene sostituito da quello di peer : Rifacendoci nel caso FTP immaginiamo se ogni client che scarica il file a sua volta potesse funzionare anche da server e rendesse disponibile per il download il file stesso. Automatizzando il meccanismo in modo che si possa scaricare il file da uno qualsiasi dei nodi, che funzionano sia da client che da server, avremo qualcosa di molto simile sd una delle tecnologie P2P più in voga oggi , Bittorent. Cosi facendo però ogni peer potrebbe fungere da server solo dopo aver scaricato l' intero file oggetto del download. Per risolvere tale situazione (ossia far si che il peer funga da server il prima possibile aumentando cosi l' efficienza dell' intera rete P2P) i client P2P suddividono i file da distribuire in parti più piccole (64KB-1MB). In tal modo queste parti possono essere scaricate più in fretta (rispetto all' intero file) e di conseguenza i peer possono più in fretta fungere come server e condividere immediatamente il frammento di file scaricato, senza dover aspettare di aver di aver scaricato il file originale per intero. Inoltre è possibile scaricare parti diverse di uno stesso file da nodi differenti, quindi nel caso più frequentemente incontrato oggi(collegamenti ADSL) in cui disponiamo di una banda download parecchio superiore a quella upload, possiamo contattare tanti peer fino a scaricare al massimo della velocità download possibile dal nostro collegamento. Per ciò che riguarda l' integrità dei frammenti scaricati si tiene traccia dei checksum degli stessi in modo da poter stabilire senza nessun dubbio che quanto scaricato è conforme all' originale oppure si è corrotto per diversi motivi.

Architetture di reti P2P

Poco fa abbiamo accennato che non tutte le reti P2P (quindi senza nessun tipo di server o serverless) seguono il modello serverless. tra le reti P2P pure possiamo citare ad esempio Gnutella e Freenet ma esistono anche molte reti P2P ibride che sfruttano un qualche server centrale come ad esempio Bittorrent e eDonkey2000 (eD2k) (quest' ultima rete identificata col suo famoso client eMule)


eD2k è la rete P2P che più si avvicina al classico modello client-server (sebbene questo stia cambiando ultimamente come vedremo). Si basa su una serie di server che mantengono una lista dei client e dei file posseduti da ogni client, fungendo in tal modo da "mediatori" fra i client e ancora da punto focale per le ricerche. I client contattano i server per eseguire le ricerche, ma lo scambio di file avviene esclusivamente fra i client.


Bittorent funziona in modo abbastanza diverso. L' elemento fondamentale qui è il file .torrent che contiene una serie di informazioni, fra le quali ci sono quelle relative ai chunk (frammenti) in cui è stato suddiviso il downlad e l' indirizzo del tracker che è un nodo particolare che contiene una lista dei peer che dispongono dei chunk di un determinato file (che condividono). In genere i file .torrent si rendono a disposizione via web, ad esempio sui siti delle varie disto Linux. Tali file di pochi KB si scaricano tramite HTTP(col browser).

1. Chi mette a disposizione il file .torrent la maggior parte delle volte funge anche da seed cioè da sorgente primaria(disponendo inizialmente solo lui la totalità dei frammenti del file [.iso, .zip, .txt etc.] da condividere).
2. Tutti i peer interessati al file scaricano in modo casuale il primo chunk (frammento), e successivamente scelgono in base ad un algoritmo (che premia la rarità del chunk da scaricare) i frammenti del file che gli mancano per completare il download dell' intero file.

   Perche' viene premiata la rarità? Se un certo chunk esiste su un solo nodo(e questo chunk che l'algoritmo decide sia "raro") , qualora tale nodo andasse offline nessun altro nodo dello swarm riuscirebbe a ricostruire l' intero file.

   In luce di tutto ciò si evince che se ogni frammento fosse presente su più nodi in contemporanea, la banda aggregata per il download aumenterebbe considerevolmente. Quando un peer finisce di scaricare tutti i frammenti di un file, diventa automaticamente a sua volta un seed
   

Gnutella invece è una rete P2P cosidetta "pura" cioè non dispone di un sistema (server) centrale, ogni nodo e' a se stante e funge anche da server per le ricerche. Quando avviamo un client Gnutella esso

1. si connette ad un insieme di nodi gia noti(o eventualmente forniti dal utente)
2. Per effettuare una ricerca la query(richiesta) viene inviata a tutti i nodi con cui il client Gnutella è in contatto inizialmente.
3. Ogni nodo poi verifica se dispone del file richiesto e se no reinoltra a sua volta la richiesta ai propri contatti iniziali. tutto ciò si ripete fino a 6-7 livelli di profondità. Facendo un esempio se il nostro client Gnutella ha 4 contatti iniziali e supponendo che ognuno di essei abbia a sua volta altri 4 contatti iniziali dopo 6 livelli di profondità di inolto si arriva a contattare più di 4000 peer.

Questo schema ha degli svantaggi e dei vantaggi:

Pro Da una parte è molto resistente ad atacchi mirati a rendere inaccessibile la rete dato che non c'è un' entita centralizzata(server) vera e propria a cui tutti i nodi fanno riferimento

Contro Dall' altra il traffico di rete dedicato all' inoltro delle ricerche spesso è molto ingente

Dopo la pressione da parte delle Major dell' industria Cine-audio che ha portato alla chiusura dei più importanti server della rete eD2K si è portati a introdurre nelle versioni più recenti del protocollo(e dei rispetivi client ) della possibilità di sfruttare una rete P2P "pura" di seconda generazione Kademlia che di basa su DHT (che è un miglioramento del modello P2P di Gnutella che permette di ridurre notevolmente il traffico di rete dedicato alle ricerche).
Gli stessi timori hanno portato all' introduzione delle DHT anche su bittorrent tramite particolari torrent chiamati trackerless

Software(clients) P2P

Causa l' elevato numero di protocolli e dei rispettivi clients qui ci concentriamo sui più usati attualmente ossia sulle reti Bittorent eD2k e Gnutella


aMULE
In linux il client che meglio ricalca eMule(che è disponibile sol oper Windows) è aMule. Per poterlo installare se si dispone di Ubuntu da shell diamo:

$ sudo apt-get update
sudo apt-get install amule

Si tratta di pacchetti presenti in quasi tutti i repository ufficiali delle distro. Terminata l' installazione troviamo aMule sotto Applications>internet.

• Una volta avviato il programma dobbiamo inserire l' elenco dei server a cui collegarsi: l' aggiornamento della lista dei server è banale, basta inserire un url che punta a un file .met che contiene l' elenco dei server a cui aMule puo collegarsi. Questi file .met si trovano sul sito di eMule o da Google inserendo come chiave di ricerca emule server met

• Adesso scarichiamo l' elenco dei server mettendo nella sezione Server della schermata Network l' url succitato e cliccando sulla freccia di fianco. Se conosciamo altri server possiamo aggiungerli a mano nella sezione Manual server add

• Una volta connesi si devono sbloccare le porte del firewall per permettere connessioni dai peer (da Internet) verso il nostro aMule. Se non si aprono le porte si verrà marcati con un low ID che indica una bassa capacità di condivisione da parte nostra e ci verrà assegnata una priorità più bassa nelle code di download. Per verificare se il firewall è disattivato diamo:
  

  $ sudo iptables -L -n

  se le connessioni sono impostate tutte su ACCEPT significa che il firewall è disttivato e lascia passare tutto.In Ubuntu l' output del suddetto comando è:

  harrykar@harrysas:~$ sudo iptables -L -n
  [sudo] password for harrykar:
  Chain INPUT (policy DROP)
  target     prot opt source               destination 
  ACCEPT     tcp  --  192.168.1.1          0.0.0.0/0           tcp flags:!0x17/0x02
  ACCEPT     udp  --  192.168.1.1          0.0.0.0/0   
  ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0   
  ACCEPT     icmp --  0.0.0.0/0            0.0.0.0/0           limit: avg 10/sec burst 5
  DROP       all  --  0.0.0.0/0            255.255.255.255
  DROP       all  --  0.0.0.0/0            192.168.1.255
  DROP       all  --  224.0.0.0/8          0.0.0.0/0   
  DROP       all  --  0.0.0.0/0            224.0.0.0/8 
  DROP       all  --  255.255.255.255      0.0.0.0/0   
  DROP       all  --  0.0.0.0/0            0.0.0.0     
  DROP       all  --  0.0.0.0/0            0.0.0.0/0           state INVALID
  LSI        all  -f  0.0.0.0/0            0.0.0.0/0           limit: avg 10/min burst 5
  INBOUND    all  --  0.0.0.0/0            0.0.0.0/0   
  LOG_FILTER  all  --  0.0.0.0/0            0.0.0.0/0   
  LOG        all  --  0.0.0.0/0            0.0.0.0/0           LOG flags 0 level 6 prefix `Unknown Input'
  
  Chain FORWARD (policy DROP)
  target     prot opt source               destination 
  ACCEPT     icmp --  0.0.0.0/0            0.0.0.0/0           limit: avg 10/sec burst 5
  LOG_FILTER  all  --  0.0.0.0/0            0.0.0.0/0   
  LOG        all  --  0.0.0.0/0            0.0.0.0/0           LOG flags 0 level 6 prefix `Unknown Forward'
  
  Chain OUTPUT (policy DROP)
  target     prot opt source               destination 
  ACCEPT     tcp  --  192.168.1.10         192.168.1.1         tcp dpt:53
  ACCEPT     udp  --  192.168.1.10         192.168.1.1         udp dpt:53
  ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0   
  DROP       all  --  224.0.0.0/8          0.0.0.0/0   
  DROP       all  --  0.0.0.0/0            224.0.0.0/8 
  DROP       all  --  255.255.255.255      0.0.0.0/0   
  DROP       all  --  0.0.0.0/0            0.0.0.0     
  DROP       all  --  0.0.0.0/0            0.0.0.0/0           state INVALID
  OUTBOUND   all  --  0.0.0.0/0            0.0.0.0/0   
  LOG_FILTER  all  --  0.0.0.0/0            0.0.0.0/0   
  LOG        all  --  0.0.0.0/0            0.0.0.0/0           LOG flags 0 level 6 prefix `Unknown Output'
  
  Chain INBOUND (1 references)
  target     prot opt source               destination 
  ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED
  ACCEPT     udp  --  0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED
  ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0           tcp dpt:54100
  ACCEPT     udp  --  0.0.0.0/0            0.0.0.0/0           udp dpt:54100
  LSI        all  --  0.0.0.0/0            0.0.0.0/0   
  
  Chain LOG_FILTER (5 references)
  target     prot opt source               destination 
  
  Chain LSI (2 references)
  target     prot opt source               destination 
  LOG_FILTER  all  --  0.0.0.0/0            0.0.0.0/0   
  LOG        tcp  --  0.0.0.0/0            0.0.0.0/0           tcp flags:0x17/0x02 limit: avg 1/sec burst 5 LOG flags 0 level 6 prefix `Inbound '
  DROP       tcp  --  0.0.0.0/0            0.0.0.0/0           tcp flags:0x17/0x02
  LOG        tcp  --  0.0.0.0/0            0.0.0.0/0           tcp flags:0x17/0x04 limit: avg 1/sec burst 5 LOG flags 0 level 6 prefix `Inbound '
  DROP       tcp  --  0.0.0.0/0            0.0.0.0/0           tcp flags:0x17/0x04
  LOG        icmp --  0.0.0.0/0            0.0.0.0/0           icmp type 8 limit: avg 1/sec burst 5 LOG flags 0 level 6 prefix `Inbound '
  DROP       icmp --  0.0.0.0/0            0.0.0.0/0           icmp type 8
  LOG        all  --  0.0.0.0/0            0.0.0.0/0           limit: avg 5/sec burst 5 LOG flags 0 level 6 prefix `Inbound '
  DROP       all  --  0.0.0.0/0            0.0.0.0/0   
  
  Chain LSO (0 references)
  target     prot opt source               destination 
  LOG_FILTER  all  --  0.0.0.0/0            0.0.0.0/0   
  LOG        all  --  0.0.0.0/0            0.0.0.0/0           limit: avg 5/sec burst 5 LOG flags 0 level 6 prefix `Outbound '
  REJECT     all  --  0.0.0.0/0            0.0.0.0/0           reject-with icmp-port-unreachable
  
  Chain OUTBOUND (1 references)
  target     prot opt source               destination 
  ACCEPT     icmp --  0.0.0.0/0            0.0.0.0/0   
  ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED
  ACCEPT     udp  --  0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED
  ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0   
  

  In caso quindi di firewall attivo è necessario dare:

  $ sudo iptables -I INPUT 1 -p tcp --dport 4662 -j ACCEPT
  $ sudo iptables -I INPUT 1 -p udp --dport 4662+3 -j ACCEPT
  $ sudo iptables -I INPUT 1 -p udp --dport 4672 -j ACCEPT
  $ sudo iptables -I INPUT 1 -m state --state ESTABLISHED,RELATED -j ACCEPT
  $ sudo iptables -I -P OUTPUT ACCEPT
  

• Il traffico in uscita è abilitato per default. se si acedde a Internet tramite un router sarà neccessario aprire le porte di aMule anche su quest' ultimo. Oltre che ai valori di default Si possono ovviamente settare le le porte a piacere.

L' utilizzo del programma di per se è molto semplice. In alto abbiamo la bara degli strumenti che ci da accesso a tutte le varie sezioni. In pulsante connect avvia le connesioni ai vari server disponibili. Il secondo tasto permette di gestire l' elenco dei server e il pulsante searches porta alla schermata più importante. Basta inserire le parole chiave magari con dei parametri come tipo, dimensione min e max di file per eseguire la ricerca. Una volta ottenuti i risultati con un doppio clik avviamo il download e ci possiamo spostare nella sezione transfer per tener d' occhio lo stato del download. Sotto shared file troviamo invece l' elenco dei nostri file in condivisione. Se vogliamo importare dei download parziali iniziati precedentemente da eMule su Windows col tasto import possiamo attivare la procedura che riprende a scaricare da un file .part .Infine nella schermata Preferences possaimo configurare a piacimento il programma, ad esempio sotto connections possiamo impostare le porte che utilizza il client etc


BITTORENT
E' un protocollo molto utilizzato e in continua espansione principalmente per la distribuzione delle immagini ISO delle maggiori disto o software particolarmente corposi come OpenOffice.

La maggior parte delle distribuzioni Il software più utilizzato è equipaggiata con un client bittorent ma se cosi non fosse per le disto Debian based basta dare:

$ sudo apt-get update
sudo apt-get install bittorrent

per installare il relativamente scarno client originale scritto in Python. Bittorent neccessita di connessioni dirette per poter funzionare ottimamente quindi ci tocca aprire le porte tcp 6881-6999

$ sudo iptables -I INPUT 1 -p tcp --destination-port 6881:6999 -j ACCEPT
sudo iptables -I OTPUT 1 -p tcp --destination-port 6881:6999 -j ACCEPT

Come abbiamo detto già tale protocollo fu nato per risolvere il classico problema di download contemporanei di file di grosse dimensioni. Con questo protocollo chi scarica un file mette a disposizione degli altri utenti

To be continued...