Post

Nebula

Posté
Preview Image
Par Yann
16 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.

Documentation

Exécution du phare “lighthouse” sur un VPS Webdock 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.19.55.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.

Nebula - PC1

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

  1. Téléchargez la dernière version pour votre plateforme depuis GitHub
  2. Extrayez l’archive et placez nebula et nebula-cert dans votre répertoire /usr/local/bin. Assurez-vous qu’ils sont exécutables : sudo chmod +x /usr/local/bin/nebula*

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
3
4
5

# créer dossier
mkdir -p ~/media/devel/nebula
cd ~/media/devel/nebula
# Créer les fichiers ca.key et ca.crt
nebula-cert ca -name "Réseau Nebula Yan"

Création des certificats clients

Avant de le verrouiller, nous avons besoin qu’il crée quelques certificats clients, 1 pour chaque client. Lors de la génération d’un certificat client, vous devez avoir décidé quel sous-réseau vous utiliserez pour le réseau VPN. On va utiliser 10.19.55.0/24

Phare lighthouse webdock
nebula-cert sign -name "lighthouse" -ip "10.19.55.1/24"

Cela créera un lighthouse.crt et un lighthouse.key, signés en utilisant votre AC Nebula.
Ces fichiers devront ensuite être transférés en toute sécurité à votre client.
Répétez ce processus pour chaque client que vous devez approvisionner, à l’exception des appareils mobiles - nous y reviendrons plus tard.

PC1 endeavouros
nebula-cert sign -name "pc1" -ip "10.19.55.2/24"

Portable DELL Latitude e6230
nebula-cert sign -name "e6230" -ip "10.19.55.3/24" -groups "laptop,ssh"

Serveur debian cwwk rnmkcy.eu
nebula-cert sign -name "cwwk" -ip "10.19.55.4/24" -groups "servers"

Serveur debian contabo xoyize
nebula-cert sign -name "xoyize" -ip "10.19.55.5/24" -groups "servers"

Fichiers de configuration (YAML)

La configuration de Nebula, comme tout ce qui se passe dans le cloud, se fait à l’aide d’un fichier YAML. La meilleure façon de commencer est d’utiliser l’exemple de configuration.

Fichiers de configuration
Télécharger une copie de la configuration d’exemple de nebula. Faites deux copies séparées du fichier de configuration exemple, une pour votre phare nommé config-lighthouse.yaml, et une pour chaque hôte non-léger, appelé config.yaml.

1
2
3

curl -o config.yml https://raw.githubusercontent.com/slackhq/nebula/master/examples/config.yml
cp config.yml config-lighthouse.yaml
cp config.yml config.yaml

La configuration d’exemple montre d’excellents exemples sur ce que sont les clés et comment vous pouvez les utiliser. Si vous avez l’intention de déployer Nebula, je vous recommande de la lire en entier. Mais ce sont les choses que vous devez changer pour obtenir un tunnel fonctionnel

Configuration du phare (lighthouse.yaml)

Serveur webdock debian 12 ip publique: 92.113.144.37

Sur l’hôte phare, vous devrez vous assurer que am_lighthouse: true. En général, un phare n’aura pas d’entrées dans sa carte static_host_map, car tous les hôtes se présenteront à un phare. Si vous utilisez plusieurs phares, ils n’ont généralement pas besoin de se connaître.

1
2
3
4
5

static_host_map:
  '10.19.55.1': ['92.113.144.37:4242']

lighthouse:
  am_lighthouse: true

Configuration des hôtes (config.yaml)

Sur les hôtes individuels, assurez-vous que le phare (lighthouse) est correctement défini dans la section static_host_map et que son adresse IP privée soit ajoutée à la section lighthouse: hosts

1
2
3
4
5
6
7
8

static_host_map:
  '10.19.55.1': ['92.113.144.37:4242']

lighthouse:
  am_lighthouse: false
  interval: 60
  hosts:
    - '10.19.55.1'

Paramètres du pare-feu

Le fichier de configuration par exemple permet tout le trafic sortant, mais permet uniquement des connexions spécifiques à chaque hôte Nebula. Vous devriez modifier ces paramètres pour permettre le trafic vers/depuis les hôtes de votre réseau.

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

firewall:
  outbound:
    # Allow all outbound traffic from this node
    - port: any
      proto: any
      host: any

  inbound:
    # Allow icmp between any nebula hosts
    - port: any
      proto: icmp
      host: any

Fichier complet (hosts, laptop, desktop et server)

Le fichier complet pour les hosts laptop desktop et server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

pki:
ca'
  ca: /etc/nebula/ca.crt
  cert: /etc/nebula/host.crt
  key: /etc/nebula/host.key
