Samedi 21 mars 2020 (Modifié le Mercredi 25 mars 2020)

Serveur OVH vps803434

OVH
OVH vps803434 (1 vCore/2GoRam/20GoSSD) Debian Buster

Debian Buster
PARAMETRES D’ACCES:
L’adresse IPv4 du VPS est : 59.12.235.121
L’adresse IPv6 du VPS est : 2010:3fc0:4dff:2400::afe5

Le nom du VPS est : vps803434.ovh.net
Connexion SSH en “root”

ssh root@59.12.235.121

Réseau

Créer un bash pour désactiver l’initialisation réseau par le cloud sur le VPS OVH

nano initres.sh
#!/bin/bash
#
# To disable cloud-init's network configuration capabilities, write a file
# /etc/cloud/cloud.cfg.d/99-disable-network-config.cfg with the following:
# network: {config: disabled}
#
#Création du fichier **/etc/cloud/cloud.cfg.d/99-disable-network-config.cfg** en mode su
echo "network: {config: disabled}" > /etc/cloud/cloud.cfg.d/99-disable-network-config.cfg
#
# Effacerle fichier /etc/network/interfaces  
rm /etc/network/interfaces
# Recréer le fichier /etc/network/interfaces
cat > /etc/network/interfaces << EOF
auto lo
iface lo inet loopback

auto eth0
iface eth0 inet dhcp
iface eth0 inet6 static
 address 2010:3fc0:4dff:2400::afe5
 netmask 128
 post-up /sbin/ip -6 route add 2010:3fc0:4dff:2400::1 dev eth0
 post-up /sbin/ip -6 route add default via 2010:3fc0:4dff:2400::1 dev eth0
 pre-down /sbin/ip -6 route del default via 2010:3fc0:4dff:2400::1 dev eth0
 pre-down /sbin/ip -6 route del 2010:3fc0:4dff:2400::1 dev eth0
EOF
#
# Configuration OVH à modifier /etc/cloud/cloud.cfg 
sed -i 's/preserve_hostname: false/preserve_hostname: true/g' /etc/cloud/cloud.cfg
sed -i 's/manage_etc_hosts: true/manage_etc_hosts: false/g' /etc/cloud/cloud.cfg
#
# Redémarrage de la machine
systemctl reboot

Droits et exécution

chmod +x initres.sh && ./initres.sh

Patienter quelques minutes avant la reconnexion…

Se connecter en root via SSH

ssh root@59.12.235.121

Vérifier le réseau ip a

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether fa:16:3e:bd:0b:95 brd ff:ff:ff:ff:ff:ff
    inet 59.12.235.121/32 brd 59.12.235.121 scope global dynamic eth0
       valid_lft 86212sec preferred_lft 86212sec
    inet6 2010:3fc0:4dff:2400::afe5/128 scope global 
       valid_lft forever preferred_lft forever
    inet6 fe80::f816:3eff:febd:b95/64 scope link 
       valid_lft forever preferred_lft forever

Locales fr UTF8 : dpkg-reconfigure locales
Fuseau Europe/Paris : dpkg-reconfigure tzdata

domaine wgvpn.ovh

Zone dns OVH

$TTL 3600
@	IN SOA dns20.ovh.net. tech.ovh.net. (2020022809 86400 3600 3600000 300)
        IN NS     ns20.ovh.net.
        IN NS     dns20.ovh.net.
        IN A      59.12.235.121
        IN AAAA   2010:3fc0:4dff:2400::afe5

Reverse DNS sur “server”

Hostname

hostnamectl set-hostname wgvpn.ovh

Création utilisateur

Utilisateur wgadmin

useradd -m -d /home/wgadmin/ -s /bin/bash wgadmin

Mot de passe wgadmin

passwd wgadmin 

Visudo pour les accès root via utilisateur wgadmin

apt install sudo  # sudo installé par défaut
echo "wgadmin     ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers

Changer le mot de passe root

passwd root

Mise à jour

apt update && apt -y upgrade
reboot

OpenSSH, clé et script

connexion avec clé
sur l'ordinateur de bureau Générer une paire de clé curve25519-sha256 (ECDH avec Curve25519 et SHA2) nommé kvm-cinay pour une liaison SSH avec le serveur KVM.

ssh-keygen -t ed25519 -o -a 100 -f ~/.ssh/kvm-vps803434

Envoyer la clé publique sur le serveur KVM

