Hey all! Rich here.

I’m going to be going to the Free Culture 2008 conference in Berkeley, California this weekend and hopefully giving a quick talk about our project! If anybody is going to be there, you should stop by and meet me and we’ll hang out and have fun!

Just letting you all know, we are progressing along quite well. We have now done successful intercontinental test downloads from multiple anonymous sources! Anonarchy is nigh!

And our most exciting announcement is just around the corner!..

Richout

Anyway, it’s 4 am. Sleep now, More updates later.
-John

Anomos, with GUI!

How about that!

The GUI can only run one instance at a time, hence the seeder still being command line, but that’s nothing to worry about right now. Soon we’ll have the resources for a dedicated test platform so we won’t have to fiddle around trying to get multiple clients and trackers all on the same box.

Rich

These downloads aren’t anonymous yet, but all the infrastructure for making them so is there. I expect to get relay nodes working sometime later this week, and after that Rich and I will likely be starting some small scale tests over the internet.

We’ve also added a bit of content to the wiki, like the protocol specification, but there’s still a lot to be done there.

As always, feel free to contact us if you’re interested in getting involved.

Running tool: GrepAll
 
./Connecter.py:
352:            self.encoder.add_neighbor(self.id, AESKey(key, iv))
356:            self.encoder.add_neighbor(self.id, self.tmp_aes)
 
./Encoder.py:
154:    def add_neighbor(self, nid, aeskey):

Right there in the bottom pane.

So along with Gedit’s many nice features like tabs, syntax highlighting, and remote file editing come a bunch of very useful plugins. One of which is called External Tools, and it allows you to setup key bindings for scripts.
To use Grepall in Gedit, go to Edit -> Preferences -> Plugins and check External Tools. A “Tools” menu should appear in your menu bar. Then go to Tools -> External Tools, create a new tool and specify a description and key-binding of your choice. Copy and paste the following into the “Commands” text box:

#!/bin/bash
search=`xargs -0 echo`
$HOME/bin/grepall -e `echo $GEDIT_CURRENT_DOCUMENT_NAME | cut -d. -f2` "$search"

(Make sure you either saved grepall as ~/bin/grepall or changed the part that says “$HOME/bin/grepall” in the above code. And don’t forget to chmod it executable)

Back on the External Tools dialog, for Input select “Current selection” and for Output select “Display in bottom pane”

That’s it! Now whenever you highlight some text and hit the key-binding you selected Gedit will show you all instances of the highlighted text in all the files of the current directory with the same extension as the file you’re editing.

-John

Those exciting command line shots in the video are indeed showing some working parts of the protocol, such as encrypted tracker requests:

We’re also getting very close to finishing neighbor-to-neighbor connections, so an alpha release can be expected within the next few weeks.

Thanks for everybody who came to see our demo on the 2nd floor. If you missed it, I’ve put up a copy of the pdf, which you can download: Anomos.pdf

John has been diligently hacking away at the codebase recently and it’s coming along really nicely. Clients can now securely connect to the tracker and handshake to securely connect with each other. Data encryption up and down is in place, and the Relayers are being worked on so it shouldn’t be long until a slightly hacky but working alpha is available.

I set up an Anomos Wiki which we will be using for documentation and guides at somepoint, but there isn’t any content there yet. I’m also thinking about setting up a phpBB forum or a Google Group so we can handle development discussions.

Rich out!

E_a(0 . E_b(3 . E_c(2 . E_d(m))))

Each peer removes a layer of encryption and passes the message along. This is essentially the way in which Onion Routing networks, such as Tor, protect their routing information.

General Features

• File transfers through Anomos are anonymous (the degree of this anonymity will be discussed in a future post). After being sent, packets are routed through a number of intermediary nodes before reaching their final destination. These intermediary nodes can only confirm that their neighbors are participating in the network, they cannot confirm that their neighbors are sharing or merely relaying information, nor can they determine what is being shared.
• Downloading with Anomos is decentralized — the downloader receives parts of the requested file from a number of different sources, similar to how BitTorrent functions.
• Connections within Anomos are End-To-End encrypted.
• Communication with the Tracker is also encrypted.

Growing the Network