static_host_map:
  '10.19.55.1': ['92.113.144.37:4242']
lighthouse:
  am_lighthouse: false
  interval: 60
  hosts:
    - "10.19.55.1"
listen:
  host: "::"
  port: 4242
punchy:
  punch: true
relay:
  am_relay: false
  use_relays: true
tun:
  disabled: false
  dev: nebula1
  drop_local_broadcast: false
  drop_multicast: false
  tx_queue: 500
  mtu: 1300

  # Route based MTU overrides, you have known vpn ip paths that can support larger MTUs you can increase/decrease them here
  routes:
 unsafe_routes:
logging:
  level: info
  format: text
firewall:
  outbound_action: drop
  inbound_action: drop
  conntrack:
    tcp_timeout: 12m
    udp_timeout: 3m
    default_timeout: 10m
  outbound:
    # Allow all outbound traffic from this node
    - port: any
      proto: any
      host: any
  inbound:
    # Allow icmp between any nebula hosts
    - port: any
      proto: icmp
      host: any

Avec la configuration, le certificat et la clé, la dernière étape consiste à copier les fichiers appropriés à chaque hôte et à démarrer votre réseau Nebula.

Machines

VPS webdock (lighthouse)

Copiez le binaire de nebula, ainsi que le config-lighthouse.yaml, ca.crt, phare1.crt et phare1.key vers votre phare. Ne copier pas ca.key

Connexion SSH à votre phare.

1

 ssh yock@92.113.144.37 -p 55037 -i /home/yann/.ssh/vps-yock

Créez un répertoire nommé /etc/nebula sur votre hôte phare (en mode su).

1

mkdir /etc/nebula

Déplacez la configuration, les certificats et la clé dans le répertoire approprié.

Note : La configuration par exemple suppose que votre certificat d’hôte et clé sont nommés host.crt et host.key, de sorte que vous devrez renommer certains fichiers lorsque vous les déplacerez dans le répertoire approprié.

1
2
3
4

mv config-lighthouse.yaml /etc/nebula/config.yaml
mv ca.crt /etc/nebula/ca.crt
mv yock.crt /etc/nebula/host.crt
mv yock.key /etc/nebula/host.key

Le fichier complet /etc/nebula/config.yaml pour le phare lighthouse

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

pki:
  ca: /etc/nebula/ca.crt
  cert: /etc/nebula/host.crt
  key: /etc/nebula/host.key
static_host_map:
  '10.19.55.1': ['92.113.144.37:4242']
lighthouse:
  am_lighthouse: true
  interval: 60
  hosts:
    - "10.19.55.1"
listen:
  host: "::"
  port: 4242
punchy:
  punch: true
relay:
  am_relay: false
  use_relays: true
tun:
  disabled: false
  dev: nebula1
  drop_local_broadcast: false
  drop_multicast: false
  tx_queue: 500
  mtu: 1300
  routes:
  unsafe_routes:
logging:
  level: info
  format: text
firewall:
  outbound_action: drop
  inbound_action: drop
  conntrack:
    tcp_timeout: 12m
    udp_timeout: 3m
    default_timeout: 10m
  outbound:
    # Allow all outbound traffic from this node
    - port: any
      proto: any
      host: any
  inbound:
    # Allow icmp between any nebula hosts
    - port: any
      proto: icmp
      host: any

Télécharger les binaires

1
2
3

cd ~
wget https://github.com/slackhq/nebula/releases/download/v1.9.6/nebula-linux-amd64.tar.gz
tar xzvf nebula-linux-amd64.tar.gz

ATTENTION! Il faut ouvrir le port UDP 4242 sur le serveur “lighthouse”
sudo ufw allow 4242/udp
sudo ufw reload

Démarrer nebula

1
2
3

chmod +x nebula
mv nebula /usr/local/bin/
nebula -config /etc/nebula/config.yaml

Le service systemd /etc/systemd/system/nebula.service

1
2
3
4
5
6
7
8

[Unit]
Description=Nebula service
[Service]
Type=simple
ExecStart=/usr/local/bin/nebula -config /etc/nebula/config.yaml
Restart=on-failure
[Install]
WantedBy=multi-user.target

Serveur cwwk

Connexion SSH à votre serveur.

1

 ssh yick@192.168.0.205 -p 55205 -i /home/yann/.ssh/yick-ed25519

Créez un répertoire nommé /etc/nebula sur votre hôte phare (en mode su).

1

mkdir /etc/nebula

Déplacez la configuration, les certificats et la clé dans le répertoire approprié.

