Info::WireGuard script pour projeter tous les ports vers un remote server
De wiki_pcwiki2
Aller à la navigationAller à la recherche
#!/usr/bin/env bash
#
# wg-fulltunnel-setup.sh
#
# Automatise la mise en place d'un tunnel WireGuard complet SORTANT :
# tout le trafic IP (v4+v6, tous ports) de la machine cliente est routé
# à travers le tunnel vers un serveur distant (ex: ovh2) qui NAT le
# trafic sortant sur sa propre IP publique.
#
# Usage :
# ./wg-fulltunnel-setup.sh server [--iface IFACE] [--port PORT] [--wg-net NET4] [--wg-net6 NET6]
# ./wg-fulltunnel-setup.sh client --endpoint HOTE:PORT --server-pubkey CLE_PUB_SERVEUR
# [--wg-net NET4] [--wg-net6 NET6] [--dns "IP1 IP2"]
#
# Le script est en deux temps car deux machines distinctes sont impliquées :
# 1) Lancer en mode "server" sur ovh2 -> il affiche la clé publique du serveur
# et attend que tu lui fournisses la clé publique du client (générée à
# l'étape 2) pour finaliser le [Peer] côté serveur.
# 2) Lancer en mode "client" sur la machine locale -> il affiche sa propre
# clé publique (à coller côté serveur) et démarre le tunnel une fois
# la clé publique du serveur fournie en argument.
#
# Prérequis Debian : apt install wireguard iptables
#
# Piège courant : sur ovh2, la chaîne ip6tables OUTPUT est en policy DROP
# sans règle ACCEPT pour les nouvelles connexions sortantes -> ce script
# ajoute les règles nécessaires en iptables ET ip6tables (INPUT/OUTPUT/FORWARD).
set -euo pipefail
IFS=$'\n\t'
# --- Constantes par défaut -------------------------------------------------
readonly WG_IFACE_DEFAULT="wg-tunnel"
readonly WG_PORT_DEFAULT="51821"
readonly WG_NET4_DEFAULT="10.66.0.0/24"
readonly WG_NET6_DEFAULT="fd66::/64"
readonly WG_DIR="/etc/wireguard"
readonly DNS_DEFAULT="9.9.9.9 2620:fe::fe"
# --- Fonctions utilitaires --------------------------------------------------
log() { printf '\033[1;32m[+]\033[0m %s\n' "$*" >&2; }
warn() { printf '\033[1;33m[!]\033[0m %s\n' "$*" >&2; }
err() { printf '\033[1;31m[x]\033[0m %s\n' "$*" >&2; exit 1; }
# Vérifie qu'on est bien root (le script ne gère pas sudo, usage direct en root)
require_root() {
if [[ "${EUID}" -ne 0 ]]; then
err "ce script doit être exécuté en root."
fi
}
# Vérifie la présence d'une commande, sinon indique le paquet Debian à installer
require_cmd() {
local cmd="$1" pkg="$2"
command -v "${cmd}" >/dev/null 2>&1 || err "commande '${cmd}' introuvable. Installez-la : apt install ${pkg}"
}
# Détecte l'interface réseau de sortie par défaut (celle qui a la route vers Internet)
detect_wan_iface() {
ip -4 route get 1.1.1.1 2>/dev/null | awk '/dev/ {for(i=1;i<=NF;i++) if ($i=="dev") print $(i+1)}'
}
# Génère une paire de clés WireGuard dans WG_DIR/keys si elle n'existe pas déjà
# $1 = préfixe (server|client)
generate_keypair() {
local prefix="$1"
local keydir="${WG_DIR}/keys"
mkdir -p "${keydir}"
chmod 700 "${keydir}"
if [[ -f "${keydir}/${prefix}_private.key" ]]; then
warn "clé privée ${prefix} déjà présente, réutilisation."
else
umask 077
wg genkey | tee "${keydir}/${prefix}_private.key" | wg pubkey > "${keydir}/${prefix}_public.key"
log "paire de clés '${prefix}' générée dans ${keydir}"
fi
}
# --- Mode SERVEUR ------------------------------------------------------------
setup_server() {
local iface="${WG_IFACE_DEFAULT}" port="${WG_PORT_DEFAULT}"
local net4="${WG_NET4_DEFAULT}" net6="${WG_NET6_DEFAULT}"
local wan_iface="" client_pubkey=""
while [[ $# -gt 0 ]]; do
case "$1" in
--iface) iface="$2"; shift 2 ;;
--port) port="$2"; shift 2 ;;
--wg-net) net4="$2"; shift 2 ;;
--wg-net6) net6="$2"; shift 2 ;;
--wan-iface) wan_iface="$2"; shift 2 ;;
--client-pubkey) client_pubkey="$2"; shift 2 ;;
*) err "option inconnue : $1" ;;
esac
done
require_root
require_cmd wg wireguard-tools
require_cmd iptables iptables
require_cmd ip6tables iptables
[[ -z "${wan_iface}" ]] && wan_iface="$(detect_wan_iface)"
[[ -z "${wan_iface}" ]] && err "impossible de détecter l'interface WAN, précise --wan-iface."
log "interface de sortie détectée : ${wan_iface}"
generate_keypair "server"
local server_priv server_pub
server_priv="$(cat "${WG_DIR}/keys/server_private.key")"
server_pub="$(cat "${WG_DIR}/keys/server_public.key")"
# Adresses tunnel dérivées des réseaux fournis (.1 côté serveur)
local addr4="${net4%.*}.1/${net4##*/}"
local addr6="${net6%::*}::1/${net6##*/}"
# Activation du forwarding IP, de façon persistante
cat > /etc/sysctl.d/99-wg-fulltunnel.conf << EOF
net.ipv4.ip_forward = 1
net.ipv6.conf.all.forwarding = 1
EOF
sysctl --system >/dev/null
log "IP forwarding (v4/v6) activé de façon persistante."
# Fichier de configuration WireGuard
local conf="${WG_DIR}/${iface}.conf"
if [[ -f "${conf}" ]]; then
warn "${conf} existe déjà, sauvegarde en ${conf}.bak"
cp "${conf}" "${conf}.bak"
fi
{
printf '[Interface]\n'
printf 'Address = %s, %s\n' "${addr4}" "${addr6}"
printf 'ListenPort = %s\n' "${port}"
printf 'PrivateKey = %s\n' "${server_priv}"
printf 'PostUp = iptables -t nat -A POSTROUTING -s %s -o %s -j MASQUERADE\n' "${net4}" "${wan_iface}"
printf 'PostUp = ip6tables -t nat -A POSTROUTING -s %s -o %s -j MASQUERADE\n' "${net6}" "${wan_iface}"
printf 'PostDown = iptables -t nat -D POSTROUTING -s %s -o %s -j MASQUERADE\n' "${net4}" "${wan_iface}"
printf 'PostDown = ip6tables -t nat -D POSTROUTING -s %s -o %s -j MASQUERADE\n' "${net6}" "${wan_iface}"
} > "${conf}"
chmod 600 "${conf}"
if [[ -n "${client_pubkey}" ]]; then
{
printf '\n[Peer]\n'
printf 'PublicKey = %s\n' "${client_pubkey}"
printf 'AllowedIPs = %s.2/32, %s::2/128\n' "${net4%.*}" "${net6%::*}"
} >> "${conf}"
log "[Peer] client ajouté dans ${conf}."
else
warn "aucune clé publique client fournie (--client-pubkey)."
warn "ajoute manuellement le bloc [Peer] dans ${conf} avant de démarrer le tunnel, puis relance :"
warn " systemctl restart wg-quick@${iface}"
fi
# Règles pare-feu : entrée UDP WireGuard + forwarding, en v4 ET v6
# (idempotent : -C vérifie l'existence avant d'insérer avec -I)
add_rule_once() {
local table_cmd="$1"; shift
if ! "${table_cmd}" -C "$@" 2>/dev/null; then
"${table_cmd}" -I "$@"
fi
}
add_rule_once iptables INPUT -p udp --dport "${port}" -j ACCEPT
add_rule_once ip6tables INPUT -p udp --dport "${port}" -j ACCEPT
add_rule_once iptables FORWARD -i "${iface}" -o "${wan_iface}" -j ACCEPT
add_rule_once iptables FORWARD -i "${wan_iface}" -o "${iface}" -m state --state RELATED,ESTABLISHED -j ACCEPT
add_rule_once ip6tables FORWARD -i "${iface}" -o "${wan_iface}" -j ACCEPT
add_rule_once ip6tables FORWARD -i "${wan_iface}" -o "${iface}" -m state --state RELATED,ESTABLISHED -j ACCEPT
log "règles pare-feu INPUT/FORWARD ajoutées (iptables + ip6tables)."
warn "pense à persister ces règles (ex: netfilter-persistent save) selon ton mécanisme habituel."
systemctl enable --now "wg-quick@${iface}" 2>&1 | tee /dev/stderr || true
echo
log "=== Clé publique du SERVEUR (à fournir côté client) ==="
echo "${server_pub}"
echo
log "Config : ${conf}"
}
# --- Mode CLIENT --------------------------------------------------------------
setup_client() {
local iface="${WG_IFACE_DEFAULT}"
local net4="${WG_NET4_DEFAULT}" net6="${WG_NET6_DEFAULT}"
local endpoint="" server_pubkey="" dns="${DNS_DEFAULT}"
while [[ $# -gt 0 ]]; do
case "$1" in
--iface) iface="$2"; shift 2 ;;
--wg-net) net4="$2"; shift 2 ;;
--wg-net6) net6="$2"; shift 2 ;;
--endpoint) endpoint="$2"; shift 2 ;;
--server-pubkey) server_pubkey="$2"; shift 2 ;;
--dns) dns="$2"; shift 2 ;;
*) err "option inconnue : $1" ;;
esac
done
require_root
require_cmd wg wireguard-tools
generate_keypair "client"
local client_priv client_pub
client_priv="$(cat "${WG_DIR}/keys/client_private.key")"
client_pub="$(cat "${WG_DIR}/keys/client_public.key")"
local addr4="${net4%.*}.2/${net4##*/}"
local addr6="${net6%::*}::2/${net6##*/}"
if [[ -z "${endpoint}" || -z "${server_pubkey}" ]]; then
warn "--endpoint et --server-pubkey manquants : le fichier sera généré mais incomplet."
warn "clé publique CLIENT à transmettre au serveur (--client-pubkey côté script server) :"
echo "${client_pub}"
[[ -z "${endpoint}" || -z "${server_pubkey}" ]] && exit 0
fi
local conf="${WG_DIR}/${iface}.conf"
if [[ -f "${conf}" ]]; then
warn "${conf} existe déjà, sauvegarde en ${conf}.bak"
cp "${conf}" "${conf}.bak"
fi
# DNS formaté en liste séparée par virgules pour la directive WireGuard
local dns_csv="${dns// /, }"
{
printf '[Interface]\n'
printf 'Address = %s, %s\n' "${addr4}" "${addr6}"
printf 'PrivateKey = %s\n' "${client_priv}"
printf 'DNS = %s\n' "${dns_csv}"
printf '\n[Peer]\n'
printf 'PublicKey = %s\n' "${server_pubkey}"
printf 'Endpoint = %s\n' "${endpoint}"
printf 'AllowedIPs = 0.0.0.0/0, ::/0\n'
printf 'PersistentKeepalive = 25\n'
} > "${conf}"
chmod 600 "${conf}"
log "config client écrite : ${conf}"
wg-quick up "${iface}"
log "tunnel '${iface}' démarré."
echo
log "=== Vérification ==="
if command -v curl >/dev/null 2>&1; then
curl -s https://ifconfig.me && echo
curl -s -6 https://ifconfig.me && echo || warn "IPv6 non joignable (vérifie ip6tables côté serveur)."
else
warn "curl absent, teste manuellement : curl https://ifconfig.me"
fi
}
# --- Point d'entrée -----------------------------------------------------------
usage() {
cat << EOF
Usage :
$(basename "$0") server [--iface IFACE] [--port PORT] [--wg-net NET4] [--wg-net6 NET6]
[--wan-iface IFACE] [--client-pubkey CLE_PUB]
$(basename "$0") client [--iface IFACE] [--wg-net NET4] [--wg-net6 NET6]
--endpoint HOTE:PORT --server-pubkey CLE_PUB [--dns "IP1 IP2"]
EOF
exit 1
}
main() {
[[ $# -ge 1 ]] || usage
local mode="$1"; shift
case "${mode}" in
server) setup_server "$@" ;;
client) setup_client "$@" ;;
*) usage ;;
esac
}
main "$@"