Ntk_carciofo - Dyne.org Wiki

NTK_RFC 0011

Subject: Carciofo - The vegetable sister of Tor in the Netsukuku realm

This text describes a possible expansion of the current Npv7 protocol. It will be included in the final documentation, so feel free to correct it. But if you want to change the system here described, please contact us first.

Carciofo

Carciofo means artichoke in Italian.

Carciofo is a system which enables full anonymity in Netsukuku. It hides the source and destination of packets and encrypts them, in this way it is impossible (too difficult) to know who sent the packets, where they are going and what they are carrying.

The theory of Carciofo isn't complete yet. This document, right now, is just a description of what it would be.

Features

Carciofo supports hidden servers and clients and it is, in fact, very similar to Tor, but it has some peculiar differences:

Carciofo is optimised for Netsukuku
Since it built upon Netsukuku, it is distributed and scalable
It works with IP tunnels, thus it supports any higher protocol like TCP and UDP
Carciofo will also work on the Internet with the advent of Viphilama ( http://lab.dyne.org/Ntk_viphilama ).

Since Carciofo is an expansion of the Npv7, it can be implemented as a total separated application from ntkd. The Carciofo daemon will communicate with ntkd using its API.

Carciofo can be also seen as an extension of Tor, in fact, a good idea would be to modify the Tor code and starting from there. Is it feasible?

Hidden connection

        Dest  <--> ... <-->  X  <--> ... <-->  Y  <--> ... <-->  Source
              MASQ     MASQ  |  MASQ     MASQ     MASQ     MASQ    |
                             |                                     |
                             |                                     |
                             |                                     |
                             |______ IPIP encrypted tunnel ________|

`...'  indicates an indefinite number of ntk nodes linked toghether

The node S (Source) wants to communicate with D (Dest), but it doesn't want any other node know of this communication. (a secret love affair?)

S creates a circuit which can be then utilised to reach more than one destination, moreover a circuit can be shared among other nodes of its same gnode.

The procedure to create a circuit is divided in various steps:

S contacts anonymously a node X chosen (almost) casually.
S creates an encrypted IPIP tunnel with X
X repeats the same procedure with another random node X_1
the procedure is iterated n times. (the user can modify this value. An higher value means higher protection but less performance. n=3 should be a good value.)
X_n finally contacts anonymously D

Let's go into details.

Step one: Masquerading

S chooses randomly its first relay node X. S can also lookup the routing tables to choose a node with a low delay or a node with a big bandwidth. (See NTK_RFC 002 - http://lab.dyne.org/Ntk_bandwidth_measurement )

S wants to create an encrypted link to the relay node X. X, to relay the packets of S, needs the IP of D (the destination node), but it hasn't to know the IP of S, because it would clearly see that S is attempting to contact D (and it will spread the rumor of the S-D love affair all over the net).

For this reason, S contacts X through a series of masqueraded connections:

S sets the MASQUERADE flag in all its packet, which are outgoing to X
The nodes between S and X, will MASQUERADE the packets of S:

        X  <--   A  <--   B  <--   C  <--  S
           MASQ     MASQ     MASQ     MASQ

In this way, C masquerades S, B masquerades C, and so on. The final packet received by X is A(B(C(S))).

Note that this happens at IP level (probably we'll use netfilter).

Step two: Encrypted tunnel

At this point, S creates an encrypted (IPIP) tunnel with X. (What is the best tunnel method to choose here? GRE, IPIP? And what encryption?)

S will then set X, as its gateway to reach the node D, in this way all the packets it sends to D, will go through the encrypted tunnel.

Step three: Iteration

S can tell X to iterate the first two steps `n' times:

X will create an (anonymous) encrypted tunnel with X_1
X_1 creates the tunnel with X_2
...
X_(n-1) creates the tunnel with X_n

Step four: Connection established

X_n can now create an (anonymous) connection to D with the method seen in the first step.

The use of the X_n<-->D masqueraded connection isn't really necessary. It should be used preferably when `n' is set to a small value.

S and D can now communicate.

Hidden server

                                     /            \
           Srv <---- enc tunnel --->   Hub nodes    <--- enc tunnel ---- Client
      netsukuku.org                  \            /

The hidden server method allows to hide the real IP of a node which needs to be contacted by other nodes. This method is based on ANDNA.

Server

Srv contacts, with circuit, ANDNA and register a hostname. Let's say "netsukuku.org". It specifies that the registration is anonymous, in this way ANDNA doesn't consider the src ip of the register node.

The hname netsukuku.org is then associated, with the use of SNSD and the service 0, to various random nodes chosen by Srv. These nodes are called "Hub nodes"

Srv creates an anonymous encrypted tunnel to each Hub node. The hub nodes set the encrypted tunnel as the default gateway for all the packets directed to Srv.

It would be good to change the hub nodes every X (60?) minutes.

Client

Client resolves "netsukuku.org" and gets the IPs of the hub nodes. It then creates an anonymous encrypted tunnel to one random hub node and sets it as the default gw to reach Srv.

At this point the link is set and Client can communicate happily with Srv.