scp ~/.ssh/kvm-vps803434.pub wgadmin@59.12.235.121:/home/wgadmin/

sur le serveur KVM On se connecte

ssh wgadmin@59.12.235.121

Copier le contenu de la clé publique dans /home/$USER/.ssh/authorized_keys

cd ~

Sur le KVM ,créer un dossier .ssh

mkdir .ssh
cat $HOME/kvm-vps803434.pub >> $HOME/.ssh/authorized_keys
chmod 600 $HOME/.ssh/authorized_keys  # donner les droits
rm $HOME/kvm-vps803434.pub  # effacer le fichier de la clé  

Modifier la configuration serveur SSH

sudo nano /etc/ssh/sshd_config

Modifier

Port 55037
PermitRootLogin no
PasswordAuthentication no

session SSH ne se termine pas correctement lors d'un "reboot" à distance
Si vous tentez de redémarrer/éteindre une machine distance par ssh, vous pourriez constater que votre session ne se termine pas correctement, vous laissant avec un terminal inactif jusqu’à l’expiration d’un long délai d’inactivité. Il existe un bogue 751636 à ce sujet. Pour l’instant, la solution de contournement à ce problème est d’installer :

sudo apt install libpam-systemd  # installé par défaut sur debian buster

cela terminera la session ssh avant que le réseau ne tombe.
Veuillez noter qu’il est nécessaire que PAM soit activé dans sshd.

Relancer openSSH

sudo systemctl restart sshd

Accès depuis le poste distant avec la clé privée

ssh -p 55037 -i ~/.ssh/kvm-vps803434 wgadmin@59.12.235.121

Installer utilitaires

sudo apt install rsync curl tmux jq figlet git dnsutils tree -y

Scripts motd et ssh_rc_bash

Motd

sudo nano /etc/motd
                 ___   __  ____ _ _  ____ _ _      
 __ __ _ __  ___( _ ) /  \|__ /| | ||__ /| | |     
 \ V /| '_ \(_-</ _ \| () ||_ \|_  _||_ \|_  _|    
  \_/ | .__//__/\___/ \__/|___/  |_||___/  |_|_    
 __ __|_| __ _ __ __ _ __  _ _      ___ __ __| |_  
 \ V  V // _` |\ V /| '_ \| ' \  _ / _ \\ V /| ' \ 
  \_/\_/ \__, | \_/ | .__/|_||_|(_)\___/ \_/ |_||_|
         |___/      |_|                            

Script ssh_rc_bash

ATTENTION!!! Les scripts sur connexion peuvent poser des problèmes pour des appels externes autres que ssh

nano ssh_rc_bash
#!/bin/bash

get_infos() {
    seconds="$(< /proc/uptime)"
    seconds="${seconds/.*}"
    days="$((seconds / 60 / 60 / 24)) jour(s)"
    hours="$((seconds / 60 / 60 % 24)) heure(s)"
    mins="$((seconds / 60 % 60)) minute(s)"
    
    # Remove plural if < 2.
    ((${days/ *} == 1))  && days="${days/s}"
    ((${hours/ *} == 1)) && hours="${hours/s}"
    ((${mins/ *} == 1))  && mins="${mins/s}"
    
    # Hide empty fields.
    ((${days/ *} == 0))  && unset days
    ((${hours/ *} == 0)) && unset hours
    ((${mins/ *} == 0))  && unset mins
    
    uptime="${days:+$days, }${hours:+$hours, }${mins}"
    uptime="${uptime%', '}"
    uptime="${uptime:-${seconds} seconds}"

   if [[ -f "/sys/devices/virtual/dmi/id/board_vendor" ||
                    -f "/sys/devices/virtual/dmi/id/board_name" ]]; then
	model="$(< /sys/devices/virtual/dmi/id/board_vendor)"
	model+=" $(< /sys/devices/virtual/dmi/id/board_name)"
   fi

   if [[ -f "/sys/devices/virtual/dmi/id/bios_vendor" ||
                    -f "/sys/devices/virtual/dmi/id/bios_version" ]]; then
        bios="$(< /sys/devices/virtual/dmi/id/bios_vendor)"
        bios+=" $(< /sys/devices/virtual/dmi/id/bios_version)"
        bios+=" $(< /sys/devices/virtual/dmi/id/bios_date)"
   fi
}

