#!/bin/bash

#Code couleur
RED='\033[0;31m'
ORANGE='\033[0;33m'
NC='\033[0m'
GREEN='\033[0;32m'
#

function isRoot() {
	if [ "${EUID}" -ne 0 ]; then
		echo "Vous devez exécuter ce script en tant que root"
		exit 1
	fi
}

function checkOS() {
	# Vérifie la version du système d'exploitation (RockyLinux)
	if [[ -e /etc/rocky-release ]]; then
		source /etc/os-release
		OS=rocky
	elif [[ -e /etc/os-release ]]; then
		source /etc/os-release
		OS="ubuntu"
	elif [[ -e /etc/os-release ]]; then
		source /etc/os-release
		OS="debian"
	else
		echo "Il semble que vous n'exécutez pas ce programme d'installation sur un système compatible"
		exit 1
	fi
}

function initialCheck() {
	checkOS
	isRoot
}

function installQuestions() {
	echo -e "\n${GREEN}Bienvenue dans le programme d'installation de WireGuard !${NC}"
	echo ""
	echo "Avant de continuer je dois vous poser quelques questions."
	echo "Vous pouvez laisser les options par défaut et appuyer simplement sur Entrée si elles vous conviennent."
	echo ""

	# Détecter l'adresse IPv4 publique et pré-remplir pour l'utilisateur
	SERVER_PUB_IP=$(wget -qO- icanhazip.com)
	if [[ ${SERVER_PUB_IP} ]]; 
        then
	    read -rp "Adresse publique IPv4 : " -e -i "${SERVER_PUB_IP}" SERVER_PUB_IP
	
	# Détecter l'interface publique et pré-remplir pour l'utilisateur
	SERVER_NIC="$(ip -4 route ls | grep default | grep -Po '(?<=dev )(\S+)' | head -1)"
	until [[ ${SERVER_PUB_NIC} =~ ^[a-zA-Z0-9_]+$ ]]; do
	    read -rp "Interface LAN (Public)  : " -e -i "${SERVER_NIC}" SERVER_PUB_NIC
	done

	until [[ ${SERVER_WG_NIC} =~ ^[a-zA-Z0-9_]+$ && ${#SERVER_WG_NIC} -lt 16 ]]; do
            read -rp "Nom de l'interface WireGuard (Vous pouvez mettre ce que vous voulez) : " -e -i wg0 SERVER_WG_NIC
	done

	until [[ ${SERVER_WG_IPV4} =~ ^([0-9]{1,3}\.){3} ]]; do
	    read -rp "IPv4 du tunel WireGuard (à modifier si vous le voulez) : " -e -i 10.8.0.1 SERVER_WG_IPV4
	done

	# Générer un nombre aléatoire dans la plage de ports privés
	RANDOM_PORT=$(shuf -i49152-65535 -n1)
	until [[ ${SERVER_PORT} =~ ^[0-9]+$ ]] && [ "${SERVER_PORT}" -ge 1 ] && [ "${SERVER_PORT}" -le 65535 ]; do
            read -rp "Port du serveur WireGuard [1-65535]: " -e -i "${RANDOM_PORT}" SERVER_PORT
	done

	# FFDN DNS par défaut
	until [[ ${CLIENT_DNS_1} =~ ^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$ ]]; do
            read -rp "Premier résolveur DNS à utiliser pour les clients : " -e -i 80.67.169.12 CLIENT_DNS_1
	done
	until [[ ${CLIENT_DNS_2} =~ ^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$ ]]; do
            read -rp "Deuxième résolveur DNS à utiliser pour les clients (facultatif) : " -e -i 80.67.169.40 CLIENT_DNS_2
	    if [[ ${CLIENT_DNS_2} == "" ]]; then
	        CLIENT_DNS_2="${CLIENT_DNS_1}"
	    fi
	done

	echo ""
	echo "D'accord, c'était tout ce dont j'avais besoin. Nous sommes prêts à configurer votre serveur WireGuard maintenant."
	echo "Vous pourrez générer un client à la fin de l'installation avec un fichier de configuration et un QRCode"
	read -n1 -r -p "Appuyez sur n'importe quelle touche pour continuer..."
fi
}

function installWireGuard() {
	# Exécutez d'abord les questions de configuration
	installQuestions

	# Installer les outils et le module WireGuard
	if [[ ${OS} == 'rocky' ]]; then
		dnf install epel-release elrepo-release -y 
			dnf update -y && dnf install kmod-wireguard wireguard-tools iptables qrencode -y
	
	elif [[ ${OS} == 'ubuntu' ]]; then
		apt update -y
			apt install wireguard iptables resolvconf qrencode -y

	elif [[ ${OS} == 'debian' ]]; then
		apt update -y
			apt install wireguard iptables resolvconf qrencode -y
			# Activer le service resolvconf
    		systemctl enable resolvconf
			# Ajouter les serveurs DNS à la configuration resolvconf
    		echo "nameserver ${CLIENT_DNS_1}" > /etc/resolvconf/resolv.conf.d/base
    		echo "nameserver ${CLIENT_DNS_2}" >> /etc/resolvconf/resolv.conf.d/base
			# Mettre à jour la configuration resolvconf
    		resolvconf -u
				# Redémarrer le service réseau pour que les modifications prennent effet
				systemctl restart networking
	fi

	# Assurez que le répertoire existe
	mkdir /etc/wireguard >/dev/null 2>&1

	chmod 600 -R /etc/wireguard/

	SERVER_PRIV_KEY=$(wg genkey)
	SERVER_PUB_KEY=$(echo "${SERVER_PRIV_KEY}" | wg pubkey)

	# Enregistrer les paramètres WireGuard
	echo "SERVER_PUB_IP=${SERVER_PUB_IP}
SERVER_PUB_NIC=${SERVER_PUB_NIC}
SERVER_WG_NIC=${SERVER_WG_NIC}
SERVER_WG_IPV4=${SERVER_WG_IPV4}
SERVER_PORT=${SERVER_PORT}
SERVER_PRIV_KEY=${SERVER_PRIV_KEY}
SERVER_PUB_KEY=${SERVER_PUB_KEY}
CLIENT_DNS_1=${CLIENT_DNS_1}
CLIENT_DNS_2=${CLIENT_DNS_2}" >/etc/wireguard/params

	# Ajouter une interface serveur
	echo "[Interface]
Address = ${SERVER_WG_IPV4}/24
ListenPort = ${SERVER_PORT}
PrivateKey = ${SERVER_PRIV_KEY}" >"/etc/wireguard/${SERVER_WG_NIC}.conf"

	if pgrep firewalld; then
		FIREWALLD_IPV4_ADDRESS=$(echo "${SERVER_WG_IPV4}" | cut -d"." -f1-3)".0"
		echo "PostUp = firewall-cmd --add-port ${SERVER_PORT}/udp && firewall-cmd --add-rich-rule='rule family=ipv4 source address=${FIREWALLD_IPV4_ADDRESS}/24 masquerade'
PostDown = firewall-cmd --remove-port ${SERVER_PORT}/udp && firewall-cmd --remove-rich-rule='rule family=ipv4 source address=${FIREWALLD_IPV4_ADDRESS}/24 masquerade'" >>"/etc/wireguard/${SERVER_WG_NIC}.conf"
	else
		echo "PostUp = iptables -A FORWARD -i ${SERVER_PUB_NIC} -o ${SERVER_WG_NIC} -j ACCEPT; iptables -A FORWARD -i ${SERVER_WG_NIC} -j ACCEPT; iptables -t nat -A POSTROUTING -o ${SERVER_PUB_NIC} -s 10.8.0.0/24 -j MASQUERADE; ip6tables -A FORWARD -i ${SERVER_WG_NIC} -j ACCEPT; ip6tables -t nat -A POSTROUTING -o ${SERVER_PUB_NIC} -j MASQUERADE
PostDown = iptables -D FORWARD -i ${SERVER_PUB_NIC} -o ${SERVER_WG_NIC} -j ACCEPT; iptables -D FORWARD -i ${SERVER_WG_NIC} -j ACCEPT; iptables -t nat -D POSTROUTING -o ${SERVER_PUB_NIC} -j MASQUERADE; ip6tables -D FORWARD -i ${SERVER_WG_NIC} -j ACCEPT; ip6tables -t nat -D POSTROUTING -o ${SERVER_PUB_NIC} -j MASQUERADE" >>"/etc/wireguard/${SERVER_WG_NIC}.conf"
	fi

	# Activer le routage sur le serveur
	echo "net.ipv4.ip_forward = 1" >/etc/sysctl.d/wg.conf

	sysctl --system

	systemctl start "wg-quick@${SERVER_WG_NIC}"
	systemctl enable "wg-quick@${SERVER_WG_NIC}"

	newClient
	echo "Si vous souhaitez ajouter d'autres clients, il vous suffit d'exécuter ce script une autre fois !"

	# Vérifiez si WireGuard est en cours d'exécution
	systemctl is-active --quiet "wg-quick@${SERVER_WG_NIC}"
	WG_RUNNING=$?

	# WireGuard pourrait ne pas fonctionner si nous mettions à jour le noyau. Dit à l'utilisateur de redémarrer.
	if [[ ${WG_RUNNING} -ne 0 ]]; then
		echo -e "\n${RED}AVERTISSEMENT : WireGuard ne semble pas fonctionner.${NC}"
		echo -e "${ORANGE}Vous pouvez vérifier si WireGuard fonctionne avec : systemctl status wg-quick@${SERVER_WG_NIC}${NC}"
		echo -e "${ORANGE}Si vous obtenez quelque chose comme \"Impossible de trouver l'appareil ${SERVER_WG_NIC}\", s'il vous plaît redémarrez !${NC}"
	fi
}

function newClient() {
	ENDPOINT="${SERVER_PUB_IP}:${SERVER_PORT}"

	echo ""
	echo "Donnez moi un nom pour le client."
	echo "Le nom doit être composé de caractères alphanumériques. Il peut également inclure un trait de soulignement ou un tiret et ne peut pas dépasser 15 caractères."

	until [[ ${CLIENT_NAME} =~ ^[a-zA-Z0-9_-]+$ && ${CLIENT_EXISTS} == '0' && ${#CLIENT_NAME} -lt 16 ]]; do
		read -rp "Nom du client : " -e CLIENT_NAME
		CLIENT_EXISTS=$(grep -c -E "^### Client ${CLIENT_NAME}\$" "/etc/wireguard/${SERVER_WG_NIC}.conf")

		if [[ ${CLIENT_EXISTS} == '1' ]]; then
			echo ""
			echo "Un client avec le nom spécifié a déjà été créé, veuillez choisir un autre nom."
			echo ""
		fi
	done

	for DOT_IP in {2..254}; do
		DOT_EXISTS=$(grep -c "${SERVER_WG_IPV4::-1}${DOT_IP}" "/etc/wireguard/${SERVER_WG_NIC}.conf")
		if [[ ${DOT_EXISTS} == '0' ]]; then
			break
		fi
	done

	if [[ ${DOT_EXISTS} == '1' ]]; then
		echo ""
		echo "Le sous-réseau configuré ne prend en charge que 253 clients."
		exit 1
	fi

	BASE_IP=$(echo "$SERVER_WG_IPV4" | awk -F '.' '{ print $1"."$2"."$3 }')
	until [[ ${IPV4_EXISTS} == '0' ]]; do
		read -rp "IPv4 du client WireGuard : ${BASE_IP}." -e -i "${DOT_IP}" DOT_IP
		CLIENT_WG_IPV4="${BASE_IP}.${DOT_IP}"
		IPV4_EXISTS=$(grep -c "$CLIENT_WG_IPV4/24" "/etc/wireguard/${SERVER_WG_NIC}.conf")

		if [[ ${IPV4_EXISTS} == '1' ]]; then
			echo ""
			echo "Un client avec l'IPv4 spécifié a déjà été créé, veuillez choisir un autre IPv4."
			echo ""
		fi
	done

	# Générer une paire de clés pour le client
	CLIENT_PRIV_KEY=$(wg genkey)
	CLIENT_PUB_KEY=$(echo "${CLIENT_PRIV_KEY}" | wg pubkey)
	CLIENT_PRE_SHARED_KEY=$(wg genpsk)

	# Répertoire personnel de l'utilisateur, où sera écrite la configuration du client
	mkdir /Wireguard
	if [ -e "/Wireguard" ]; then
		# si $1 est un nom d'utilisateur
		HOME_DIR="/Wireguard"
	elif [ "${SUDO_USER}" ]; then
		# sinon, utilisez SUDO_USER
		if [ "${SUDO_USER}" == "root" ]; then
			# Si vous exécutez sudo en tant que root
			HOME_DIR="/Wireguard"
		else
			HOME_DIR="/Wireguard"
		fi
	else
		# sinon SUDO_USER, utilisez /root
		HOME_DIR="/Wireguard"
	fi

# Créer une liste vide pour stocker les réseaux locaux
local_networks=()

# Demander à l'utilisateur d'entrer les réseaux locaux
while true; do
    read -rp "Entrez un réseau local (ou 'q' pour quitter) : " network
    if [[ $network == "q" ]]; then
        break
    fi
    local_networks+=("$network")
done

# Convertir la liste des réseaux locaux en une seule chaîne, séparée par des virgules
allowed_ips=$(IFS=,; echo "${local_networks[*]}")

# Créer un fichier client et ajouter le serveur en tant que pair
echo "[Interface]
PrivateKey = ${CLIENT_PRIV_KEY}
Address = ${CLIENT_WG_IPV4}/32
DNS = ${CLIENT_DNS_1},${CLIENT_DNS_2}

[Peer]
PublicKey = ${SERVER_PUB_KEY}
PresharedKey = ${CLIENT_PRE_SHARED_KEY}
Endpoint = ${ENDPOINT}
AllowedIPs = ${allowed_ips}" >>"${HOME_DIR}/${SERVER_WG_NIC}-client-${CLIENT_NAME}.conf"

	# Ajouter le client en tant qu'homologue au serveur
	echo -e "\n### Client ${CLIENT_NAME}
[Peer]
PublicKey = ${CLIENT_PUB_KEY}
PresharedKey = ${CLIENT_PRE_SHARED_KEY}
AllowedIPs = ${CLIENT_WG_IPV4}/32" >>"/etc/wireguard/${SERVER_WG_NIC}.conf"

	wg syncconf "${SERVER_WG_NIC}" <(wg-quick strip "${SERVER_WG_NIC}")

	echo -e "\nVoici votre fichier de configuration client sous forme de QR Code :"

	qrencode -t ansiutf8 -l L <"${HOME_DIR}/${SERVER_WG_NIC}-client-${CLIENT_NAME}.conf"
	echo "Le fichier de configuration est disponible en ${HOME_DIR}/${SERVER_WG_NIC}-client-${CLIENT_NAME}.conf"
	qrencode -s 20 -o "${HOME_DIR}/${CLIENT_NAME}.png" <"${HOME_DIR}/${SERVER_WG_NIC}-client-${CLIENT_NAME}.conf"
	echo "Le QR code est sauvegarder dans ${HOME_DIR}/${CLIENT_NAME}.png"
        read -n1 -r -p "Appuyez sur n'importe quelle touche pour continuer..."
}

function revokeClient() {
	NUMBER_OF_CLIENTS=$(grep -c -E "^### Client" "/etc/wireguard/${SERVER_WG_NIC}.conf")
	if [[ ${NUMBER_OF_CLIENTS} == '0' ]]; then
		echo ""
		echo "Vous n'avez aucun client existant !"
		exit 1
	fi

	echo ""
	echo "Sélectionnez le client existant que vous souhaitez révoquer"
	grep -E "^### Client" "/etc/wireguard/${SERVER_WG_NIC}.conf" | cut -d ' ' -f 3 | nl -s ') '
	until [[ ${CLIENT_NUMBER} -ge 1 && ${CLIENT_NUMBER} -le ${NUMBER_OF_CLIENTS} ]]; do
		if [[ ${CLIENT_NUMBER} == '1' ]]; then
			read -rp "Sélectionnez un client [1]: " CLIENT_NUMBER
		else
			read -rp "Sélectionnez un client [1-${NUMBER_OF_CLIENTS}]: " CLIENT_NUMBER
		fi
	done

	# faire correspondre le numéro sélectionné à un nom de client
	CLIENT_NAME=$(grep -E "^### Client" "/etc/wireguard/${SERVER_WG_NIC}.conf" | cut -d ' ' -f 3 | sed -n "${CLIENT_NUMBER}"p)

	# supprimer le bloc [Peer] correspondant à $CLIENT_NAME
	sed -i "/^### Client ${CLIENT_NAME}\$/,/^$/d" "/etc/wireguard/${SERVER_WG_NIC}.conf"

	# supprimer le fichier client généré
	rm -f "/Wireguard/${SERVER_WG_NIC}-client-${CLIENT_NAME}.conf"
	#Supprimer le fichier QRCode
	rm -f "/Wireguard/${CLIENT_NAME}.png"

	# redémarrer wireguard pour appliquer les modifications
	wg syncconf "${SERVER_WG_NIC}" <(wg-quick strip "${SERVER_WG_NIC}")
}

function uninstallWg() {
	echo ""
	read -rp "Voulez-vous vraiment supprimer WireGuard ? [y/n]: " -e -i n REMOVE
	if [[ $REMOVE == 'y' ]]; then
		checkOS

		systemctl stop "wg-quick@${SERVER_WG_NIC}"
		systemctl disable "wg-quick@${SERVER_WG_NIC}"

		if [[ ${OS} == 'rocky' ]]; then
			yum -y remove kmod-wireguard wireguard-tools qrencode epel-release elrepo-release yum-plugin-elrepo iptables
			yum -y autoremove
		elif [[ ${OS} == 'ubuntu' ]]; then
			apt-get autoremove --purge -y wireguard qrencode
		elif [[ ${OS} == 'debian' ]]; then
			apt-get autoremove --purge -y wireguard qrencode
		fi

		rm -rf /etc/wireguard
		rm -f /etc/sysctl.d/wg.conf
		rm -f /Wireguard

		# Recharger sysctl
		sysctl --system

		# Vérifiez si WireGuard est en cours d'exécution
		systemctl is-active --quiet "wg-quick@${SERVER_WG_NIC}"
		WG_RUNNING=$?

		if [[ ${WG_RUNNING} -eq 0 ]]; then
			echo "WireGuard n'a pas réussi à désinstaller correctement."
			exit 1
		else
			echo "WireGuard a été désinstallé avec succès."
			exit 0
		fi
	else
		echo ""
		echo "Suppression annulée !"
	fi
}
function systemctlstatus() {
	echo ""
		systemctl status "wg-quick@${SERVER_WG_NIC}"
}
function systemctlstop() {
	echo ""
		systemctl stop "wg-quick@${SERVER_WG_NIC}"		
}
function systemctlstart() {
	echo ""
		systemctl start "wg-quick@${SERVER_WG_NIC}"
}
function systemctlrestart() {
	echo ""
		systemctl restart "wg-quick@${SERVER_WG_NIC}"		
}
function sexit() {
        echo ""
               	exit           
}
function manageMenu() {
clear
	echo -e "\n${GREEN}Bienvenue sur WireGuard-Configuration !${NC}"
	echo ""
	echo "Que voulez vous faire?"
	echo "   1) Ajouter un nouveau client"
	echo "   2) Révoquer un client existant"
	echo "   3) Vérifier le status de WireGuard"
	echo "   4) Arreter Wireguard"
	echo "   5) Démarrer Wireguard"
	echo "   6) Redémarrer Wireguard"
    echo -e "   ${RED}7) /!\ Désinstaller WireGuard${NC}"
	echo "Control + C pour quitter"
	until [[ ${MENU_OPTION} =~ ^[1-8]$ ]]; do
		read -rp "Sélectionnez une option [1-7]: " MENU_OPTION
	done
	case "${MENU_OPTION}" in
	1)
		newClient
		;;
	2)
		revokeClient
		;;
	3)
		systemctlstatus
		;;
	4)
		systemctlstop
		;;
	5)
		systemctlstart
		;;
	6)
		systemctlrestart
		;;
    8)
        uninstallWg
        ;;

	esac
}

# Vérifiez OS...
initialCheck

# Vérifiez si WireGuard est déjà installé et chargez les paramètres
if [[ -e /etc/wireguard/params ]]; then
	source /etc/wireguard/params
	manageMenu
else
	installWireGuard
fi
while [ wireguardre ]
do
        ./auto-wireguard_rocky_ubuntu.sh
done