Post

Nebula

Posté
Preview Image
Par Yann
10 min lire
Nebula

Nebula est un outil de réseau superposé évolutif axé sur les performances, la simplicité et la sécurité. Il vous permet de connecter de manière transparente des ordinateurs partout dans le monde. Nebula est portable et fonctionne sous Linux, OSX, Windows, iOS et Android.

Nebula

nebula
Nebula: Open Source Overlay Networking

Fonctionnalités principales

  • Réseau virtuel peer-to-peer, couche 3 (détails techniques)
  • Prise en charge du trafic TCP/UDP/ICMP via un adaptateur TUN avec split-tunneling
  • Pare-feu hôte avec moteur de règles basé sur des groupes pour le trafic overlay
  • Découverte de routes et traversée NAT assistées par de simples hôtes « lookup »

Identité et autorisation

Nebula utilise un modèle PKI pour établir la confiance entre les hôtes et les réseaux.

  • Les certificats d’hôte sont utilisés pour identifier et autoriser les pairs de manière sécurisée.
  • Les hôtes s’authentifient mutuellement en validant les certificats et les autorités de certification.
  • Les règles de pare-feu sont appliquées en évaluant les « groupes de sécurité » des certificats.

Les versions incluent l’exécutable nebula-cert pour générer des clés, des certificats, des autorités de certification et pour signer les certificats d’hôte.

Compatibilité

Nebula est écrit en Go et est conçu pour être portable.

  • Packagé pour Linux, macOS, Windows, iOS, Android et FreeBSD.
  • Fonctionne efficacement sur les matériels x86, ARM, MIPS, PPC et RISC (32 et 64 bits).
  • Un seul exécutable Nebula exécute le pare-feu hôte et le service.
  • Le fichier de configuration hôte définit la confiance CA, le certificat et la clé hôte, ainsi que les règles du pare-feu.
  • Au moins un hôte du réseau superposé doit être un Lighthouse, qui aide les hôtes à découvrir les routes les uns vers les autres et facilite la traversée NAT.

Release v1.10.0

  • Prise en charge des adresses ipv6 et plusieurs ipv4/6 dans la superposition.
    Un nouveau format de certificat basé sur v2 ASN.1.
    Les certificats ont maintenant une interface unifiée pour les implémentations externes.
  • Ajoutez la possibilité de marquer des paquets sur Linux pour mieux cibler les paquets Nebula dans iptables/nftables.
  • Ajouter le support ECMP pour unsafe_routes.
  • Prise en charge de PKCS11 pour les clés P256 lorsqu’elles sont construites avec pkcs11tag

    Documentation

  • Guide de démarrage rapide de Nebula (Nebula Quick Start guide)
  • Set up a minimal nebula overlay network
  • Setting Up a Nebula Overlay Network with Syncthing

Exécution du phare “lighthouse” sur un VPS OVH Debian 12
Clients, un ordinateur de bureau Arch, un portable laptop, serveur debian et un autre sur un téléphone Android


Réseau privé: 10.55.22.0/24

Il y a toujours un nœud central, introducteur ou Nebula lighthouse (phare) , qui s’assure que tous les nœuds du réseau peuvent communiquer efficacement entre eux. Le phare est également le seul nœud qui nécessite une IP statique. Comme le trafic n’est plus acheminé par un seul nœud, il réduit considérablement les besoins en ressources pour ce nœud, tout en réduisant les goulets d’étranglement.

Ordinateur - PC1

Création dossier et sous-dossiers

1
2
3

# créer dossier
mkdir -p ~/media/devel/nebula
cd ~/media/devel/nebula

Dossier Nebula: ~/media/devel/nebula/

Nebula binaire

Binaire nebula-linux-amd64.tar.gz pour les architectures amd64

Liste des binaires https://github.com/slackhq/nebula/releases/latest pour les distributions

Téléchargez la dernière version pour votre plateforme depuis GitHub

1

wget https://github.com/slackhq/nebula/releases/download/v1.10.0/nebula-linux-amd64.tar.gz

Extraire l’archive

1
2
3

tar xzvf nebula-linux-amd64.tar.gz
# effacer archive
rm nebula-linux-amd64.tar.gz

Assurez-vous qu’ils sont exécutables :

1

 chmod +x nebula*

et placer nebula+ nebula-cert dans votre répertoire /usr/local/bin