#clear
PROCCOUNT=`ps -Afl | wc -l`  		# nombre de lignes
PROCCOUNT=`expr $PROCCOUNT - 5`		# on ote les non concernées
GROUPZ=`users`
ipinfo=$(curl -s ipinfo.io) 		# info localisation format json
#ipinfo=$(curl -s iplocality.com) 		# info localisation format json
publicip=$(echo $ipinfo | jq -r '.ip')  # extraction des données , installer préalablement "jq"
ville=$(echo $ipinfo | jq -r '.city')
pays=$(echo $ipinfo | jq -r '.country')
cpuname=`cat /proc/cpuinfo |grep 'model name' | cut -d: -f2 | sed -n 1p`
iplink=`ip link show |grep -m 1 "2:" | awk '{print $2}' | cut -d: -f1`

if [[ $GROUPZ == *irc* ]]; then
ENDSESSION=`cat /etc/security/limits.conf | grep "@irc" | grep maxlogins | awk {'print $4'}`
PRIVLAGED="IRC Account"
else
ENDSESSION="Unlimited"
PRIVLAGED="Regular User"
fi
get_infos
logo=$(figlet "`hostname --fqdn`")
#meteo=$(curl fr.wttr.in/$ville?0)
sdx=$(df -h |grep "/dev/sd") # les montages /dev/sd
distri=$(lsb_release -sd)
distri+=" $(uname -m)"

