Openvpn_install_script

#!/bin/bash
# Auteur : Tlams
# Date : 13/02/13
# Script description : Permet de monter un serveur OPENVPN de façon guidé !

############# Liste des fonctions:###############
## Menu: Permet d'afficher le menu de choix
## downloadopenvpn: Permet de télécharger OpenVPN
## config_openvpn: Configuration de OPENVPN
## conf_var: Permet de modifier les variables du fichier "var" afin d'avoir certaines configurations prè-enregistrés lors de la création d'un certificat.
## cree_files_server: Génère les fichiers de base du serveur (Certif,key,dh...)
## creer_client: Permet de créer un client OpenVPN (Génère Key et crt)
## revoke_user: Permet de bloquer un utilisateur 
## creerfichieropenvpn: Permet de générer un fichier de configuration openvpn directement utilisable.
## installpureftp: Permet d'installer un serveur FTP pour récupérer les fichiers des clients facilement.
## ftp_creer_user: Creer un utilisateur pour le serveur FTP
## ftp_modif_pw: Permet de modifier le mot de passe d'un utilisateur FTP
## transfertfichier_client: Permet de transférer (copier) les fichiers clients d'openvpn sur le dossier de l'utilisateur FTP.
## choplip: Permet de récupérer automatiquement l'adresse IP publique du serveur
## validationIP: Permet de valider une adresse IP rentré par un utilisateur.
## connexiontest: Test permettant de déterminer si une connexion internet est présente, pour le téléchargement des paquets.
## config_firewall: Créer un fichier de configuration (firewall) qui applique les régles des bases du pare feu.
## reboot: Permet de redémarrer le serveur
## mailto: permet d'envoyer un email
## genere_fichier_var_ini: Permet de créer le fichier qui sauvegarde les configurations
## write_ini: Modifie les variables de config
#################################################

# Voir ajout GZ L 487/665
menu()
{
	echo "********************"
	echo "********MENU********"
	echo "********************"
	echo "1/ Installation d'OpenVPN"
	echo "2/ Modification-Correction de paramettres"
	#echo "3/ Documentation"
	echo "4/ Quitter"
	read Choix
	 
	case "$Choix" in
		1 )
		connexiontest
		echo "***************************"
		echo "**Installation de OPENVPN**"
		echo "***************************"
		echo -e "\033[33m 
Près-requis: 
- Une connexion internet " $internet "
- Connaitre son ip publique (Taper: ipconfig)
- Connaitre le nom de sa carte réseau connecté au routeur fournissant une connexion internet (Taper: ipconfig)
- Connaitre le nom de son server (Taper: hostname)
		\033[0m"
		
		if [ "$internet_result" = "FALSE" ]; then
			echo "Aucune connexion internet n'a été trouvé !"
			echo "Il faut corriger ce problème avant de pouvoir aller plus loin"
			echo "Arret du script"
			exit 0
		fi
		
		st_install_g=""
		while [ "$st_install_g" != "y" ] && [ "$st_install_g" != "Y" ] && [ "$st_install_g" != "N" ] && [ "$st_install_g" != "n" ]
		do
			echo -n -e "\033[1mVoulez-vous lancer l'installation maintenant? (Y/N): \033[0m"
			read st_install_g
		done

		if [ "$st_install_g" = "y" ] || [ "$st_install_g" = "Y" ]; then
			source /etc/openvpn/conf.ini
			re_install_g=""
			Continuer=1
			
			dpkg -l "openvpn" > /dev/null 2>&1
			INSTALLEDOPENVPN=$?
			if [ $INSTALLEDOPENVPN == '0' ]; then
				while [ "$re_install_g" != "y" ] && [ "$re_install_g" != "Y" ] && [ "$re_install_g" != "N" ] && [ "$re_install_g" != "n" ]
					do
						echo -e "\033[33Il semblerait qu'une installation soit déjà présente, il n'est pas conseillé de re-installer par dessus ! \033[0m"
						echo -e -n  "\033[1mVoulez-vous lancer l'installation maintenant? (Y/N): \033[0m"
						read re_install_g
					done	
				if [ "$re_install_g" = "N" ] && [ "$re_install_g" = "n" ];  then		
					Continuer=0
				fi	
			fi
			
			if [ "$Continuer" = 1 ]; then
				downloadopenvpn
				conf_var
				config_openvpn
				cree_files_server
				creer_client
				creerfichieropenvpn
				mailto
				installpureftp				
				if [ "$v_ftp_install" = 1 ]; then		
					ftp_creer_user
				fi	
				config_firewall
				/etc/init.d/openvpn restart
				echo "Installation du serveur OPENVPN terminé."	
				echo "Rappels:"
				echo "Emplacement des fichiers clients: //etc/openvpn/easy-rsa/2.0/keys/clients/"
				echo "Connexion sftp: sftp://root@"$v_sys_publicIP
				if [ "$v_ftp_install" = 1 ]; then		
					echo "Connexion ftp - User:"$v_ftp_user" / IP:" $MONIP
				fi	
			else
				echo "Installation annulé ! Retour au menu"
				menu
			fi		
		elif [ "$st_install_g" = "n" ] || [ "$st_install_g" = "N" ]; then
			echo "Installation annulé ! Retour au menu"
			menu
		fi
		;;

		2 ) 
		dpkg -l "openvpn" > /dev/null 2>&1
		INSTALLEDOPENVPN=$?
		if [ $INSTALLEDOPENVPN != '0' ]; then
			echo "Aucune installation d'openvpn détecté! Certaines fonctions ne seront pas correctement fonctionnelles"
		fi
		
		
		echo "	1/ Modifier le certificat"
		echo "	2/ Ajouter un client."
		echo "	3/ Supprimer un client."
		echo "	4/ Modifier le mot de passe utilisateur FTP."
		echo "	5/ Modifier la configuration du pare-feu."
		echo "	6/ Modifier la configuration d'OPENVPN."
		echo "	7/ Mettre à jour les fichiers clients sur le serveur FTP"
		echo "	0/ Retour menu"
		read modifcorrect
		case "$modifcorrect" in
			0 )
				menu
			;;
			1 ) 
			source /etc/openvpn/conf.ini
			v_modif_certif=""
			while [ "$v_modif_certif" != "y" ] && [ "$v_modif_certif" != "Y" ] && [ "$v_modif_certif" != "N" ] && [ "$v_modif_certif" != "n" ]
			do
				echo "Si vous modifiez le certificat, TOUS vos clients actuels seront invalides ! Continuer?(Y/N) "
				read v_modif_certif
			done
			if [ "$v_modif_certif" = "y" ] || [ "$v_modif_certif" = "Y" ]; then
				conf_var
				cree_files_server
			else
				echo "Opération annulé"
			fi
			menu
			;;
			2 ) 
			source /etc/openvpn/conf.ini
			creer_client
			creerfichieropenvpn
			mailto
			if [ "$v_ftp_install" = 1 ] ; then
				transfertfichier_client
			fi
			menu;;
			3 ) revoke_user
			menu;;
			4 ) 
			source /etc/openvpn/conf.ini
			ftp_modif_pw
			menu;;
			5 ) 
			source /etc/openvpn/conf.ini
			config_firewall
			menu;;
			6 )
			v_modif_openvpn=""
			while [ "$v_modif_openvpn" != "y" ] && [ "$v_modif_openvpn" != "Y" ] && [ "$v_modif_openvpn" != "N" ] && [ "$v_modif_openvpn" != "n" ]
			do
				echo "Si vous modifiez le certificat, TOUS vos clients actuels seront invalides ! Continuer?(Y/N) "
				read v_modif_openvpn
			done
			if [ "$v_modif_openvpn" = "y" ] || [ "$v_modif_openvpn" = "Y" ]; then
				 config_openvpn 
			else
				echo "Opération annulé"
			fi
			menu;;
			7 ) 
			source /etc/openvpn/conf.ini
			transfertfichier_client
			menu;;
			* ) echo "Réponse incorrecte! - Arrêt du script";;
		esac	
		;;
		3 ) echo "RTFM !";;
		4 ) exit 0;;
		* ) echo "Réponse incorrecte! - Arrêt du script";;
	esac
}