1

 sudo cp nebula* /usr/local/bin/

Autorité de certification (AC)

Nebula utilise PKI pour l’authentification sous la forme d’autorité de certification (CA).
Les clients reçoivent la clé publique de l’autorité de certification, et leur propre paire de clés publique/privée signée par l’autorité de certification. Comme chaque client connaît l’autorité de certification, celle-ci peut facilement vérifier si le client est autorisé, et l’ajout de nouveaux clients ne nécessite pas de modifier les fichiers de configuration.

Création ca.key et ca.crt
La première étape consiste à créer les fichiers ca.key et ca.crt, qui constituent les clés privées et publiques de votre AC. Veillez à ce que le fichier ca.key reste privé.
Je recommande de stocker le fichier hors ligne, et de le traiter comme vous le feriez pour une clé privée SSH sur vos serveurs.

1
2

# Créer les fichiers ca.key et ca.crt
nebula-cert ca -name "Nebula Yan"

Cela va créer des fichiers nommés ca.keyet ca.certdans le répertoire actuel. Le ca.keyfichier est le fichier le plus sensible que vous allez créer, car c’est la clé utilisée pour signer les certificats pour les nœuds/hôtes de nébuleuse individuels. Veuillez stocker ce fichier dans un endroit sûr, de préférence avec un cryptage fort.

Soyez conscient ! Par défaut, les autorités de certification ont une durée de vie de 1 an avant l’expiration. Voir ce guide (en) pour plus de détails sur la rotation d’une AC.

Vérification du ca:

1

nebula-cert print -path ./ca.crt

Inspection du certificat.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

{
	"curve": "CURVE25519",
	"details": {
		"groups": null,
		"isCa": true,
		"issuer": "",
		"name": "Nebula Yan",
		"networks": null,
		"notAfter": "2026-12-10T14:05:21+01:00",
		"notBefore": "2025-12-10T14:05:21+01:00",
		"unsafeNetworks": null
	},
	"fingerprint": "b83..................de0ca50",
	"publicKey": "ce20....................b7d788b57b396",
	"signature": "73b.......................5a18613f7552f7b73b693c0d",
	"version": 2
}

Script pour générer un client Nebula

Création d’un bash nebula-client.sh pour générer les fichiers de configurations Nebula des groupes home, laptop, servers, lighthouse et mobile

Etendre Réduire... 
#!/bin/bash
#
STATIC_FILES="$HOME/media/statique/files/nebula/"
CURRENT=$pwd
CSV_FILE="Nebula-Certificats-Configuration.csv"

function usage {
       printf "#################################################################################################\n"
       printf "Utilisation: $0 [-n <Nom client Nebula>] [-i <Adresse IP>] [-g <Groupe>]\n"
       printf "Nom client Nebula sans espace ni caractères spéciaux\n"
       printf "Adresse IP 10.55.22.0/24\n"
       printf "Groupes: home, laptop, servers, lighthouse et mobile\n"
       printf "Exemples:\n"
       printf "    $0 -n nebula-lighthouse1 -i 10.55.22.1/24 -g lighthouse\n"
       printf "    $0 -n nebula-server1 -i 10.55.22.2/24 -g servers \n"
       printf "    $0 -n nebula-laptop1 -i 10.55.22.3/24 -g laptop \n"
       printf "Lecture fichier 'Nebula-Certificats-Configuration.csv': \n"
       printf "$0 -f \n"
       printf "#################################################################################################\n"
       exit 0
}

n=""
i=""
g=""

while getopts "n:i:g:hf" option; do
    case "${option}" in
        n)
            n=${OPTARG}
            ;;
        i)
            i=${OPTARG}
            ;;
        g)
            g=${OPTARG}
            ;;
        h)
            usage
            ;;
        f)
        if [ -f "$CSV_FILE" ]; then
	  column -s';' -t < Nebula-Cerificats-Configuration.csv	
          exit
        fi
          ;;
    esac
done
shift $((OPTIND-1))

if [ -z "$n" ] || [ -z "$i" ] || [ -z "$g" ]; then
 echo "Pas d'arguments"
 usage
fi