echo -e "
\e[1;31m$logo
\e[1;35m   \e[1;37mHostname \e[1;35m= \e[1;32m`hostname`
\e[1;35m \e[1;37mWired IpV4 \e[1;35m= \e[1;32m`ip addr show $iplink | grep 'inet\b' | awk '{print $2}' | cut -d/ -f1`
\e[1;35m \e[1;37mWired IpV6 \e[1;35m= \e[1;32m`ip addr show $iplink | grep -E 'inet6' |grep -E 'scope link' | awk '{print $2}' | cut -d/ -f1`
\e[1;35m     \e[1;37mKernel \e[1;35m= \e[1;32m`uname -r`
\e[1;35m    \e[1;37mDistrib \e[1;35m= \e[1;32m$distri
\e[1;35m     \e[1;37mUptime \e[1;35m= \e[1;32m`echo $uptime`
\e[1;35m       \e[1;37mBios \e[1;35m= \e[1;32m`echo $bios`
\e[1;35m      \e[1;37mBoard \e[1;35m= \e[1;32m`echo $model`
\e[1;35m        \e[1;37mCPU \e[1;35m= \e[1;32m`echo $cpuname`
\e[1;35m \e[1;37mMemory Use \e[1;35m= \e[1;32m`free -m | awk 'NR==2{printf "%s/%sMB (%.2f%%)\n", $3,$2,$3*100/$2 }'`
\e[1;35m   \e[1;37mUsername \e[1;35m= \e[1;32m`whoami`
\e[1;35m   \e[1;37mSessions \e[1;35m= \e[1;32m`who | grep $USER | wc -l`
\e[1;35m\e[1;37mPublic IpV4 \e[1;35m= \e[1;32m`echo $publicip`
\e[1;35m\e[1;37mPublic IpV6 \e[1;35m= \e[1;32m`ip addr show $iplink | grep -m 1 'inet6\b'  | awk '{print $2}' | cut -d/ -f1`
\e[1;35m\e[1;33m$sdx
\e[1;0m
"
chmod +x ssh_rc_bash # rendre le bash exécutable
./ssh_rc_bash        # exécution

Wireguard SERVEUR

WireGuard

Toutes les commandes qui suivent se font en mode su ou sudo -s

Installer wireguard

Notez que comme le module du noyau est construit avec dkms, vous devez vous assurer que vous avez redémarré avec votre dernière mise à jour du noyau avant de l’installer.

Le processus d’installation est basé sur Debian. La documentation concernant les autres plates-formes est disponible sur le site Web de WireGuard

Modification des dépôts

echo "deb http://deb.debian.org/debian/ unstable main" | sudo tee /etc/apt/sources.list.d/unstable-wireguard.list
printf 'Package: *\nPin: release a=unstable\nPin-Priority: 90\n' | sudo tee /etc/apt/preferences.d/limit-unstable
apt update
apt install linux-headers-$(uname --kernel-release)
apt install wireguard 

Pour vérifier que le module du noyau WireGuard est chargé, vous pouvez exécuter modprobe wireguard et ensuite :

lsmod |grep wireguard
wireguard             229376  0
ip6_udp_tunnel         16384  1 wireguard
udp_tunnel             16384  1 wireguard

Générer une paire de clés

WireGuard repose sur une authentification par clé publique/privée (cryptographie asymétrique), vous devez donc créer ces clés avec les sous-commandes wg genkey et wg pubkey
La création de la clé privée se fait avec wg genkey et la clé publique est générée en la canalisant dans wg pubkey

wg genkey | tee wgvpn.ovh-private.key | wg pubkey > wgvpn.ovh-public.key

Autoriser le serveur Wireguard à relayer les paquets

Autoriser le serveur Wireguard à relayer les paquets venant de ces clients vers l’internet et de traiter les paquets retours (modifier /etc/sysctl.conf)

sed -i 's/^#net.ipv4.ip_forward=1/net.ipv4.ip_forward=1/' /etc/sysctl.conf
sed -i 's/^#net.ipv6.conf.all.forwarding=1/net.ipv6.conf.all.forwarding=1/' /etc/sysctl.conf
sysctl -p # prise en compte immédiate

Fichier de configuration wg0.conf

Récupérer le nom de la carte réseau ip a , dans notre cas eth0

La première étape consiste à choisir une plage IPV4 qui sera utilisée par le serveur. Les plages d’adresses IP privées définies par la RFC 19198 sont les suivantes:

10.41.38.0/8
172.16.0.0/12
192.168.0.0/16

Pour une adresse IPV6 ,on la génère aléatoirement (préfixe fd)

openssl rand -hex 5 

12edf342c0 → fd12:edf3:42c0::/48 Avec ce préfixe, 65 536 sous-réseaux de taille / 64 sont disponibles pour le réseau privé: fd12:edf3:42c0:: / 64 à fd12:edf3:42c0:ffff:/ 64 .

Pour ce didacticiel, nous utiliserons 10.41.38.0/24 qui se trouve dans la plage 10.41.38.0/8 . Le serveur aura l’adresse IP suivante: 10.41.38.1 . Il est également nécessaire de choisir un port, qui sera exposé publiquement, pour que le serveur écoute.Le port de documentation standard est généralement 51820.

Créer le fichier /etc/wireguard/wg0.conf

[Interface]
Address = 10.41.38.1/24
Address = fd12:edf3:42c0::1/64
ListenPort = 51820
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE; ip6tables -A FORWARD -i wg0 -j ACCEPT; ip6tables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE; ip6tables -D FORWARD -i wg0 -j ACCEPT; ip6tables -t nat -D POSTROUTING -o eth0 -j MASQUERADE
PrivateKey = MKRVedJrgKSrfu9kKyPXMrDeCQGdCzea557duZ6uNGY=
SaveConfig = true

Address , fixer l’adresse IP privée du serveur à l’intérieur du VPN.Les adresses du réseau VPN de 10.41.38.0 à 10.41.38.255 sont fixées par le masque /24
PostUp , pour la mise en place des règles iptables de translation d’adresses à l’activation du VPN (autoriser le routage des paquets réseau venant des clients vers internet)
PostDown , pour la suppression des règles iptables de translation d’adresses à l’arrêt du VPN
PrivateKey , clé privée du serveur

Modification des droits (lecture uniquement par “root”)

chmod 600 /etc/wireguard/wg0.conf

Parefeu - UFW

Installation

sudo apt install ufw

Status

sudo ufw status verbose
    Status: inactive

Les règles

sudo ufw allow 55037/tcp  # port SSH , 55037
sudo ufw allow DNS        # port 53
sudo ufw allow 51820/udp  # wireguard

Activer le parefeu

sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Status

 sudo ufw status verbose
Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), deny (routed)
New profiles: skip

To                         Action      From
--                         ------      ----
55037/tcp                  ALLOW IN    Anywhere                  
53 (DNS)                   ALLOW IN    Anywhere                  
51820/udp                  ALLOW IN    Anywhere                  
55037/tcp (v6)             ALLOW IN    Anywhere (v6)             
53 (DNS (v6))              ALLOW IN    Anywhere (v6)             
51820/udp (v6)             ALLOW IN    Anywhere (v6)             

DNS Unbound

Un problème majeur avec beaucoup de configurations VPN est que le DNS n’est pas suffisant. Cela finit par une fuite de connexion client et de détails d’emplacement. Un bon moyen de tester cela est à travers le site http://dnsleak.com/

Nous allons sécuriser le trafic DNS avec la solution unbound qui offre les caractéristiques suivantes

  • Léger et rapide
  • Facile à installer et à configurer
  • Orienté sécurité
  • Prise en charge DNSSEC

Nous allons le configurer de manière à contrer les fuites DNS, les attaques plus sophistiquées comme la fausse configuration de proxy, les routeurs escrocs et toutes sortes d’attaques MITM sur HTTPS et autres protocoles.

Nous installons unbound sur le serveur
Passage en mode super utilisateur

sudo -s # ou su

Désinstaller bind

apt remove --purge bind* -y
rm -r /var/cache/bind/

Installation des outils dns et du paquet Unbound :

apt install dnsutils unbound unbound-host -y

Téléchargement de la liste des serveurs DNS racines

curl -o /var/lib/unbound/root.hints https://www.internic.net/domain/named.cache
chown unbound:unbound /var/lib/unbound/root.hints

Ajout d’un fichier de configuration dns-wgvpn.ovh.conf

cat > /etc/unbound/unbound.conf.d/dns-wgvpn.ovh.conf << ENDOFFILE
server:
    num-threads: 4

    # enable logs
    verbosity: 1

    # liste des serveurs DNS racine
    root-hints: "/var/lib/unbound/root.hints"

    # Répondre aux requêtes DNS sur toutes les interfaces
    interface: 0.0.0.0                          # 0.0.0.0 unbound sur plusieurs interfaces
    interface: ::0
    max-udp-size: 3072

    # IPs authorised to access the DNS Server
    access-control: 0.0.0.0/0                 refuse
    access-control: ::/0                      refuse
    access-control: 127.0.0.1                 allow
    access-control: 10.41.38.0/24             allow

    # not allowed to be returned for public Internet  names
    private-address: 10.41.38.0/24

    #hide DNS Server info
    hide-identity: yes
    hide-version: yes

    # limit DNS fraud and use DNSSEC
    harden-glue: yes
    harden-dnssec-stripped: yes
    harden-referral-path: yes

    # add an unwanted reply threshold to clean the cache and avoid, when possible, DNS poisoning
    unwanted-reply-threshold: 10000000

    # have the validator print validation failures to the log
    val-log-level: 1

    # minimum lifetime of cache entries in seconds
    cache-min-ttl: 1800

    # maximum lifetime of cached entries in seconds
    cache-max-ttl: 14400
    prefetch: yes
    prefetch-key: yes
ENDOFFILE

Droits

chown -R unbound:unbound /var/lib/unbound

Pour vérifier si le fichier de configuration est valide

unbound-checkconf /etc/unbound/unbound.conf.d/dns-wgvpn.ovh.conf

unbound-checkconf: no errors in /etc/unbound/unbound.conf.d/dns-wgvpn.ovh.conf
Désactiver systemd-resolved (si utilisé)

systemctl stop systemd-resolved
systemctl disable systemd-resolved

Activer Unbound

systemctl enable unbound-resolvconf
systemctl enable unbound

Le programme resolvconf est en général seulement nécessaire quand un système a plusieurs programmes qui ont besoin de modifier de façon dynamique les informations sur les serveurs de noms de domaine. Sur un système simple où les serveurs de noms de domaine ne changent pas souvent ou bien ne sont modifiés que par un programme, le fichier de configuration **resolv.conf** est suffisant.

Il faut installer resolvconf, sinon on a une erreur unbound-resolvconf

systemctl status unbound-resolvconf
[...]
Condition: start condition failed at Thu 2020-03-19 11:13:56 CET; 1min 48s ago
           └─ ConditionFileIsExecutable=/sbin/resolvconf was not met

Installer resolvconf

apt install resolvconf -y
echo "nameserver 127.0.0.1" >> /etc/resolvconf/resolv.conf.d/head

Une fois le paquet « resolvconf » installé, il ne faut plus modifier le fichier « /etc/resolv.conf », car le contenu de celui-ci sera automatiquement géré et remplacé par « resolvconf ».

Redémarrer le serveur

systemctl reboot

Après redémarrage

systemctl status unbound unbound-resolvconf resolvconf
● unbound.service - Unbound DNS server
   Loaded: loaded (/lib/systemd/system/unbound.service; enabled; vendor preset: enabled)
   Active: active (running) since Thu 2020-03-19 11:28:28 CET; 39s ago
     Docs: man:unbound(8)
  Process: 597 ExecStartPre=/usr/lib/unbound/package-helper chroot_setup (code=exited, status=0/SUCCESS)
  Process: 638 ExecStartPre=/usr/lib/unbound/package-helper root_trust_anchor_update (code=exited, status=0
 Main PID: 645 (unbound)
    Tasks: 4 (limit: 2319)
   Memory: 25.9M
   CGroup: /system.slice/unbound.service
           └─645 /usr/sbin/unbound -d

● unbound-resolvconf.service - Unbound DNS server via resolvconf
   Loaded: loaded (/lib/systemd/system/unbound-resolvconf.service; enabled; vendor preset: enabled)
   Active: active (exited) since Thu 2020-03-19 11:28:29 CET; 39s ago
  Process: 650 ExecStart=/usr/lib/unbound/package-helper resolvconf_start (code=exited, status=0/SUCCESS)
 Main PID: 650 (code=exited, status=0/SUCCESS)

● resolvconf.service - Nameserver information manager
   Loaded: loaded (/lib/systemd/system/resolvconf.service; enabled; vendor preset: enabled)
   Active: active (exited) since Thu 2020-03-19 11:28:23 CET; 45s ago
     Docs: man:resolvconf(8)
  Process: 222 ExecStartPre=/bin/mkdir -p /run/resolvconf/interface (code=exited, status=0/SUCCESS)
  Process: 227 ExecStartPre=/bin/touch /run/resolvconf/postponed-update (code=exited, status=0/SUCCESS)
  Process: 234 ExecStart=/sbin/resolvconf --enable-updates (code=exited, status=0/SUCCESS)
 Main PID: 234 (code=exited, status=0/SUCCESS)

Vérifications

Les commandes suivantes ne fonctionneront que si le paquet “dnsutils” est installé sur votre système Debian!

On teste en utilisant les serveurs DNS locaux

dig @127.0.0.1 afnic.fr +short +dnssec
192.134.5.37
A 13 2 600 20200319182329 20200219022911 31668 afnic.fr. bMxN0xyTue0NxSQKymDXo2rOvmulhWXymRRaactToNKXj1oX6Q/JPS9v 8fDJPdwqua8izfiYpN1BrNWTMCPj/A==

Si wireguard est lancé

dig @10.41.38.1 afnic.fr +short +dnssec
192.134.5.37
A 13 2 600 20200405050443 20200305173434 31668 afnic.fr. IS+v1tYSBZoMLCsvQJakwGEa6N3XNOjueVmFG/tmviJnvAwJ55GkvhVO XrI9n1cyTsWprQ98pgLlz3MUl7NeJA==

Démarrer/Arrêter WireGuard

wg-quick

Activer le VPN avec les commandes wg-quick up wg0 et wg show

sudo wg-quick up wg0
[#] ip link add wg0 type wireguard
[#] wg setconf wg0 /dev/fd/63
[#] ip -4 address add 10.41.38.1/24 dev wg0
[#] ip -6 address add fd12:edf3:42c0::1/64 dev wg0
[#] ip link set mtu 1420 up dev wg0
[#] iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE; ip6tables -A FORWARD -i wg0 -j ACCEPT; ip6tables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
wg show
interface: wg0
  public key: 8eBYYS/xuJR6Uh/27CWbOWbRvdjxzdp9Mmy8NhJdDw4=
  private key: (hidden)
  listening port: 51820

Arrêt du serveur VPN

sudo wg-quick down wg0
[#] wg showconf wg0
[#] ip link delete dev wg0
[#] iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE; ip6tables -D FORWARD -i wg0 -j ACCEPT; ip6tables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

Wireguard CLIENTS

Installation client wireguard

Debian

  • Voir chapitre précédent Wireguard SERVEUR → Installer wireguard

Archlinux

Installer les en-têtes et DKMS du noyau Linux et WireGuard.

linux-headers # for the default linux kernel
linux-lts-headers # for the LTS linux-lts kernel

sudo pacman -S linux-headers wireguard-dkms wireguard-tools

Les paquets suivants seront installés: dkms linux-headers wireguard-dkms wireguard-tools
Pour vérifier que le module du noyau WireGuard est chargé, vous devez exécuter sudo modprobe wireguard et ensuite :

lsmod |grep wireguard
wireguard             217088  0
ip6_udp_tunnel         16384  1 wireguard
udp_tunnel             16384  1 wireguard

Manjaro

Définir les en-têtes à télécharger

uname -r  # renvoie la version du noyau
    5.4.27-1-MANJARO
# il faut installer linux54-headers  ( `pacman -Ss linux-headers` pour voir la liste complète)

Installer les en-têtes et DKMS du noyau Linux et WireGuard.

sudo pacman -S linux54-headers wireguard-dkms wireguard-tools

Android

Télécharger l’application wireguard sur le dépôt libre Fdroïd.

Raspberry PI

Installation Wireguard

echo "deb http://deb.debian.org/debian/ unstable main" | sudo tee --append /etc/apt/sources.list.d/unstable.list
sudo apt-key adv --keyserver   keyserver.ubuntu.com --recv-keys 04EE7237B7D453EC 
sudo apt-key adv --keyserver   keyserver.ubuntu.com --recv-keys 648ACFD622F3D138 
sudo sh -c 'printf "Package: *\nPin: release a=unstable\nPin-Priority: 90\n" > /etc/apt/preferences.d/limit-unstable'
sudo apt update
sudo apt install wireguard -y

echo 'deb https://deb.debian.org/debian/ sid main' | sudo tee --append /etc/apt/sources.list.d/wireguard.list
echo -e 'Package: *\nPin: release n=sid\nPin-Priority: -1\n\nPackage: wireguard wireguard-dkms wireguard-tools\nPin: release n=sid\nPin-Priority: 99' | sudo tee /etc/apt/preferences.d/wireguard
wget https://dietpi.com/downloads/binaries/rpi/debian-archive-keyring.deb
sudo dpkg -i debian-archive-keyring.deb
sudo rm debian-archive-keyring.deb
sudo apt update
sudo apt list --upgradable
sudo apt install wireguard -y

Maintenant que l’installation est terminée, il est possible de passer à la Configuration client Raspberry de WireGuard.

Configurer le client wireguard

Le processus de configuration d’un client est similaire à celui de la configuration du serveur.
La seule différence entre le client et le serveur est le contenu du fichier de configuration.

  1. Générez une paire de clés pour le client si vous ne l’avez pas encore fait :
    wg genkey | tee wgvpn.ovh-clientx-private.key | wg pubkey > wgvpn.ovh-clientx-public.key
    x prend la valeur 1,2,3,etc…
  2. La principale différence entre le client et le fichier de configuration du serveur, wg0.conf, est qu’il doit contenir ses propres adresses IP et ne contient pas les valeurs ListenPort, PostUP, PostDown et SaveConfig.

Debian, Archlinux et Raspberry PI

Créer le fichier /etc/wireguard/wg0.conf dans la machine cliente

[Interface]
# on définit un réseau (IPV4/24, IPV6/64) auquel l'interface appartient
# .1 est le serveur donc les clients .2,.3,.4,etc...
Address = 10.41.38.2/24  , fd12:edf3:42c0::2/64
# contenu de la clé privée client 
PrivateKey = YAutvmvC0iUA35Pi3HJUuEwd3+SLCct7Xju954yr+Wg=

Address , adresses IPV4/IPV6 du client PrivateKey , la clé privée du client

Modification des droits (lecture uniquement par “root”)

chmod 600 /etc/wireguard/wg0.conf

Android (QR Code)

On va utiliser le répertoire /etc/wireguard/ d’un client pour générer notre jeu de clés android

sudo -s
cd /etc/wireguard/
wg genkey > privatekey_android
chmod 600 privatekey_android
wg pubkey < privatekey_android > publickey_android 

Créer un fichier wg0-android.conf

[Interface]
# Android
# le /24 est important : on définit un réseau (/24) auquel l'interface appartient
# idem /64 pour IPV6
Address = 10.41.38.4/24  , fd12:edf3:42c0::4/64
# privatekey client android
PrivateKey = LAui3HJUtvmvC0iU7YA35Pyr++SXjuEwd3u954WCctg=
# DNS local
DNS = 10.41.38.1

# On définit qui est le "serveur"
[Peer]
# contenu de /etc/wireguard/publickey du serveur
PublicKey = zrEsig3QOdNFSnKhOG7Hq5Cl2yaccHTndtyWLGhAddK=
# L'utilisation de l'option fourre-tout AllowedIPs = 0.0.0.0/0, ::/0 
# fera passer tout le trafic IPv4 (0.0.0.0/0) et IPv6 (::/0) sur le VPN. 
AllowedIPs = 0.0.0.0/0 , ::/0
# IP publique du serveur et port d'entrée
EndPoint = 59.12.235.121:51820
# En général les clients sont derrière du NAT, et si on veut que le serveur puisse joindre le client à tout moment, il faut :
PersistentKeepalive = 15

Le fichier de configurarion android sera tranmis sur l’appareil à partir d’un QR code

sudo apt install qrcode                # debian
sudo pacman -S pacman -S qrencode zbar # archlinux

Créer le Qr Code

qrencode -t ansiutf8 < /etc/wireguard/wg0-client.conf    # QR code sur le terminal
qrencode -t PNG -o wgandroid.png < wg0-android.conf # QR code dans un fichier

Qr code correspondant à la configuration vpn android
Il ne reste plus qu’à scanner et à importer le fichier dans l’application WireGuard android installée précédemment.

Ouvrir WireGuard QR code Saisie
Activer wgvpn OK Connexion active
Ouvrir https://ipleak.net On est bien sur le serveur WireGuard  

Wireguard Connecter le client et le serveur

Les fichiers de configuration clients wg0.conf sont créés dans chaque machine

Note : Arrêtez l’interface avec sudo wg-quick down wg0 sur le client et le serveur.

CLIENT

La première méthode consiste à modifier directement le fichier wg0.conf du client en ajoutant la clé publique, l’adresse IP publique et le port du serveur :

/etc/wireguard/wg0.conf
# On définit qui est le "serveur"
[Peer]
# contenu de la clé publique du serveur
PublicKey = zrEsig3QOdNFSnKhOG7Hq5Cl2yaccHTndtyWLGhAddK=
# L'utilisation de l'option fourre-tout AllowedIPs = 0.0.0.0/0, ::/0 
# fera passer tout le trafic IPv4 (0.0.0.0/0) et IPv6 (::/0) sur le VPN. 
AllowedIPs = 0.0.0.0/0 , ::/0
# IP publique ou domaine du serveur et port d'entrée
EndPoint = 59.12.235.121:51820
# En général les clients sont derrière du NAT, et si on veut que le serveur puisse joindre le client à tout moment, il faut :
PersistentKeepalive = 15

PublicKey , la clé publique du serveur
AllowedIPs , Tout le traffic client sera envoyé dans le tunnel VPN
EndPoint , adresse IP du serveur

SERVEUR

Il faut reporter les informations du client sur le serveur , en ajoutant ce qui suit au fichier de configuration /etc/wireguard/wg0.conf

[Peer]
# Clé publique du client
PublicKey = 7Oj1PWGth6lBjGwvQvld8qAVfzEOMJq1g40jRKJWcKD=
AllowedIPs = 10.41.38.2/32 , fd12:edf3:42c0::2/128

AllowedIPs = 10.41.38.2/32 offre une sécurité accrue en garantissant que seul un client ayant l’IP 10.200.200.2 et la bonne clé privée sera autorisé à s’authentifier sur le tunnel VPN .
PublicKey , la clé publique du client

TRES IMPORTANT, le serveur VPN doit être stoppé sudo wg-quick down wg0 pour éviter l’écrasement du fichier de configuration provoqué par l’arrêt du VPN.

Pour ne pas générer de coupure , exécuter cette commande

sudo wg set wg0 peer 'CLE_PUBLIQUE_CLIENT' allowed-ips 'IPV4_CLIENT/32, IPV6_CLIENT/128'
# ce qui donne en référence par exemple 
sudo wg set wg0 peer '7Oj1PWGth6lBjGwvQvld8qAVfzEOMJq1g40jRKJWcKD=' allowed-ips '10.41.38.2/32, fd12:edf3:42c0::2/128'

Cette section Peer sera automatiquement ajoutée à wg0.conf lorsque le service sera redémarré. Si vous souhaitez ajouter cette information immédiatement au fichier de configuration, vous pouvez l’exécuter :

wg-quick save wg0

Des clients supplémentaires peuvent être ajoutés en utilisant la même procédure.

Activer le service wg sur le client et le serveur

wg-quick up wg0
systemctl enable wg-quick@wg0