Like many BitTorrent systems Anomos relies on a centralized Tracker server to initiate downloads. However, to provide anonymity, the Anomos Tracker has been almost completely redesigned. When a client connects to the Tracker for the first time, they are assigned a small number of neighbors with whom they will directly communicate. Each neighbor the Tracker assigns to the client is given a locally unique ID (meaning that no two neighbors of the client will have the same ID). Using the the IP addresses provided by the Tracker and the local IDs, the client establishes connections with their neighbors.

After the connections have been formed the network may look like this:

Tracking Codes

Much of the power of Anomos comes from its “tracking code” system. The Tracker maintains a weighted undirected graph modeling the network. The graph’s vertices (the circles in the above images) represent clients, the edges (the arrowed lines) represent connections, and the weights (not pictured above) allow for fine grained control of how connections are formed (for instance: the tracker may route less traffic through peers who are heavily loaded). When an anonymous connection needs to be formed, the Tracker computes a path between the two peers involved. The path consists of a list of the peers through whom the packets should pass. The tracker then uses the numbered connections between those peers to create a description of the path (called a Tracking Code) which can be given to anyone without compromising the anonymity of the uploader or downloader. For instance if P0 wants to send a request to P9 then the Tracking code for that connection might be “0:1:2:4:0″

When P0 receives the tracking code, she creates the packet which needs to be sent, pops the first number off the tracking code, and sends the packet to her neighbor with that number. The process is repeated until the packet gets to its destination. Astute readers may notice that with this scheme the tracking codes would shrink and thereby reveal the recipient of the message at the second to last node. The actual codes are padded with a pseudorandom number at each node in the circuit to prevent this. You might also notice that with this scheme the recipient of the message doesn’t immediately know whether to pass the message on or to keep it. In order to resolve this, each peer initially assumes that they are the intended recipient and therefore try to decrypt the message. If the result of the decryption is garbage they pass the message on as per the Tracking Code, otherwise they respond. We’ve come up with a much better way to do this.

Requesting a file

If a client wants to download a file he first requests it from the tracker over secure HTTP. The tracker finds a small number of other users who have the file or parts of it and generates Tracking codes which connect the downloader to each of them. The Tracker also crafts the request data to be sent to each of these peers and encrypts it with each respective peer’s public key (which the Tracker knows but the downloader does not). This allows us to do end-to-end encryption without the uploader or downloader gleaning information about the network from seeing the same public key multiple times. The Tracker also generates an AES key for encrypting further communications between uploader and downloader. Here’s an example of a response the client might receive:

After receiving this, the client will create a packet containing the data in red (which the client himself cannot read), and send it through the network.

Sharing

After the initial request, the AES key generated by the Tracker is used to encrypt data between the two sharers. These sharers then pass messages in almost exactly the same way they would have in BitTorrent. The downloader sends a request, the uploader responds with a chunk.

Misc

In BitTorrent share ratios (the ratio of Amount Uploaded / Amount Downloaded) are used to punish peers who take without giving back. This can often be a barrier to entry for peers with few files or files which are not popular. Anomos helps these peers by adding their Amount Relayed to their Upload count, thereby rewarding people who donate their bandwidth to help others share anonymously.

I’ve presented some of the basics about the Anomos P2P system here, in future posts I will discuss more advanced topics such as how dropped connections are handeled, the level of anonymity the system provides, and perhaps an overview of the BitTorrent protocol.

We’ll be putting the source code repository online soon. If you’d like to be informed of major developments or would be interested in testing (several months from now) send us an email at: participateanomos.info

- John

While I was waiting for the parts to arrive I wrote a little python version that should run on just about any computer assuming python and pygame are installed. The program will display a square 40×40 toroidal game of life board by default, but it can take a command line argument to make it NxN (ex: python conway.py 8). There are plenty of other very nice game of life implementations out there, much faster and more featureful than this one, which I highly recommend if you’re interested in learning about this cellular automata.

Now, about the hardware version.
The source is available, and if you’re interested in building one there are tons of circuit diagrams online for driving an 8×8 LED Matrix (like this one). It’s a fun project and definitely easy enough for beginners (I have virtually no electronics experience, and this is also the first time I’ve ever programmed a PIC).