genere_fichier_var_ini()
{

	if [ ! -d "/etc/openvpn" ]; then
		mkdir /etc/openvpn
		echo "Création du dossier openvpn"
	fi

	fichier_var="/etc/openvpn/conf.ini"
	if [ ! -e "$fichier_var" ]; then 
		echo 'v_openvpn_port=' >> $fichier_var
		echo 'v_openvpn_reseau=' >> $fichier_var
		echo 'clienttoclient=' >> $fichier_var
		echo 'v_openvpn_masque=' >> $fichier_var
		echo 'v_sys_publicIP=' >> $fichier_var
		echo 'v_sys_localIP=' >> $fichier_var
		echo 'v_ftp_user=' >> $fichier_var
		echo 'v_openvpn_internet=' >> $fichier_var
		echo 'v_sys_cartenom=' >> $fichier_var
		echo 'v_ftp_install=' >> $fichier_var
		echo 'install_g=' >> $fichier_var
	fi
}


write_ini()
{
	clef=`echo $1 | sed 's/%/\\\%/g'`
	valeur=`echo $2 | sed 's/%/\\\%/g'`
	sed -r "s%(^[ $'\t']*$clef[ $'\t']*=[ $'\t']*).*\$%\1$valeur%" $3  -i
}

downloadopenvpn() #Permet de télécharger OPENVPN
{
	write_ini "install_g" "1" "/etc/openvpn/conf.ini"
	echo   "Mise à jours liste des paquets"
	apt-get update 
    echo   "Téléchargement des fichiers openvpn..."
	apt-get install openvpn
	dpkg -l "openvpn" > /dev/null 2>&1
	INSTALLEDOPENVPN=$?
	if [ $INSTALLEDOPENVPN != '0' ]; then
		echo "Arret de l'installation"
		exit 0
	fi
	
	echo   "Téléchargement des fichiers Mutt..."
	apt-get install mutt
	
	dpkg -l "mutt" > /dev/null 2>&1
	INSTALLEMUTT=$?
	if [ $INSTALLEMUTT != '0' ]; then
		echo "Arret de l'installation"
		exit 0
	fi
	
	cp -R /usr/share/doc/openvpn/examples/easy-rsa /etc/openvpn
}

