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 "$@"