Cjdns

Aus wiki.freifunk.net
Wechseln zu: Navigation, Suche

Cjdns ist ein Netzwerk Protokoll. Die Philosophy hinter cjdns ist ein Netzwerk, das einfach aufzusetzen ist, skaliert und komplett verschlüsselt ist.

Cjdns implementiert ein verschlüsselte IPv6 Netzwerk mit public key Krypto für address allocation und eine distributes hash table for routing.

Vorteile für Freifunk

  • Vollständige Ende-zu-Ende Verschlüsslung
  • Freifunk Dienste können auch aus dem Urlaub über eine sichere Verbindung erreicht werden

Nachteile

  • Der Adressbereich fc00::/8 kann nicht anderweitig verwendet werden

Addressbereich

Cjdns verwendet den Range fc00::/8 vollständig. Es darf keine andere Route für diesen Range verfügbar sein.

Adressbereich ist frei

Es kann ein vollständiger cjdns node betrieben werden. Es ist keine Änderung in der config notwendig. Der Node ist dazu in der Lage, traffic für andere zu routen, über seine fc adresse erreichbar und kann andere fc adressen erreichen.

Adressbereich ist in Verwendung

Cjdns kann legitlich als Router betrieben werden. Wird das tun device in der Config deaktiviert, wird keine route für diesen Bereich gesetzt und das Interface wird nicht aktiviert. Der Node ist in der Lage, traffic für andere Teilnehmer weiter zu leiten, ist selbst aber unter seiner fc Adresse nicht erreichbar und kann keine fc Adressen erreichen.

Konflikte mit Freifunk Ranges

(Todo: bisher keine)

Interessierte Communities/Personen

  • kpcyrd (freifunk hamburg)
  • larsg (freifunk berlin)
  • jcgruenhage (freifunk karlsruhe)

Installation auf Debian

# if you are running wheezy. skip this step on jessie
echo 'deb http://ftp.debian.org/debian wheezy-backports main' >> /etc/apt/sources.list
apt-get update
apt-get install nodejs build-essentials
cd /opt/
git clone https://github.com/cjdelisle/cjdns.git
cd cjdns/
./do
ln -s /opt/cjdns/cjdroute /usr/bin/
wget -O /etc/init.d/cjdns https://raw.githubusercontent.com/ProjectMeshnet/CJDNS-init.d-Script/master/cjdns.sh
chmod 0755 /etc/init.d/cjdns

Installation auf Ubuntu

apt-get install nodejs build-essentials
cd /opt/
git clone https://github.com/cjdelisle/cjdns.git
cd cjdns/
./do
cp contrib/upstart/cjdns.conf /etc/init/
ln -s /opt/cjdns/cjdroute /usr/bin/

Installation auf Fedora

dnf install cjdns cjdns-tools cjdns-selinux

Installation auf anderen Geräten

Peering konfigurieren

Ausgehende Verbindungen

Der einfachste Weg einen peer hinzuzufügen ist es, eine ausgehende Verbindung zu jemandem aufzubauen. So bedarf es keiner konfiguration des Systems für eingehende Verbindungen aus dem Internet. Obwohl es sich hierbei um eine ausgehende Verbindung handelt, können Daten in beide Richtungen übertragen werden, dein Computer ist nur der iniziierende Knoten.

Um eine ausgehende Verbindung aufzubauen brauchst du 3 Dinge: Die IPv4/IPv6 Adresse und den Port, zu dem kommunizoert werden soll, der public key um den entfernten Konten zu authentifizieren, ein shared secret password, das dem entfernten Knoten zeigt, dass du authorisiert bist, dich zu verbinden. Diese Informationen sehen so aus:

"70.201.219.150:7883":
{
    "publicKey":"8hgr60p781kbswugxjyymhhywt62yllxxkz254hqtzbb5rpzc5j0.k",
    "password":"HJSHDF80234nsdkk9KJjf090(((a;djf",
}

Du musst die peer Defintion in deine Konfiguration eintragen, um deinem Knoten zu sagen, dass er sich zu dem anderen Knoten verbinden soll.