config_openvpn() #Configuration du serveur openvpn
{
	v_openvpn_port=""
	v_openvpn_reseau=""
	clienttoclient=""
	v_openvpn_masque=""
	v_sys_publicIP=""
	echo "Configuration du serveur OpenVPN"
	
	while [ -z "${v_openvpn_port}" ] || ! [ "$v_openvpn_port" -eq "$v_openvpn_port" ] 2>/dev/null
	do
		echo -e "\033[1mQuel port d'écoute utiliser? (Conseil: 1194) \033[0m"
		echo -e "\033[33mVous pouvez aussi utiliser un port du type 443 afin d'optimiser les chances de disponibilité à partir de n'importe quel réseau. \033[0m" 
		read v_openvpn_port	
	done

	while [ -z "${v_openvpn_reseau}" ] || [ "$valideIP" != "TRUE" ]
	do
		echo -e "\033[1mQuel réseau pour vos clients? (Conseil: 10.8.0.0) \033[0m"
		echo -e "\033[33mIl s'agit d'une adresse réseau ! Pas d'une Ip de poste !\033[0m" 
		read v_openvpn_reseau
		validationIP $v_openvpn_reseau
	done
	
	
	while [ "$clienttoclient" != "y" ] && [ "$clienttoclient" != "Y" ] && [ "$clienttoclient" != "N" ] && [ "$clienttoclient" != "n" ]
		do	
		echo -e "\033[1mVoulez-vous que les clients puissent ce voir?(Y/N) \033[0m"
		echo -e "\033[33mPermet aux clients de communiquer(comme dans un réseau local)\033[0m" 
		read clienttoclient
	done

	while [ -z "${v_openvpn_masque}" ] || [ "$valideIP" != "TRUE" ]
	do
		echo -n -e "\033[1mMasque réseau? (Conseil: 255.255.255.0) \033[0m"
		read v_openvpn_masque
		validationIP $v_openvpn_masque
	done
	
	while [ -z "${v_sys_publicIP}" ] || [ "$valideIP" != "TRUE" ]
		do
			echo -e "\033[1mQuelle est l'ip publique de votre serveur? \033[0m"
			choplip
			echo -e "\033[33mIl a été détecté <"$MONIP"> comme étant votre IP publique.\033[0m"
			read v_sys_publicIP
			validationIP $v_sys_publicIP
		done
	
	echo -n -e "\033[1mVotre IP publique est elle directement attribué à votre carte réseau?(Y/N)\033[0m"
	read sys_carte_ip
	if [ "$sys_carte_ip" = "y" ] || [ "$sys_carte_ip" = "Y" ]; then
		v_sys_localIP=$v_sys_publicIP
	else
		while [ -z "${v_sys_localIP}" ] || [ "$valideIP" != "TRUE" ]
		do
			echo -e "\033[1mQuelle est l'ip locale de votre serveur? \033[0m"
			read v_sys_localIP
			validationIP $v_sys_localIP
		done
	fi

	echo "Ecriture du fichier..."
	Fichier_conf_rep="/etc/openvpn/"$HOST".conf"
	if [ -e "$Fichier_conf_rep" ]; then 
		rm $Fichier_conf_rep
	fi
	
	write_ini "v_openvpn_port" "$v_openvpn_port" "/etc/openvpn/conf.ini"
	write_ini "v_openvpn_reseau" "$v_openvpn_reseau" "/etc/openvpn/conf.ini"
	write_ini "v_openvpn_masque" "$v_openvpn_masque" "/etc/openvpn/conf.ini"
	write_ini "v_sys_publicIP" "$v_sys_publicIP" "/etc/openvpn/conf.ini"
	write_ini "v_sys_localIP" "$v_sys_localIP" "/etc/openvpn/conf.ini"
	
	 echo 'mode server' >> $Fichier_conf_rep
	 echo 'local' $v_sys_localIP >> $Fichier_conf_rep
	 echo 'port' $v_openvpn_port >> $Fichier_conf_rep
	 echo 'proto udp' >> $Fichier_conf_rep
	 echo 'dev tun' >> $Fichier_conf_rep
	 echo 'ca ca.crt' >> $Fichier_conf_rep
	 echo 'cert '$HOST'.crt' >> $Fichier_conf_rep
	 echo 'key '$HOST'.key' >> $Fichier_conf_rep
	 echo 'dh dh1024.pem' >> $Fichier_conf_rep
	 echo 'server' $v_openvpn_reseau $v_openvpn_masque >> $Fichier_conf_rep
	 echo 'cipher BF-CBC' >> $Fichier_conf_rep
	 echo 'comp-lzo' >> $Fichier_conf_rep
	 echo 'persist-key' >> $Fichier_conf_rep
	 echo 'persist-tun' >> $Fichier_conf_rep
	 echo 'status openvpn-status.log' >> $Fichier_conf_rep
	 echo 'verb 3' >> $Fichier_conf_rep
	 echo 'tun-mtu 1500' >> $Fichier_conf_rep
	 echo 'tun-mtu-extra 32' >> $Fichier_conf_rep
	 echo 'mssfix 1450' >> $Fichier_conf_rep
	 echo 'push "redirect-gateway def1"' >> $Fichier_conf_rep
	 echo 'push "dhcp-option DNS 8.8.8.8"' >> $Fichier_conf_rep
	 echo 'push "dhcp-option DNS 208.67.220.220"' >> $Fichier_conf_rep
	 echo 'keepalive 10 120' >> $Fichier_conf_rep
	 echo 'crl-verify crl.pem' >> $Fichier_conf_rep #A VOIR		
	if [ "$clienttoclient" = "y" ] || [ "$clienttoclient" = "Y" ]; then
		echo 'client-to-client' >> $Fichier_conf_rep
		write_ini "clienttoclient" "1" "/etc/openvpn/conf.ini"
	else
		write_ini "clienttoclient" "0" "/etc/openvpn/conf.ini"
	fi	
}

