Cjdns
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.