if [ -d "nebula-install" ]; then
 echo "effacement dossier temporaire"
 rm -r nebula-install/*
else
 echo "création dossier temporaire"
 mkdir -p nebula-install
fi


# Variables
nebula_host=${n}
nebula_ip=${i}
nebula_group=${g}

case "$nebula_group" in
  home | laptop | servers | mobile)
   nebula_cfg="config-server-nfs.yaml"
   ;;
  lighthouse)
   nebula_cfg="config-lighthouse.yaml"
   ;;
esac

echo "$nebula_cfg"

# Générer les certificats 
#-------------------------------------
# si le certificat est présent , on  efface le .crt et le .key
if [ -f "$nebula_host.crt" ]; then
 echo "effacement certificat "
 rm $nebula_host.*
fi

echo "Générer les certificats $nebula_host"
nebula-cert sign -name $nebula_host -ip $nebula_ip -groups $nebula_group

# Copier les fichiers $HOME/media/statique/files/nebula/
#------------------------------------------------------- 
# copier le binaire, les certificat nebula et le service
echo 'cp nebula nebula-install/'
cp nebula nebula-install/
echo 'cp ca.crt nebula-install/'
cp ca.crt nebula-install/
echo 'cp $nebula_host.key nebula-install/host.key'
cp $nebula_host.key nebula-install/host.key
echo 'cp $nebula_host.crt nebula-install/host.crt'
cp $nebula_host.crt nebula-install/host.crt
echo 'cp nebula.service nebula-install/'
cp nebula.service nebula-install/
echo 'cp $nebula_cfg nebula-install/config.yaml'
cp $nebula_cfg nebula-install/config.yaml


# Générer la procédure d'installation
cat > "nebula-install/""nebula-install.sh" << EOF
#!/bin/sh

# exécutable nebula amd64
#
sudo mv -f nebula /usr/local/bin/
#
# Répertoire, configuration et certificats nebula
#
echo "sudo mkdir -p /etc/nebula"
sudo mkdir -p /etc/nebula
echo "sudo mv -f config.yaml /etc/nebula/"
sudo mv -f config.yaml /etc/nebula/
echo "sudo mv -f ca.crt /etc/nebula/"
sudo mv -f ca.crt /etc/nebula/
echo "sudo mv -f host.* /etc/nebula/"
sudo mv -f host.key /etc/nebula/
sudo mv -f host.crt /etc/nebula/
#
# Créer le service nebula
#
echo "Créer le service systemd nebula"
sudo mv -f nebula.service /etc/systemd/system/
# Recharger la configuration systemd
sudo systemctl daemon-reload
#
# Démarrer et activer le service nebula
#
echo "Démarrer et activer le service nebula"
sudo systemctl enable nebula --now
EOF

# lighthouse
case "$nebula_group" in
  lighthouse)
cat >> "nebula-install/""nebula-install.sh" << EOF
#
# si parefeu ufw
#
if [ -f "/usr/sbin/ufw" ]; then
 echo "UFW allow 4242/udp"
 sudo ufw allow 4242/udp
 sudo ufw reload
fi
EOF
   ;;
esac

# Rendre ex&cutable le script
chmod +x "nebula-install/""nebula-install.sh"

# Compresser le dossier
cd nebula-install/
tar -czf $nebula_host-install.tar.gz *
cp $nebula_host-install.tar.gz $STATIC_FILES
cd $CURRENT
echo "# Client Nebula, télécharger le gz"
echo "wget https://chirpy.rnmkcy.eu/files/nebula/$nebula_host-install.tar.gz"
echo "# Extraire dans le répertoire courant"
echo "tar -xvf $nebula_host-install.tar.gz"

Le rendre exécutable

1

chmod +x nebula-client.sh

Aide: ./nebula-client.sh

1
2
3
4
5
6
7
8
9
10
11
12

#################################################################################################
Utilisation: ./nebula-client.sh [-n <Nom client Nebula>] [-i <Adresse IP>] [-g <Groupe>]
Nom client Nebula sans espace ni caractères spéciaux
Adresse IP 10.55.22.0/24
Groupes: home, laptop, servers, lighthouse et mobile
Exemples:
    ./nebula-client.sh -n nebula-lighthouse1 -i 10.55.22.1/24 -g lighthouse
    ./nebula-client.sh -n nebula-server1 -i 10.55.22.2/24 -g servers 
    ./nebula-client.sh -n nebula-laptop1 -i 10.55.22.3/24 -g laptop 
Lecture fichier 'Nebula-Certificats-Configuration.csv': 
./nebula-client.sh -f 
#################################################################################################

AC - Générer les certificats clients

Vous pouvez nommer les nœuds comme vous le souhaitez, y compris FQDN. Vous devrez également choisir les adresses IP et le sous-réseau associé. Nous créons un réseau Nebula dans la plage 10.55.22.x/24. On peut définir des groupes qui peuvent ensuite être utilisés pour définir des règles de trafic dans un réseau nebula.

Utilisation de la procédure pour créer des fichiers décompressibles tar.gz

Phare lighthouse OVH
./nebula-client.sh -n vps-ovh-lighthouse -i 10.55.22.1/24 -g lighthouse
Serveur debian cwwk rnmkcy.eu
./nebula-client.sh -n cwwk-nebula -i 10.55.22.1/24 -g servers
Portable DELL Latitude e6230
nebula-cert sign -name "e6230" -ip "10.55.22.20/24" -groups "laptop"
PC1 endeavouros
nebula-cert sign -name "pc1" -ip "10.55.22.10/24" -groups "home"

Vous téléchargez le fichier correspondant dans la machine concernée

Exemple pour le lighthouse (phare)

1
2
3
4

# Client Nebula, télécharger le gz
wget https://chirpy.rnmkcy.eu/files/nebula/vps-ovh-lighthouse-install.tar.gz
# Extraire dans le répertoire courant
tar -xvf $nebula_host-install.tar.gz

Puis lancer la procédure d’installation

1

./nebula-install.sh

Vérifier

1

systemctl status nebula

Tester si le port UDP 4242 est ouvert sur le phare(lighthouse)

1

sudo nmap -sU -p 4242 51.38.37.240

Réponse

1
2
3
4
5
6
7
8

Starting Nmap 7.95 ( https://nmap.org ) at 2025-12-12 18:12 CET
Nmap scan report for yick.eu (51.38.37.240)
Host is up (0.016s latency).

PORT     STATE         SERVICE
4242/udp open|filtered vrml-multi-use

Nmap done: 1 IP address (1 host up) scanned in 0.50 seconds

IMPORTANT: Le port UDP 4242 doit être ouvert sur tous les hôtes Nebula

Vérifier fonctionnement

Vous devriez maintenant être en mesure de pinger d’autres hôtes exécutant nebula (en supposant que ICMP est autorisé). Pour pinger ligthhouse (phare):

1

ping -c3 10.55.22.1

Ajout d’hôtes à votre réseau

Il est facile d’ajouter des hôtes à un réseau Nebula établi. Vous créez tout simplement un nouveau certificat d’hôte et une nouvelle clé, puis suivez les étapes sous Lancer Nebula. Vous n’aurez pas besoin de modifier votre phare ou tout autre hôte lors de l’ajout d’hôtes à votre réseau, et les hôtes existants pourront en trouver de nouveaux via le ligthhouse (phare), automatiquement.

Configuration sur iOS/Android

Téléchargez l’application (iOS/Android). Cliquez sur « + » pour ajouter une nouvelle configuration, puis copiez la clé publique de l’appareil (à partir de l’écran « Certificate ») sur votre ordinateur qui contient ca.key.

Envoi du certificat par messagerie, enregistrer dans un fichier $HOME/media/devel/nebula/a528s-nebula.key

Signez la clé en utilisant ca.key:

1
2
3

nebula-cert sign -ca-crt ./ca.crt \
  -ca-key ./ca.key -in-pub a528s-nebula.key \
  -name a528s-nebula -ip 10.55.22.10/24

Cela devrait produire a528s-nebula.crt
Envoyer a528s-nebula.crt et ca.crt sur votre téléphone.

Choose file pour récupérer le certificat a528s-nebula.crt , puis “save”

Cliquer sur CA pour récupérer le certificat ca.crt , puis “File”, “Choose file” et save

Dans l’écran « Hosts », “Add a new entry” définissez l’adresse IP de votre phare, ainsi que son adresse IP publique et son port. Activez l’option « Phare ».

Une fois ces informations saisies, vous pouvez enregistrer la configuration.

Vous pouvez ensuite utiliser l’application Nebula ou les paramètres VPN pour activer Nebula. La connexion prendra quelques secondes, puis vous pourrez accéder à tous les appareils connectés à votre VPN.

network
Cet article est sous licence CC BY 4.0 par l'auteur.