Suche nach diesem Teil in deiner Konfiguration:

      // Nodes to connect to.
      "connectTo":
      {
          // Add connection credentials here to join the network
          // Ask somebody who is already connected.
      }

Als nächstes, nimm die Knoten, zu denen du sich verbinden möchtest und füge sie so ein:

      // Nodes to connect to.
      "connectTo":
      {
           "0.1.2.3:45678":
           {
               "password": "password",
               "publicKey": "key.k"
           },
           "0.1.2.3:45678":
           {
               "password": "password",
               "publicKey": "key.k"
           },
           "0.1.2.3:45678":
           {
               "password": "password",
               "publicKey": "key.k"
           }
      }

Wichtig:

  • Ein paar Personen können dir zusätzliche Werte mitgeben als nur das password und den public key. Obwohl diese nicht notwendig sind, stellen sie kein Problem dar. Unbenutzte Werte werden ignoriert. Möglicherweise möchtest du deine eigenen Werte oder Kommentare hinzufügen, damit du dir merken kannst, welcher Knoten welcher ist.

Incoming Connections

Of course, if you can connect to people by making outgoing connections, they must have a way to accept incoming connections, right?

In order to reliably accept incoming peer connections, you need to do a bit of setup. You have set up your router or firewall or whatever stands between you and the Internet to allow incoming connections to to cjdns on the port you are using. If you are using the most common home network setup (a standard consumer wireless router between you and the Internet), you need to configure port forwarding to allow incoming connections. See below for instructions on how to find the port number to forward.

Note that most residential Internet connections have dynamic IP addresses, which periodically change. This causes problems with incoming peer connections: if you tell peers to connect to you at a certain IP address, and your IP address changes, they will no longer be able to find you and connect. Talk with your ISP about getting a static IP address.

If you are unable to obtain a static IP address from your ISP, it is possible to use a dynamic IP address from services such as NO-IP in its place, given that you have this updating on your router or as a service/daemon on the system running Cjdns.

To add a new incoming peer, first find the section of your configuration file that looks like this:

   // Anyone connecting and offering these passwords on connection will be allowed.
   //
   // WARNING: Currently there is no key derivation done on the password field,
   //          DO NOT USE A PASSWORD HERE use something which is truly random and
   //          cannot be guessed.
   // Including a username in the beginning of the password string is encouraged
   // to aid in remembering which users are who.
   //
   "authorizedPasswords":
   [
      // There may already be some stuff here. That is OK.
   ]

Between the square brackets, you should place a comma-separated list of secret connection passwords, thusly:

   "authorizedPasswords":
   [
       {
           // It's good practice to note which peer you have assigned which password to.
           "password": "asdhkjauiawyhajhsf+64987654**&#$*7922-asf"
       },
       {
           // Each peer ought to have its own password, so you can revoke access if necessary.
           "password": "aslrhjfjsdfar2347889023745()@;;;tdfgjh"
       }
   ]

The actual password can be anything; it just has to be hard to guess. Remember that \ is an escape character.

Find the part of your configuration file that looks like this:

   "publicKey": "nu8yx4ht958wqlvvxj7fgfq7l5yq13cc9ycnr8sfjtzm3zjlxhm0.k",

This gives your node's public key, which incoming peers need to connect.

Finally, find the part of your config file that looks like this:

       "UDPInterface":
       {
           // Bind to this port.
           "bind": "0.0.0.0:40941",

This gives the port that your cjdns node is listening on (in this example, 40941).

Make sure that you know your Internet-facing IPv4 address (which you can get here). For this example, assume it is "59.202.17.33".

Once you have all that, construct a peer configuration section and give it to your peer to insert into their configuration file:

"59.202.17.33:40941":
{
    "publicKey":"nu8yx4ht958wqlvvxj7fgfq7l5yq13cc9ycnr8sfjtzm3zjlxhm0.k",
    "password":"asdhkjauiawyhajhsf+64987654**&#$*7922-asf"
}

Send this information to your peer, and have them insert it into their configuration file as an outgoing connection, as described above.

Weblinks