conf_var() #Permet de déf des variables de bases pour la création des certif. (Non utilisé pour le moment)
{
	v_certif_pays=""
	v_certif_province=""
	v_certif_ville=""
	v_certif_org=""
	v_certif_org=""
	v_certif_email=""
	while [ -z "${v_certif_pays}" ] || [ ${#v_certif_pays} != 2 ]
	do
		echo -n -e "\033[1mIndice de votre pays?(Exemple:FR - Limite de 2 caractère): \033[0m"
		read v_certif_pays
	done

	while [ -z "${v_certif_province}" ] 
	do
		echo -n -e "\033[1mVotre province?:\033[0m "
		read v_certif_province
	done

	while [ -z "${v_certif_ville}" ] 
	do
		echo -n -e "\033[1mVotre ville?:\033[0m "
		read v_certif_ville
	done
	
	while [ -z "${v_certif_org}" ] 
	do
		echo -n -e "\033[1mVotre organisation?:\033[0m "
		read v_certif_org
	done
	
	while [ -z "${v_certif_email}" ] ||  [[ "$v_certif_email" != *"@"* ]]
	do
		echo -n -e "\033[1mVotre email?  \033[0m"
		read v_certif_email
	done
	
	write_ini 'export KEY_COUNTRY' '"'$v_certif_pays'"' '/etc/openvpn/easy-rsa/2.0/vars'
	write_ini 'export KEY_PROVINCE' '"'$v_certif_province'"' '/etc/openvpn/easy-rsa/2.0/vars'
	write_ini 'export KEY_CITY' '"'$v_certif_ville'"' '/etc/openvpn/easy-rsa/2.0/vars'
	write_ini 'export KEY_ORG' '"'$v_certif_org'"' '/etc/openvpn/easy-rsa/2.0/vars'
	write_ini 'export KEY_EMAIL' '"'$v_certif_email'"' '/etc/openvpn/easy-rsa/2.0/vars'
	echo "Données enregistrés"
}



cree_files_server() #Permet de creer les fichiers de base du serveur (ca, key..)
{
ecrase_file=""
	echo "Création du certificat serveur..."
	if [ -e "/etc/openvpn/ca.crt" ]; then 
		while [ "$ecrase_file" != "y" ] && [ "$ecrase_file" != "Y" ] && [ "$ecrase_file" != "N" ] && [ "$ecrase_file" != "n" ]
		do
			echo "Il semblerait qu'un certificat existe déjà, si vous continuez le procéssus, il sera écrasé par le nouveau."
			echo "Tous les clients devront mettre à jour leurs fichiers"
			echo -n -e "\033[1mVoulez-vous continuer (Y/N)? \033[0m"
			read ecrase_file
		done
	fi	
	
	if [ "$ecrase_file" != "n" ] && [ "$ecrase_file" != "N" ]; then 
		if [ -e "/etc/openvpn/ca.crt" ]; then 
			rm /etc/openvpn/ca.crt
		fi
		if [ -e "/etc/openvpn/keys/ca.key" ]; then 
			rm /etc/openvpn/keys/ca.key
		fi
		if [ -e "/etc/openvpn/keys/dh1024.pem" ]; then 
			rm /etc/openvpn/keys/dh1024.pem
		fi
		if [ -e "/etc/openvpn/$v_system_name.key" ]; then 
			rm /etc/openvpn/$HOST.key
		fi
		if [ -e "/etc/openvpn/$v_system_name.crt" ]; then 
			rm /etc/openvpn/$HOST.crt
		fi
		
		#Lignes pour le générer...
		cd /etc/openvpn/easy-rsa/2.0
		. /etc/openvpn/easy-rsa/2.0/vars
		. /etc/openvpn/easy-rsa/2.0/clean-all
		. /etc/openvpn/easy-rsa/2.0/build-ca
		echo "Certificat serveur crée !"	
		echo "Création de la clé serveur..."
		
		#Ligne de création 
		. /etc/openvpn/easy-rsa/2.0/build-key-server $HOST
		echo "Clée serveur crée!"	
		echo "Création du fichier Diffie Hellman..."
		#Ligne de création Diffie Hellman.
		. /etc/openvpn/easy-rsa/2.0/build-dh
		
		echo "Mise en place des fichiers..."
		#Déplacement des fichiers du serveur
		cp /etc/openvpn/easy-rsa/2.0/keys/ca.crt /etc/openvpn/ca.crt
		cp /etc/openvpn/easy-rsa/2.0/keys/ca.key /etc/openvpn/ca.key
		cp /etc/openvpn/easy-rsa/2.0/keys/dh1024.pem /etc/openvpn/dh1024.pem
		cp /etc/openvpn/easy-rsa/2.0/keys/$HOST.key /etc/openvpn/$HOST.key
		cp /etc/openvpn/easy-rsa/2.0/keys/$HOST.crt /etc/openvpn/$HOST.crt
		echo "Tous les fichiers sont en place."
	else
		echo "Création du certificat serveur annulé !"
	fi
	
	#Importation d'un certificat bidon (Fichier ne peut pas être vide)
	echo "Téléchargement d'un certificat bidon..."
	cd /etc/openvpn/
	wget http://pastebin.com/raw.php?i=fs5DYbeT
	mv raw.php?i=fs5DYbeT crl.pem
}


creer_client() #Permet de creer un client openvpn
{
v_nom_clientP=""
	while [ -z "${v_nom_clientP}" ] 
	do	
		echo -n -e "\033[1mCréation du client... Quel nom voulez-vous lui donner? \033[0m"	
		read v_nom_clientP
	done
	
	#permet de détecter si le nom est déjà utilisé ou pas
	if [ -e "/etc/openvpn/easy-rsa/2.0/keys/clients/"$v_nom_clientP".crt" ]; then 
			echo "Ce client existe déjà !"
	else
		cd /etc/openvpn/easy-rsa/2.0
		source ./vars
		. /etc/openvpn/easy-rsa/2.0/build-key $v_nom_clientP
		echo "Client $v_nom_clientP crée"

		if [ ! -d "/etc/openvpn/easy-rsa/2.0/keys/clients" ]; then
		mkdir /etc/openvpn/easy-rsa/2.0/keys/clients
		echo "Création du dossier clients"
		
		fi
		#GZ les deux fichiers
		cp /etc/openvpn/easy-rsa/2.0/keys/$v_nom_clientP.crt /etc/openvpn/easy-rsa/2.0/keys/clients/$v_nom_clientP.crt
		cp /etc/openvpn/easy-rsa/2.0/keys/$v_nom_clientP.key /etc/openvpn/easy-rsa/2.0/keys/clients/$v_nom_clientP.key
		echo "Les fichiers sont en attentes dans: /etc/openvpn/easy-rsa/2.0/keys/clients/"
	fi
}

revoke_user() #Permet de bloquer l'utilisation d'un certificat client 
{
revokclient=""
while [ -z "${revokclient}" ] 
	do
		echo -n -e "\033[1mNom du client à supprimer:\033[0m "
		read revokclient
	done	
cd /etc/openvpn/easy-rsa/2.0
source ./vars #Charge les var
./revoke-full $revokclient
cp keys/crl.pem /etc/openvpn/
}


creerfichieropenvpn() #Permet de générer un fichier de configuration openvpn directement utilisable.
{
	#Création du fichier ovpn client.
	confuseropenvpn="/etc/openvpn/easy-rsa/2.0/keys/clients/"$v_nom_clientP".ovpn"
	
	#Config Ip + Port
	echo "remote" $v_sys_publicIP $v_openvpn_port  >> $confuseropenvpn
	echo "<ca>" >> $confuseropenvpn
	
	#Récupere les données du Certificat serveur et les mets dans le fichier de configuration ...
	while read ca 
	do   
	   echo -e "$ca" >> $confuseropenvpn  
	done < /etc/openvpn/ca.crt
	
	echo "</ca>" >> $confuseropenvpn
	echo "<cert>" >> $confuseropenvpn
	
	#Récupere les données du Certificat client et les mets dans le fichier de configuration ...
	while read cert  
	do   
	   echo -e "$cert" >> $confuseropenvpn  
	done < /etc/openvpn/easy-rsa/2.0/keys/clients/$v_nom_clientP.crt
	
	echo "</cert>" >> $confuseropenvpn
	echo "<key>" >> $confuseropenvpn	
	
	#Récupere les données de la Key client et les mets dans le fichier de configuration ...
	while read key 
	do   
	   echo -e "$key" >> $confuseropenvpn  
	done < /etc/openvpn/easy-rsa/2.0/keys/clients/$v_nom_clientP.key
	
	echo "</key>" >> $confuseropenvpn
	
	#Configurations générales du client...
	echo "client" >> $confuseropenvpn
	echo "dev tun" >> $confuseropenvpn
	echo "proto udp" >> $confuseropenvpn
	echo "resolv-retry infinite" >> $confuseropenvpn
	echo "nobind" >> $confuseropenvpn
	echo "persist-key" >> $confuseropenvpn
	echo "persist-tun" >> $confuseropenvpn
	echo "mute-replay-warnings" >> $confuseropenvpn
	echo "cipher BF-CBC" >> $confuseropenvpn
	echo "comp-lzo" >> $confuseropenvpn
	echo "verb 5" >> $confuseropenvpn
}



installpureftp() #Installe le serveur FTP pour récuperer les fichiers clients
{
st_install_ftp=""
	echo -e "\033[33m Afin de récuperer les fichiers clients vous pouvez installer un serveur FTP.\033[0m"
	while [ "$st_install_ftp" != "y" ] && [ "$st_install_ftp" != "Y" ] && [ "$st_install_ftp" != "N" ] && [ "$st_install_ftp" != "n" ]
	do	
		echo -e "\033[1mVoulez-vous installer pure-ftp maitenant? (Y/N) \033[0m"
		echo -e "\033[33m-Si vous possédez déjà un serveur FTP l'installation d'un second est très fortement déconseillé !  
-Si votre serveur est disponible sur votre réseau local vous pouvez opter pour un partage de fichier.\033[0m" 
		read st_install_ftp
	done

	if [ "$st_install_ftp" = "y" ] || [ "$st_install_ftp" = "Y" ]; then
		echo "Installation du serveur ftp..."
		apt-get install pure-ftpd-common
		
		dpkg -l "pure-ftpd-common" > /dev/null 2>&1
		INSTALLEDftpd=$?
		if [ $INSTALLEDftpd = '0' ]; then
			echo "Création du groupe..."
			groupadd ftpgroup
			echo "Mise en place des droits..."
			useradd -g ftpgroup -d /dev/null -s /usr/sbin/nologin ftpuser
			echo 'yes' >> /etc/pure-ftpd/conf/NoAnonymous
			echo 'yes' >> /etc/pure-ftpd/conf/ChrootEveryone
			echo 'yes' >> /etc/pure-ftpd/conf/CreateHomeDir 
			echo 'yes' >> /etc/pure-ftpd/conf/AntiWarez
			write_ini "v_ftp_install" "1" "/etc/openvpn/conf.ini"
			v_ftp_install=1		
		else 
			"Arret de l'installation de pureftp"
		fi			
	else
		echo "Vous devrez les récuperer par vos propres moyens !"
		write_ini "v_ftp_install" "0" "/etc/openvpn/conf.ini"
	fi
}

ftp_creer_user() #Creer l'utilisateur FTP.
{
v_ftp_user=""
while [ -z "${v_ftp_user}" ] 
		do
			echo -n -e "\033[1mQuel nom d'utilisateur pour votre compte ftp?\033[0m"
			read v_ftp_user
		done
		echo "Création de l'utilisateur..."
		mkdir /home/virtual_ftp_users
		mkdir /home/virtual_ftp_users/$v_ftp_user
		pure-pw useradd $v_ftp_user -u ftpuser -g ftpgroup -d /home/virtual_ftp_users/$v_ftp_user		
		write_ini "v_ftp_user" "$v_ftp_user" "/etc/openvpn/conf.ini"		
		pure-pw mkdb
		echo "Application des modifications..."
		ln -s /etc/pure-ftpd/conf/PureDB /etc/pure-ftpd/auth/50pure		
		transfertfichier_client
		/etc/init.d/pure-ftpd restart
}

ftp_modif_pw() #Permet de modifier le mot de passe d'un compte FTP
{
v_ftp_user_modif=""
		echo "Modification du mot de passe"
		source /etc/openvpn/conf.ini
		while [ "$userftpmodfpw" != "y" ] && [ "$userftpmodfpw" != "Y" ] && [ "$userftpmodfpw" != "N" ] && [ "$userftpmodfpw" != "n" ]
		do	
			echo -e "\033[1m"$v_ftp_user" est-il bien votre utilisateur FTP? (Y/N) \033[0m"
			read userftpmodfpw
		done
		
		if [ "$userftpmodfpw" = "y" ] || [ "$userftpmodfpw" = "Y" ]; then
			pure-pw passwd $v_ftp_user -m
			pure-pw mkdb

			# Password
			echo "Application des modifications..."
			ln -s /etc/pure-ftpd/conf/PureDB /etc/pure-ftpd/auth/50pure		
			/etc/init.d/pure-ftpd restart		
		else
			while [ -z "${v_ftp_user_modif}" ] 
			do
				echo -n -e "\033[1mQuel nom d'utilisateur ?033[0m"
				read v_ftp_user_modif
			done	
			pure-pw passwd $v_ftp_user -m
			pure-pw mkdb

			# Password
			echo "Application des modifications..."
			ln -s /etc/pure-ftpd/conf/PureDB /etc/pure-ftpd/auth/50pure		
			/etc/init.d/pure-ftpd restart
		fi
}

transfertfichier_client() #Permet de transferer les fichiers clients (.ovpn,ca,key...) dans le dossier du serveur ftp
{

	while [ -z "${v_ftp_user}" ] 
		do
			echo -n -e "\033[1mQuel est le nom utilisateur de votre compte ftp?"$v_ftp_user"\033[0m"
		read v_ftp_user
	done
	
	#VOir pour l'ajout GZ
	cp /etc/openvpn/ca.crt /home/virtual_ftp_users/$v_ftp_user/ca.crt 
	cp /etc/openvpn/easy-rsa/2.0/keys/clients/*.*  /home/virtual_ftp_users/$v_ftp_user/
	echo "Les fichiers clients sont maintenant disponible sur votre FTP!"
	echo "Une fois les fichiers récuperés, il faut les supprimer du serveur FTP(Sécurité)"
	echo -e "\033[33mInformation de connexion: IP:"$v_sys_publicIP" // USER:"$v_ftp_user"\033[0m"
	chmod 755 /home/virtual_ftp_users/$v_ftp_user/*.* #Utile car tous les fichiers n'ont pas les mêmes droits.
}

config_firewall() #Configuration du firewall
{
	v_openvpn_internet=""
	v_sys_iptables=""
	v_sys_cartenom=""
	while [ "$v_openvpn_internet" != "y" ] && [ "$v_openvpn_internet" != "Y" ] && [ "$v_openvpn_internet" != "N" ] && [ "$v_openvpn_internet" != "n" ]
	do
		echo -n -e "\033[1mVoulez-vous un accès internet à partir du réseau client VPN?(Y/N) \033[0m"
		read v_openvpn_internet
	done
	
	while [ "$v_sys_iptables" != "y" ] && [ "$v_sys_iptables" != "Y" ] && [ "$v_sys_iptables" != "N" ] && [ "$v_sys_iptables" != "n" ]
	do
		echo -e "\033[1mVoulez-vous que le script génère aussi les régles de base d'iptables?(Y/N) \033[0m"
		echo -e "\033[33m Si vous en avez déjà paramétré un vous même, cette option peut créer des conflits ! \033[0m"
		read v_sys_iptables
	done
	
	while [ -z "${v_sys_cartenom}" ] 
	do
		echo -e "\033[1mQuel est le nom de votre carte rélié à internet? \033[0m"
		echo -e "\033[33mIl s'agit généralement de <eth0> mais dans le cas d'un serveur vitualisé par OPENVZ le nom peut être <venet0>\033[0m" 
		read v_sys_cartenom
	done
	Fichier_firewall="/etc/init.d/firewall"
	echo "Création des régles IPTables"
	
	write_ini "v_sys_cartenom" "$v_sys_cartenom" "/etc/openvpn/conf.ini"
	
	if [ -e "$Fichier_firewall" ]; then 
		rm $Fichier_firewall
	fi
	 echo '#!/bin/bash' >> $Fichier_firewall
	
	#régles de bases
	if [ "$v_sys_iptables" = "y" ] || [ "$v_sys_iptables" = "Y" ]; then
		modprobe ip_nat_ftp
		modprobe ip_conntrack_ftp 
		#Suppr des régles existantes
		 echo 'iptables -F' >> $Fichier_firewall
		 echo 'iptables -X' >> $Fichier_firewall
		 
		  # Entrés bloqués par défaut
		 echo 'iptables -P INPUT DROP' >> $Fichier_firewall
		  # Sortie bloqués par défauts
		 echo 'iptables -P OUTPUT DROP' >> $Fichier_firewall
		 # Forward entre cartes autorisé
		 echo 'iptables -P FORWARD ACCEPT' >> $Fichier_firewall 
		 
		 #Ne pas casser les connexions existantes
		 echo 'iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT' >> $Fichier_firewall 
		 echo 'iptables -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT' >> $Fichier_firewall
		 
		 #Le loopback		
		 echo 'iptables -t filter -A INPUT -i lo -j ACCEPT' >> $Fichier_firewall 
		 echo 'iptables -t filter -A OUTPUT -o lo -j ACCEPT' >> $Fichier_firewall

		 #Le ping
		 echo 'iptables -A INPUT -p icmp -j ACCEPT' >> $Fichier_firewall
		 echo 'iptables -A OUTPUT -p icmp -j ACCEPT' >> $Fichier_firewall
		 
		 #Le SSH
		 echo 'iptables -t filter -A INPUT -p tcp --dport  22 -j ACCEPT' >> $Fichier_firewall
		 echo 'iptables -t filter -A OUTPUT -p tcp --dport 22 -j ACCEPT' >> $Fichier_firewall
		 
		 #le FTP 
		 echo 'iptables -t filter -A INPUT -p tcp --dport  20 -j ACCEPT' >> $Fichier_firewall
		 echo 'iptables -t filter -A OUTPUT -p tcp --dport  20 -j ACCEPT' >> $Fichier_firewall
		 
		 echo 'iptables -t filter -A INPUT -p tcp --dport  21 -j ACCEPT' >> $Fichier_firewall
		 echo 'iptables -t filter -A OUTPUT -p tcp --dport 21 -j ACCEPT' >> $Fichier_firewall
		 
		 #SMTP
		 echo 'iptables -t filter -A OUTPUT -p tcp --dport  25 -j ACCEPT' >> $Fichier_firewall
		 
		 #Port openVPN
		 echo 'iptables -t filter -A INPUT -p udp --dport '$v_openvpn_port' -j ACCEPT' >> $Fichier_firewall
		 echo 'iptables -t filter -A OUTPUT -p udp --dport '$v_openvpn_port' -j ACCEPT' >> $Fichier_firewall
		 
		 #DNS...
		 echo 'iptables -t filter -A INPUT -p udp --dport 53 -j ACCEPT' >> $Fichier_firewall
		 echo 'iptables -t filter -A OUTPUT -p udp --dport 53 -j ACCEPT' >> $Fichier_firewall
		 
		 #Internet 80
		 echo 'iptables -t filter -A INPUT -p tcp --dport 80 -j ACCEPT' >> $Fichier_firewall
		 echo 'iptables -t filter -A OUTPUT -p tcp --dport 80 -j ACCEPT' >> $Fichier_firewall
		 
		 #Internet 443
		 echo 'iptables -t filter -A INPUT -p tcp --dport 443 -j ACCEPT' >> $Fichier_firewall
		 echo 'iptables -t filter -A OUTPUT -p tcp --dport 443 -j ACCEPT' >> $Fichier_firewall
		 
		 #NTP
		 echo 'iptables -t filter -A OUTPUT -p udp --dport 123 -j ACCEPT' >> $Fichier_firewall
	else
		 while [ -z "${def_regles}" ] 
		 do
			echo -e "\033[1mVoulez-vous mettre les régles iptables par défaut?(Y/N) \033[0m"
			echo -e "\033[33mSi vous avez défini des régles personalisés, elles seront écrasées.\033[0m" 
			read def_regles
		 done
		 
		 if [ "$def_regles" = "y" ] || [ "$def_regles" = "Y" ]; then
			 echo "Régles par défauts..."
			 iptables -F
			 iptables -X 
			 echo "INPUT - ACCEPT[OK]"
			 iptables -P INPUT ACCEPT
			 echo "OUTPUT - ACCEPT[OK]"
			 iptables -P OUTPUT ACCEPT
			 echo "FORWARD - ACCEPT[OK]"
			 iptables -P FORWARD ACCEPT
			fi
	fi
	
	#Pour l'accès internet au réseau du VPN
	if [ "$v_openvpn_internet" = "y" ] || [ "$v_openvpn_internet" = "Y" ]; then	
		 echo 'oclient="'$v_openvpn_reseau'/'$v_openvpn_masque'"' >> $Fichier_firewall
		 echo 'iptables -A FORWARD -s $oclient -j ACCEPT' >> $Fichier_firewall	
		 echo 'iptables -t nat -A POSTROUTING -o '$v_sys_cartenom' -j SNAT --to-source '$v_sys_localIP'' >> $Fichier_firewall	 
		 echo "Activation d'ipforward"
		 write_ini "v_openvpn_internet" "1" "/etc/openvpn/conf.ini"
		 write_ini "net.ipv4.ip_forward" "1" "/etc/sysctl.conf"
	elif [ "$v_openvpn_internet" = "n" ] || [ "$v_openvpn_internet" = "N" ]; then
		 echo "Désactivation de l'ipforward"
		 echo "Vos clients n'auront pas d'accès internet!"
		 write_ini "v_openvpn_internet" "0" "/etc/openvpn/conf.ini"
		 write_ini "net.ipv4.ip_forward" "0" "/etc/sysctl.conf"
	fi

	echo "Le fichier firewall crée"
	echo "chmod du fichiers..."
	chmod +x $Fichier_firewall
	$Fichier_firewall restart
	update-rc.d firewall defaults
}

choplip() #Récupere l'ip publique du serveur
{
	MONIP=`wget http://checkip.dyndns.org/ -O - -o /dev/null | cut -d: -f 2 | cut -d\< -f 1`
}

validationIP() #Permet de vérifier que l'entrée utilisateur soit bien une IP...
{
	valideIP="FALSE"
	if [[ $1 =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
		valideIP="TRUE"
	else
		valideIP="FALSE"
	fi
}

connexiontest() #Permet de tester la connectivité internet du serveur avant le téléchargement des paquets
{
internet_result=""
echo "Test de connectivité internet..."
ping -c3 checkip.dyndns.com
TEST=$?

if [ $TEST -ne 0 ]
    then
       internet="[Pas de connexion détecté]"
	   internet_result="FALSE"
    else
       internet="[Connexion détecté]"
fi
}

reboot() #Pour reboot le serveur complétement !
{
	while [ "$rebootemoi" != "y" ] && [ "$rebootemoi" != "Y" ] && [ "$rebootemoi" != "N" ] && [ "$rebootemoi" != "n" ]
		do
			echo -n -e "\033[1mVoulez-vous redémarrer maintenant? (Y/N): \033[0m"
			read rebootemoi
		done

		if [ "$rebootemoi" = "y" ] || [ "$rebootemoi" = "Y" ]; then
			reboot
		fi
}

reboot_opvn() #Pour reboot openvpn
{
	while [ "$reboote_opvn" != "y" ] && [ "$reboote_opvn" != "Y" ] && [ "$reboote_opvn" != "N" ] && [ "$reboote_opvn" != "n" ]
		do
			echo -e "\033[1mCette opération demande un redémarrage d'open vpn... (Y/N): \033[0m"
			echo -n -e "\033[1mVoulez-vous redémarrer maintenant? (Y/N): \033[0m"
			read reboote_opvn
		done

		#if [ "$reboote_opvn" = "y" ] || [ "$reboote_opvn" = "Y" ]; then
		#	/etc/init.d/openvpn restart
		#fi
}

mailto() #Permet d'envoyer les fichiers par email
{
	while [ "$mail_to_user" != "y" ] && [ "$mail_to_user" != "Y" ] && [ "$mail_to_user" != "N" ] && [ "$mail_to_user" != "n" ]
		do
			echo -n -e "\033[1mVoulez-vous envoyer les fichiers de configuration par mail au client?(Y/N) \033[0m"
			read mail_to_user
	done

	if [ "$mail_to_user" = "y" ] || [ "$mail_to_user" = "Y" ]; then
		echo -n -e "\033[1mQuelle est l'email de "$v_nom_clientP"?\033[0m"
		read email_user	
		echo "Envoi du mail..."
		echo "Merci de patienter, cela peut prendre un peu de temps!"
		echo | mutt -s "Vos fichiers de configuration OPENVPN" -a /etc/openvpn/easy-rsa/2.0/keys/clients/$v_nom_clientP.key /etc/openvpn/easy-rsa/2.0/keys/clients/$v_nom_clientP.crt /etc/openvpn/easy-rsa/2.0/keys/clients/$v_nom_clientP.ovpn /etc/openvpn/ca.crt -- $email_user
		echo "Email envoyé."
	fi
}

HOST=`hostname` 
echo "Script d'installation simplifié d'openVPN"
echo "Auteur: Tlams"
echo "Date: 15/02/13"
echo "Version: 1.0"
echo "Langue: Français"
genere_fichier_var_ini
menu