Note : La configuration par exemple suppose que votre certificat d’hôte et clé sont nommés host.crt et host.key, de sorte que vous devrez renommer certains fichiers lorsque vous les déplacerez dans le répertoire approprié.

1
2
3
4

mv config-server-nfs.yaml /etc/nebula/config.yaml
mv ca.crt /etc/nebula/ca.crt
mv cwwk.crt /etc/nebula/host.crt
mv cwwk.key /etc/nebula/host.key

Le fichier complet /etc/nebula/config.yaml pour le serveur cwwk

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

pki:
  ca: /etc/nebula/ca.crt
  cert: /etc/nebula/host.crt
  key: /etc/nebula/host.key
static_host_map:
  '10.19.55.1': ['92.113.144.37:4242']
lighthouse:
  am_lighthouse: false
  interval: 60
  hosts:
    - "10.19.55.1"
listen:
  host: "::"
  port: 4242
punchy:
  punch: true
relay:
  am_relay: false
  use_relays: true
tun:
  disabled: false
  dev: nebula1
  drop_local_broadcast: false
  drop_multicast: false
  tx_queue: 500
  mtu: 1300
  routes:
  unsafe_routes:
logging:
  level: info
  format: text
firewall:
  outbound_action: drop
  inbound_action: drop
  conntrack:
    tcp_timeout: 12m
    udp_timeout: 3m
    default_timeout: 10m
  outbound:
    # Allow all outbound traffic from this node
    - port: any
      proto: any
      host: any
  inbound:
    # Allow proto any between any nebula hosts
    - port: any
      proto: any
      host: any

Info: inbound: proto: any pour autoriser tous les accès

Télécharger les binaires

1
2

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

Démarrer nebula

1
2
3

chmod +x nebula
mv nebula /usr/local/bin/
nebula -config /etc/nebula/config.yaml

Le service systemd /etc/systemd/system/nebula.service

1
2
3
4
5
6
7
8

[Unit]
Description=Nebula service
[Service]
Type=simple
ExecStart=/usr/local/bin/nebula -config /etc/nebula/config.yaml
Restart=on-failure
[Install]
WantedBy=multi-user.target

Recharger systemd

1

systemctl daemon-reload

Activer et lancer le service

1

systemctl enable nebula.service --now

Portable laptop DELL e6230

Pour cet exemple, nous configurons l’hôte créé ci-dessus, nommé serveur. Veuillez remplacer les noms de fichiers appropriés.

Copiez le binaire de nébuleuse, ainsi que le config.yaml, ca.crt, server.crt et server.key vers l’hôte nommé serveur. Ne faites pas le dossier ca.key.

Connexion SSH à votre serveur.

1

 ssh yick@192.168.0.205 -p 55205 -i /home/yann/.ssh/yick-ed25519

Créez un répertoire nommé /etc/nebula sur votre hôte phare (en mode su).

1

mkdir /etc/nebula

Déplacez la configuration, les certificats et la clé dans le répertoire approprié.

Note : La configuration par exemple suppose que votre certificat d’hôte et clé sont nommés host.crt et host.key, de sorte que vous devrez renommer certains fichiers lorsque vous les déplacerez dans le répertoire approprié.

1
2
3
4

mv config.yaml /etc/nebula/config.yaml
mv ca.crt /etc/nebula/ca.crt
mv e6230.crt /etc/nebula/host.crt
mv e6230.key /etc/nebula/host.key

Le fichier complet /etc/nebula/config.yaml pour laptop DELL e6230

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

pki:
  ca: /etc/nebula/ca.crt
  cert: /etc/nebula/host.crt
  key: /etc/nebula/host.key
static_host_map:
  '10.19.55.1': ['92.113.144.37:4242']
lighthouse:
  am_lighthouse: false
  interval: 60
  hosts:
    - "10.19.55.1"
listen:
  host: "::"
  port: 4242
punchy:
  punch: true
relay:
  am_relay: false
  use_relays: true
tun:
  disabled: false
  dev: nebula1
  drop_local_broadcast: false
  drop_multicast: false
  tx_queue: 500
  mtu: 1300
  routes:
  unsafe_routes:
logging:
  level: info
  format: text
firewall:
  outbound_action: drop
  inbound_action: drop
  conntrack:
    tcp_timeout: 12m
    udp_timeout: 3m
    default_timeout: 10m
  outbound:
    # Allow all outbound traffic from this node
    - port: any
      proto: any
      host: any
  inbound:
    # Allow icmp between any nebula hosts
    - port: any
      proto: icmp
      host: any

Installer nebula sous archlinux

1

sudo pacman -S nebula

Démarrer nebula

1

