I've been thinking about noncentralized self-organizing network
topologies since George
posted his query. First, there are several problems that any P2P
network faces in the future
hostile world:
1. ISPs blocking its ports
2. The "entry points" to P2P are vulnerable ---web sites that point
to dynamic list of *tella
servents, or the Kazaa site that points to active Kazaa supernode
servents. Simply sue
any of the sites with lists of *tella hosts. Even better, get the
ISPs to drop host lists
as fast as they drop stuff under DMCA.
3. Slow connections, slow machines
4. Active, hostile attacks, not just doofuses querying with
too-common keywords
To resist 1. you can use port 80, which ISPs can't block without losing
most
'legitimate' utility for the masses :-) Or you use randomly varying
ports and have to do more door-knocking.
To resist 2. you have to be able to randomly probe IP addresses to find
a node.
To manage 3., nodes should announce their capacities and the network
should work with this info.
(Cf. self-management in Morpheus/Kazaa, where users can disable the
'supernode' function).
Caching probably helps a lot.
So what you have is your client randomly 'knocking on doors' looking for
someone to answer with
the handshake that means, 'yes, I'm in the network'. Then the knocker
asks to join, and joins
the resident's "cell" :-) or is told to try another known to be in the
network.
I then started thinking about how to keep nodes connected in a single
connected graph. I ended up
with an algorithm which I realized resembled funky tree
growing/balancing algorithms I had seen
in datastruct/algorithm CS classes years ago. Only the nodes were
hosts, the links were communication links (IP addr=pointers) instead of
in-memory locations & pointers. Nodes can add children, keep track of
their
parents (and several great-ancestors for redundancy), and defer requests
to join to their children. When nodes
leave, they tell their children to reparent to the leaving-node's
parent. When parents defer join-requests
to their children, they first do an application-ping to see if the child
is still alive. When the 'root' node
leaves, it tells each of its children that they are each other's
parents, to keep the graph connected.
I'm going to code up a simulation when I get the time, with nodes
randomly receiving join requests and
randomly leaving, gracefully and not gracefully.
This does not handle various hostile/spoofing attacks, crypto
authentication, content-finding-query routing,
managing slow connections, etc. Its about keeping a virtual network
together.
Now that I write it up, I realize a tree has the flaw that child nodes'
queries must go through slow upstream links.
So I will think about algorithms to grow meshes dynamically, robustly,
to overcome that problem.
We welcome comments & pointers, and apologize for the rambling.
------
In the future, you will need a state license for a general-purpose
computer, otherwise you can only
run state-approved code. Similarly for Inet "connections" which
transport other than approved
protocols on well known ports.
Celsius 451 -the melting point of Cat-5
