Modification de Kit de dépannage

= Configuration d'un Accès Sécurisé à un Réseau Local via WireGuard =

Ce guide explique comment configurer un accès sécurisé à des machines sur un réseau local (RL1) en utilisant WireGuard, avec un serveur intermédiaire pour relayer la connexion. Typiquement, cet accès sera ouvert en connectant à RL1 un RPI pré-paramétré.

Concrètement, on utilise un pont (serveur intermédiaire) auquel M1 = le RPI et M2 = la machine utilisateur se connectent. Sur M1 on paramètre de l'IP forwarding pour accéder aux autres machines de ce réseau (RL1 = 192.168.1.x). Et sur M2 on définit une route pour que les adresses 192.168.1.x transitent par le serveur intermédiaire. Ainsi, par simple branchement du RPI sur le réseau d'un adhérent, on ouvre la possibilité d'accéder à ses machines et de le dépanner, sans intervenir sur sa box et sans en connaitre l'adresse. Le paramétrage ci-dessous présuppose que son réseau est de type 192.168.1.x.

== Prérequis ==

- Trois machines : M1 (sur RL1), M2 (sur RL2), et un serveur intermédiaire accessible depuis Internet.

- WireGuard installé sur toutes les machines.

- Accès administrateur sur toutes les machines.

== Étape 1 : Configuration du Serveur Intermédiaire ==

# Installez WireGuard sur le serveur intermédiaire (possibilité d'utiliser celui paramétré dans Home Assistant).
# Générez les clés WireGuard :
<pre>
wg genkey | tee privatekey | wg pubkey > publickey
</pre>

# Créez le fichier de configuration WireGuard (''/etc/wireguard/wg0.conf''):
<pre>
[Interface]
PrivateKey = <contenu du fichier privatekey>
Address = 10.0.0.1/24
ListenPort = 51820

[Peer]
PublicKey = <clé publique de M1>
AllowedIPs = 10.0.0.2/32, 192.168.1.0/24

[Peer]
PublicKey = <clé publique de M2>
AllowedIPs = 10.0.0.3/32
</pre>

# Activez WireGuard :
<pre>
sudo wg-quick up wg0
sudo systemctl enable wg-quick@wg0
</pre>

== Étape 2 : Configuration de M1 ==

# Installez WireGuard sur M1.
# Générez les clés WireGuard :
<pre>
wg genkey | tee privatekey | wg pubkey > publickey
</pre>

# Créez le fichier de configuration WireGuard (''/etc/wireguard/wg0.conf''):
<pre>
[Interface]
PrivateKey = <contenu du fichier privatekey>
Address = 10.0.0.2/24

[Peer]
PublicKey = <clé publique du serveur intermédiaire>
Endpoint = <adresse publique du serveur intermédiaire>:51820
AllowedIPs = 10.0.0.0/24, 192.168.1.0/24
PersistentKeepalive = 25
</pre>

# Activez WireGuard :
<pre>
sudo wg-quick up wg0
sudo systemctl enable wg-quick@wg0
</pre>

== Étape 3 : Configuration de M2 ==

# Installez WireGuard sur M2.
# Générez les clés WireGuard :
<pre>
wg genkey | tee privatekey | wg pubkey > publickey
</pre>

# Créez le fichier de configuration WireGuard (''/etc/wireguard/wg0.conf''):
<pre>
[Interface]
PrivateKey = <contenu du fichier privatekey>
Address = 10.0.0.3/24

[Peer]
PublicKey = <clé publique du serveur intermédiaire>
Endpoint = <adresse publique du serveur intermédiaire>:51820
AllowedIPs = 10.0.0.0/24, 192.168.1.0/24
PersistentKeepalive = 25
</pre>

# Activez WireGuard :
<pre>
sudo wg-quick up wg0
sudo systemctl enable wg-quick@wg0
</pre>

# Ajoutez une route temporaire pour accéder à M1a :
<pre>
sudo ip route add 192.168.1.0/24 via 10.0.0.2
ajout à voir pour l'accès au serveur Flask ?
</pre>

== Étape 4 : Application Flask pour Lister les Machines Connectées sur M1 ==

# Créez une application Flask pour scanner le réseau et lister les machines connectées :
<pre>
from flask import Flask, render_template_string
from scapy.all import ARP, Ether, srp
import socket

app = Flask(__name__)

def scan_network(ip_range):
    arp = ARP(pdst=ip_range)
    ether = Ether(dst="ff:ff:ff:ff:ff:ff")
    packet = ether/arp
    result = srp(packet, timeout=3, verbose=0)[0]

    devices = []
    for sent, received in result:
        devices.append({'ip': received.psrc, 'mac': received.hwsrc})

    return devices

def get_hostname(ip):
    try:
        return socket.gethostbyaddr(ip)[0]
    except socket.herror:
        return "N/A"

@app.route('/')
def index():
    ip_range = "192.168.1.0/24"
    devices = scan_network(ip_range)

    html = "<h1>Machines connectées au réseau</h1><ul>"
    for device in devices:
        hostname = get_hostname(device['ip'])
        html += f"<li>IP: {device['ip']}, MAC: {device['mac']}, Hostname: {hostname}</li>"
    html += "</ul>"

    return render_template_string(html)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
</pre>

# Instructions :
- Installez les dépendances :
<pre>
pip install flask scapy
</pre>
- Exécutez l'application Flask :
<pre>
python app.py
</pre>
- Accédez à l'interface web via ''http://<adresse_de_M1>:5000''.

== Étape 5 : Configuration de l'IP Forwarding et des Règles NAT sur M1 ==

# Activez l'IP forwarding :
<pre>
sudo sysctl -w net.ipv4.ip_forward=1
</pre>

# Pour rendre cette configuration permanente, ajoutez ou modifiez la ligne suivante dans ''/etc/sysctl.conf'' :
<pre>
net.ipv4.ip_forward = 1
</pre>

# Configurez les règles NAT (installer iptables si besoin et à compléter pour les rendre persistantes) :
<pre>
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
sudo iptables -A FORWARD -i wg0 -o eth0 -j ACCEPT
sudo iptables -A FORWARD -i eth0 -o wg0 -m state --state RELATED,ESTABLISHED -j ACCEPT
</pre>

== Conclusion ==

Ce guide vous permet de configurer un accès sécurisé à des machines sur un réseau local via WireGuard, en utilisant un serveur intermédiaire pour relayer la connexion. Vous pouvez également lister les machines connectées en utilisant une application Flask.