nebula -config /etc/nebula/config.yaml

Le service systemd /etc/systemd/system/nebula.service

1
2
3
4
5
6
7
8

[Unit]
Description=Nebula service
[Service]
Type=simple
ExecStart=/usr/bin/nebula -config /etc/nebula/config.yaml
Restart=on-failure
[Install]
WantedBy=multi-user.target

Recharger systemd

1

systemctl daemon-reload

Activer et lancer le service

1

systemctl enable nebula.service --now

VPS Contabo xoyize

Connexion SSH à votre serveur.

1

 ssh xouser@158.220.91.148 -p 55148 -i /home/yann/.ssh/xoyize-ed25519

Créez un répertoire nommé /etc/nebula sur votre hôte phare (en mode su).

1

mkdir /etc/nebula

Déplacez la configuration, les certificats et la clé dans le répertoire approprié.

Note : La configuration par exemple suppose que votre certificat d’hôte et clé sont nommés host.crt et host.key, de sorte que vous devrez renommer certains fichiers lorsque vous les déplacerez dans le répertoire approprié.

1
2
3
4

mv config-server-nfs.yaml /etc/nebula/config.yaml
mv ca.crt /etc/nebula/ca.crt
mv xoyize.crt /etc/nebula/host.crt
mv xoyize.key /etc/nebula/host.key

Le fichier complet /etc/nebula/config.yaml pour le serveur xoyize

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

pki:
  ca: /etc/nebula/ca.crt
  cert: /etc/nebula/host.crt
  key: /etc/nebula/host.key
static_host_map:
  '10.19.55.1': ['92.113.144.37:4242']
lighthouse:
  am_lighthouse: false
  interval: 60
  hosts:
    - "10.19.55.1"
listen:
  host: "::"
  port: 4242
punchy:
  punch: true
relay:
  am_relay: false
  use_relays: true
tun:
  disabled: false
  dev: nebula1
  drop_local_broadcast: false
  drop_multicast: false
  tx_queue: 500
  mtu: 1300
  routes:
  unsafe_routes:
logging:
  level: info
  format: text
firewall:
  outbound_action: drop
  inbound_action: drop
  conntrack:
    tcp_timeout: 12m
    udp_timeout: 3m
    default_timeout: 10m
  outbound:
    # Allow all outbound traffic from this node
    - port: any
      proto: any
      host: any
  inbound:
    # Allow proto any between any nebula hosts
    - port: any
      proto: any
      host: any

Info: inbound: proto: any pour autoriser tous les accès

Télécharger les binaires

1
2

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

Démarrer nebula

1
2
3

chmod +x nebula
mv nebula /usr/local/bin/
nebula -config /etc/nebula/config.yaml

Le service systemd /etc/systemd/system/nebula.service

1
2
3
4
5
6
7
8

[Unit]
Description=Nebula service
[Service]
Type=simple
ExecStart=/usr/local/bin/nebula -config /etc/nebula/config.yaml
Restart=on-failure
[Install]
WantedBy=multi-user.target

Recharger systemd

1

systemctl daemon-reload

Activer et lancer le service

1

systemctl enable nebula.service --now

Archlinux EndeavourOS PC1

Installer nebula sous archlinux

1

sudo pacman -S nebula

Créez un répertoire nommé /etc/nebula sur votre hôte phare

1

sudo mkdir /etc/nebula

Copier la configuration, les certificats et la clé dans le répertoire approprié.

Note : La configuration par exemple suppose que votre certificat d’hôte et clé sont nommés host.crt et host.key, de sorte que vous devrez renommer certains fichiers lorsque vous les déplacerez dans le répertoire approprié.

1
2
3
4

sudo cp $HOME/media/devel/nebula/nebula_config.yaml /etc/nebula/config.yaml
sudo cp $HOME/media/devel/nebula/ca.crt /etc/nebula/ca.crt
sudo cp $HOME/media/devel/nebula/pc1.crt /etc/nebula/host.crt
sudo cp $HOME/media/devel/nebula/pc1.key /etc/nebula/host.key

Démarrer nebula

1

nebula -config /etc/nebula/config.yaml

Le service systemd /etc/systemd/system/nebula.service

1
2
3
4
5
6
7
8

[Unit]
Description=Nebula service
[Service]
Type=simple
ExecStart=/usr/bin/nebula -config /etc/nebula/config.yaml
Restart=on-failure
[Install]
WantedBy=multi-user.target

Recharger systemd

1

systemctl daemon-reload

Activer et lancer le service

1

systemctl enable nebula.service --now

Annexe

Vérifier fonctionnement

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

1

ping -c3 10.19.55.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.19.55.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.