Blog Blog - Balise - Iptables

Serveur Debian - versionning de fichiers

Seza — Tue, 04 Sep 2007 21:22:00 +0200

CHAPITRE 9 : Subversion

Subversion ou autrement dit SVN est un outil bien agréable et utile pour les développeurs ou toutes personnes souhaitant versionnés des fichiers.

SVN, pour rappel, remplace avantageusement CVS - sûrement le logiciel le plus connu -. Je ne présenterais pas comment on utilise SVN car si vous êtes intéressé et que vous êtes là vous avez déjà trouvez sûrement beaucoup de tutoriaux concernant se sujet.

Passons à l'installation :

ALBAN@bebeserv:~$ sudo -i
Password:
bebevserv:~# apt-get update
[...]
bebevserv:~# apt-get upgrade
[...]
apt-get install subversion subversion-tools
[...]

C'est presque terminé ! Il nous faut créer un repository :

bebeserv:~# cd /var
bebeserv:/var# mkdir svn
bebeserv:/var# cd svn

Voilà ici sera donc entreposé nos projet. Créons-en un pour l'exemple :

bebeserv:/var/svn# svnadmin --fs-type fsfs create mon_projet

Rien de plus simple. Maintenant créons un modèle à importer de base dans notre projet avec les clasiques dossier « trunk », « branches »}} et « tags ».

bebeserv:/var/svn# mkdir bases
bebeserv:/var/svn# cd bases
bebeserv:/var/svn# mkdir trunk branches tags
bebeserv:/var/svn# cd ..
bebeserv:/var/svn# svn import -m "Import des dossiers commum" /var/svn/bases/ file:///var/svn/mon_projet

Voilà nous avons un dossier « bases » qui nous resservira sûrement plus tard et las commande « svnadmin » avait créer un répertoire avec tout ce dont SVN à besoin pour fonctionner et entreposé les fichiers. D'ailleurs nous allons faire un tour dans la configuration de ce projet pour voir rapidement comment sont géré les utilisateurs :

bebeserv:/var/svn# cd mon_projet/conf

Paramétrons d'abord le comportement du serveur SVN associé à ce projet :

bebeserv:/var/svn/mon_projet/conf# nano svnserve.conf

general]
anon-access = none
auth-access = write
password-db = passwd
authz-db = authz
realm = Subversion bebeserv.bebenet.local repository

Voilà rien n'est autorisé pour les utilisateur anonyme (même pas la lecture) et les utilisateur authentifié auront le droit d'écrire dans le projet au mieux. Pourquoi au mieux car l'on peut préciser les droits d'accès utilisateurs par utilisateurs (ou par groupe d'utilisateur) grâce au fichier « passwd » et « authz ».

Passwd pour créer les utilisateurs :

bebeserv:/var/svn/mon_projet/conf# nano passwd

users]
user = password
user2 = password_2
user3 = password_3

Enregistrez ainsi simplement votre fichier d'utilisateur.

Authz pour préciser les droits des utilisateurs :

bebeserv:/var/svn/mon_projet/conf# nano authz

groups]
les_autres = user2, user3

[mon_projet:/]
user = rw
@les_autres = r

[mon_projet:/trunk/dir/section_modifiable]
@les_autres = rw

Voilà un petit exemple assez concis. Tout d'abord « user2 » et « user3 » sont mis dans un groupe « les_autres ». Pour la racine de notre projet le groupe à le droit unique de lecture. Pour le dossier « trunk/dir/section_modifiable » le groupe aura le droit d'écrire. L'utilisateur « user » quand à lui à le droit d'écriture partout.

Voilà c'est fini pour la configuration. Il vous reste à démarrer le serveur SVN. Pour ceci j'ai encore fait un petit script :

bebeserv:/var/svn/mon_projet/conf#cd /etc/init.d
bebeserv:/etc/init.d# nano svn

Entrez ceci :

#! /bin/sh
set -e

case "$1" in
  start)
        echo -n "Starting svnserve"
        svnserve -d -r /var/svn
        echo "."
        ;;
  stop)
        echo -n "Terminating svnserve"
        pid=`ps -C svnserve -o pid=`
        kill -HUP $pid
        echo "."
        ;; 
  restart)
        echo -n "Terminating svnserve"
        pid=`ps -C svnserve -o pid=`
        kill -HUP $pid
        echo "."
        echo -n "Starting svnserve"
        svnserve -d -r /var/svn
        echo "."
       ;; 
  *)
        echo "Usage: /etc/init.d/svn {start|stop|restart}"
        exit 1
esac

exit 0

UPDATE : Un grand merci pour la contribution de " le père Léon " qui m'a permi de mettre à jour le script de démarrage, en ajoutant le cas STOP. (le RESTART en découle forcément)

~~A l'heure actuel je n'est pas trouver comment arrêter proprement le serveur.~~ Mettez les bons droits d'accès et faîtes un « update-rc.d » pour lancer ce script au démarrage du serveur.

bebeserv:/etc/init.d# chmod 755 svn
bebeserv:/etc/init.d# update-rc.d svn start 98 2 3 4 5 .

Démarrez finalement le serveur pour finir cette session :

bebeserv:/etc/init.d# /etc/init.d/svn start

N'oubliez pas votre firewall :

bebeserv:/etc/init.d# nano /etc/network/iptables

iptables -t filter -A INPUT -i eth0 -p tcp --dport 3690 -d $MYIP -j ACCEPT
iptables -t filter -A OUTPUT -i eth0 -p tcp --dport 3690 -s $MYIP -j ACCEPT

bebeserv:/etc/init.d# /etc/init.d/iptables-conf restart

C'est fini =) A très bientôt !

bebeserv:/etc/init.d# exit
logout
ALBAN@bebeserv:~$

Serveur Debian - Serveur email (MTA + MDA)

Seza — Tue, 07 Aug 2007 10:20:00 +0200

CHAPITRE 7 : POSTFIX & COURRIER-IMAP

Postfix est certainement un des meilleurs serveurs d'e-mail existant, c'est pourquoi mon choix se porte sur celui-ci. Le sujet des e-mails est un sujet compliqué ou les documentations sont nombreuses et confusent assez souvent, je n'en ferai aujourd'hui toujours pas ma spécialité. Je vais donc ne pas m'étendre sur ce sujet.

Nous voulons ici créer un serveur MX principal qui recevra nos mails et les enverra au reste du monde. Nous souhaitons pouvoir envoyé des e-mails depuis ce serveur depuis n'importe où. Dans cette configuration pour ne pas finir en open relay, il n'y a que l'authentification SMTP qui puisse nous protégé de ceci. J'ai testé auparavant le pop-before-smtp qui permet d'en faire autant mais ce n'est qu'un bricolage face à l'authentification SMTP. C'est pourquoi ici on fera une véritable authentification bien sur avec un peu de SSL.

Commençons par installer Postfix et ce qui sera nécessaire à l'authentification SMTP.

ALBAN@bebeserv:~$ sudo -i
Password:
bebeserv:~# apt-get update
[...]
bebeserv:~# apt-get install postfix libsasl2-modules sasl2-bin
[...]

L'installateur vous pose deux questions pour la configuration de Postfix. Répondez à la première "Site internet" et laisser la seconde qui devrait ressembler à « bebeserv.bebenet.local » tel quel.

Maintenant que c'est fait, stoppez Postfix :

bebeserv:~# /etc/init.d/postfix stop
[...]

Maintenant configurons notre serveur d'e-mail :

bebeserv:~# cd /etc/postfix
bebeserv:/etc/postfix# nano main.cf

Afin de garantir la sécurité du MTA faisons le passer pour un serveur Sendmail (un concurrent plus ancien) :

mail_name = Sendmail
mail_version = 8.12.10
smtpd_banner = $myhostname ESMTP $mail_name ($mail_version)

Maintenant quelques fonctionnalités et configuration :

append_dot_mydomain = yes
mynetwork_style = host
proxy_interfaces = 10.0.0.1
relay_domains=
masquerade_domains = bebenet.local
local_transport = virtual:$myhostname

Les utilisateurs virtuels

virtual_alias_domains = hash:/etc/postfix/conf.d/virtual_alias_domains
virtual_alias_maps = hash:/etc/postfix/conf.d/virtual_alias
virtual_mailbox_domains = hash:/etc/postfix/conf.d/virtual_mailbox_domains
virtual_mailbox_base = /var/mail/virtual
virtual_mailbox_maps = hash:/etc/postfix/conf.d/virtual_mailbox
virtual_uid_maps = static:5000
virtual_gid_maps = static:5000

Encore un peu de sécurité et pour l'authentification SMTP

smtp_helo_timeout = 10s
smtpd_recipients_limit = 16
smtpd_soft_error_limit = 3
smtpd_hard_error_limit = 12
smtpd_helo_required = yes
smtpd_delay_reject = yes
disable_vrfy_command = yes
strict_rfc821_envelopes = yes

broken_sasl_auth_clients = yes
smtpd_sasl_auth_enable = yes
smtpd_sasl_path = smtpd
smtpd_sasl_exceptions_networks = $mynetworks
smtpd_sasl_security_options = noanonymous


smtpd_helo_restrictions = 
	permit_mynetworks, 
	reject_invalid_hostname, 
	reject_unknown_hostname,
	reject_non_fqdn_hostname

smtpd_client_restrictions =
   sleep 1, 
   reject_unauth_pipelining
   
smtpd_recipient_restrictions =
	permit_mynetworks,
	permit_sasl_authenticated,
	reject_invalid_hostname,
	reject_unauth_destination,
	reject_unknown_sender_domain,
	reject_unknown_recipient_domain,
	reject_non_fqdn_recipient

smtpd_sender_restrictions =
	reject_unknown_sender_domain,
	reject_non_fqdn_sender,

Pour le SSL :

smtpd_use_tls=yes
smtpd_tls_cert_file = /etc/postfix/smtpd.cert
smtpd_tls_key_file = /etc/postfix/smtpd.key

Enregistrez et quittez. Générons directement les nouveaux certificats SSL pour Postfix :

bebeserv:/etc/postfix# openssl req -new -outform PEM -out /etc/postfix/smtpd.cert -newkey rsa:2048 -nodes -keyout /etc/postfix/smtpd.key -keyform PEM -days 365 -x509
bebeserv:/etc/postfix# chmod 640 smtpd.key

Le fait d'utiliser Sasl (un serveur d'authentification) nous impose de lui montré comment nous souhaitons authentifier les utilisateurs : Pour ceci nous créons comme précisé par notre configuration : « smtpd_sasl_path » le fichier « /etc/postfix/sasl/smtpd.conf »

bebeserv:/etc/postfix# cd sasl
bebeserv:/etc/postfix/sasl# nano smtpd.conf

Entrez ceci :

pwcheck_method: saslauthd
mech_list: plain login

Enregistrer et quitter. Visiblement la commande suivante est utile pour remédier à une histoire de bug...

bebeserv:/etc/postfix/sasl# ln -s /etc/postfix/sasl/smtpd.conf /usr/lib/sasl2/smtpd.conf

Éditez le fichier de configuration de Sasl :

bebeserv:/etc/postfix/sasl# nano /etc/default/saslauthd

Modifier les lignes suivantes :

START=yes
MECHANISMS="rimap"
MECH_OPTIONS="localhost"
OPTIONS="-r -c -m /var/spool/postfix/var/run/saslauthd"

Enregistrez et quitter. Maintenant ajoutons l'utilisateur Postfix au groupe Sasl et faisons en sorte que Sasl puisque créer ses fichiers dans la cage de postfix (ça aussi ça ne s'invente pas) :

bebeserv:/etc/postfix/sasl# dpkg-statoverride --add root sasl 710 /var/spool/postfix/var/run/saslauthd
bebeserv:/etc/postfix/sasl# adduser postfix sasl
[...]

Maintenant il va falloir alimenter les différentes bases de Postfix :

bebeserv:/etc/postfix/sasl# cd ..
bebeserv:/etc/postfix# mkdir conf.d
bebeserv:/etc/postfix# cd conf.d
bebeserv:/etc/postfix/conf.d# nano virtual_mailbox_domains

Entrez :

bebeserv.local	x

Enregistrez et quitter.

bebeserv:/etc/postfix/conf.d# nano virtual_mailbox

Entrez :

test@bebeserv.local	bebeserv.local/test/

Enregistrez et quitter.

bebeserv:/etc/postfix/conf.d# nano virtual_alias

Entrez :

postmaster@bebeserv.local	test@bebeserv.local
hostmaster@bebeserv.local	test@bebeserv.local
webmaster@bebeserv.local	test@bebeserv.local
www@bebeserv.local	test@bebeserv.local
ALBAN@bebeserv.local	test@bebeserv.local

Enregistrez et quitter.

bebeserv:/etc/postfix/conf.d# nano virtual_alias_domains

Entrez :

localhost	bebeserv.local

Enregistrez et quitter. Créons maintenant les bases compilées à l'aide de « postmap » :

bebeserv:/etc/postfix/conf.d# postmap virtual_alias
bebeserv:/etc/postfix/conf.d# postmap virtual_alias_domains
bebeserv:/etc/postfix/conf.d# postmap virtual_mailbox
bebeserv:/etc/postfix/conf.d# postmap virtual_mailbox_domains

Redirigeons « root » qui est normalement alias de tous les autres démon vers notre utilisateur principal :

bebeserv:/etc/postfix/conf.d# nano /etc/aliases

Entrez à la fin du fichier :

root:	ALBAN

Enregistrez et quittez. Remettons, de la même manière que les autres tables, celle-ci à jour :

bebeserv:/etc/postfix/conf.d# postalias /etc/aliases

Créons l'utilisateur et le groupe « virtual » et le dossier des boites e-mail virtuelles :

bebeserv:/etc/postfix/conf.d# cd /var/mail
bebeserv:/var/mail# mkdir virtual	
bebeserv:/var/mail# groupadd -g 5000 virtual
bebeserv:/var/mail# useradd -u 5000 -g virtual -d /var/mail/virtual -s /usr/sbin/nologin virtual
bebeserv:/var/mail# chown virtual.virtual virtual

Parfait ! Maintenant Postfix est fonctionnel et bien configuré. Nous l'avons configuré de sorte que les e-mails émis par les utilisateurs locaux soit traiter par le relay virtual, que localhost soit assimilé à notre domaine, que les sous domaines de notre domaine soit assimilé à notre domaine. Il ne nous reste plus qu'à installer un client IMAP pour lire nos messages.

Installons « courier-imap-ssl » :

bebeserv:/var/mail# apt-get install courier-imap-ssl

Stoppons les serveur nouvellement installés :

bebeserv:/var/mail# /etc/init.d/courier-authdaemon stop
[...]
bebeserv:/var/mail# /etc/init.d/courier-imap stop
[...]
bebeserv:/var/mail# /etc/init.d/courier-imap-ssl stop
[...]

Regénérons un certificat propre à notre domaine pour IMAP :

bebeserv:/var/mail# cd /etc/courier
bebeserv:/etc/courier# rm imapd.pem
bebeserv:/etc/courier# nano imapd.cnf

Modifiez ceci :

[ req_dn ]
C=FR
ST=FRANCE
L=Paris
O=Courier Mail Server
OU=IMAP SSL key
CN=imap.bebenet.local
emailAddress=postmaster@bebenet.local

Enregistrez et quittez. Maintenant créons un beau certificat :

bebeserv:/etc/courier# dpkg-reconfigure courier-imap-ssl
[...]

Ceci fait, ré-arretons le serveur qui a été redémarrer et configurons l'authentification (ici authdaemon à ne pas confondre avec saslauthd) :

bebeserv:/etc/courier# /etc/init.d/courier-imap-ssl stop
[...]
bebeserv:/etc/courier# nano authdaemonrc

Modifiez cette ligne :

authmodulelist="authuserdb"

Enregistrez et quittez. Maintenant nous allons créer la base des utilisateurs qui vont pouvoir se connecter à IMAP. Pour simplifier les choses je vous ai concocté un petit script:

bebeserv:/etc/courier# mkdir userdb
bebeserv:/etc/courier# chmod 0000 userdb
bebeserv:/etc/courier# nano userdb-utils

Entrez ceci :

#!/bin/bash
cd /etc/courier
case "$1" in
add)
	if [ $# -lt 2 ]; then
		echo "Usage: ./userdb-utils add user@domain.tld"
		exit 1
	fi
	EMAIL=$2
	DIR=/var/mail/virtual
	USER=$(echo $EMAIL | cut -d@ -f1)
	DOMAIN=$(echo $EMAIL | cut -d@ -f2)
	userdb $DOMAIN/$EMAIL set mail=$DIR/$DOMAIN/$USER home=$DIR/$DOMAIN/$USER uid=5000 gid=5000
	userdbpw -md5 | userdb $DOMAIN/$EMAIL set systempw
	makeuserdb
	;;
del)
	if [ $# -lt 2 ]; then
		echo "Usage: ./userdb-utils del user@domain.tld"
		exit 1
	fi
	TODAY=$(date +%Y%m%d)
	FILE=/tmp/userdbcreate$TODAY
	EMAIL=$2
	USER=$(echo $EMAIL | cut -d@ -f1)
	DOMAIN=$(echo $EMAIL | cut -d@ -f2)
	DB=/etc/courier/userdb/$DOMAIN
	sed -e /^$EMAIL/d $DB > $FILE
	rm $DB
	mv $FILE $DB
	makeuserdb
	;;
list)
	authenumerate
	;;
*)
	echo "Usage: ./userdb-utils {add|del|list} [user@domain.tld]"
	exit 1
esac
exit 0

Enregistrez et quittez. Maintenant rendons notre script exécutable et disponible dans notre banque de script :

bebeserv:/etc/courier# chmod 700 userdb-utils
bebeserv:/etc/courier# ln -s userdb-utils /usr/local/bin/

Ok, créons deux utilisateurs pour voir comment ceci fonctionne :

bebeserv:/etc/courier# ./userdb-utils add test@bebenet.local
Password :
[...]
bebeserv:/etc/courier# ./userdb-utils add test2@bebenet.local
Password :
[...]
bebeserv:/etc/courier# ./userdb-utils list
[...]
bebeserv:/etc/courier# ./userdb-utils del test2@bebenet.local
bebeserv:/etc/courier# ./userdb-utils list
[...]

C'est terminé. Il reste à mettre à jour « iptables »

bebeserv:/etc/courier# nano /etc/network/iptables

Rajouter ces lignes :

iptables -t filter -A INPUT -i eth0 -p tcp --dport 25 -d $MYIP -j ACCEPT
iptables -t filter -A INPUT -i eth0 -p tcp --dport 993 -d $MYIP -j ACCEPT

iptables -t filter -A OUTPUT -o eth0 -p tcp --dport 25 -s $MYIP -j ACCEPT
iptables -t filter -A OUTPUT -o eth0 -p tcp --sport 25 -s $MYIP -j ACCEPT
iptables -t filter -A OUTPUT -o eth0 -p tcp --dport 993 -s $MYIP -j ACCEPT
iptables -t filter -A OUTPUT -o eth0 -p tcp --sport 993 -s $MYIP -j ACCEPT

Enregistrez et quittez :

Redémarrons les serveurs :

bebeserv:/var/mail# /etc/init.d/iptables-conf restart
bebeserv:/var/mail# /etc/init.d/postfix start
bebeserv:/var/mail# /etc/init.d/courier-authdaemon start
bebeserv:/var/mail# /etc/init.d/courier-imap-ssl start
bebeserv:/var/mail# /etc/init.d/courier-imap start

Et voilà ! Nos utilisateurs doivent se loguer forcément en IMAP et en SMTP le tout couvert du SSL.

Prochain chapitre on ajoute un antivirus et un antispam !

bebeserv:/var/mail# exit
logout
ALBAN@bebeserv:~$

Serveur Debian - vsftpd

Seza — Sat, 02 Jun 2007 18:28:00 +0200

CHAPITRE 3 : FTP

Commençons par installer le serveur FTP :

ALBAN@bebeserv:~$ sudo -i
Password:
bebeserv:~# apt-get update
[...]
bebeserv:~# apt-get install vsftpd libdb3-util ftp
[...]

L'installateur créé automatiquement un utilisateur « ftp » qui à le groupe « nogroup » et le dossier « /home/ftp » pour cet utilisateur. Nous allons changer tout ça, et de plus vu que de base « vsftp » autorise les connexions anonymes par défaut, même si « iptables » ne laissera rien passer, c'est un bon reflex de couper le serveur en attendant sa configuration finale.

bebeserv:~# /etc/init.d/vsftpd stop
[...]

Nous allons d'abord nettoyer un peu ce que « vsftpd » à créer automatiquement

bebeserv:~# userdel ftp
bebeserv:~# rmdir /home/ftp

Je vais conserver le groupe « nogroup » et utiliser l'utilisateur « nobody » qui existe déjà. Nous devons juste accorder cet utilisateur pour ce que nous voulons en faire. Ici j'anticipe un peu sachant que je vais créer des utilisateurs FTP virtuels pour mes sites internet.

bebeserv:~# usermod -g nogroup -d /home/nobody -s /usr/sbin/nologin nobody
bebeserv:~# useradd -g nogroup -d /home/nobody -s /usr/sbin/nologin anonymous
bebeserv:~# mkdir /home/nobody
bebeserv:~# chgrp nogroup /home/nobody
bebeserv:~# chmod 2770 /home/nobody

Créons aussi le dossier de notre premier utilisateur virtuel :

bebeserv:~# mkdir /home/nobody/test/
bebeserv:~# chown nobody /home/nobody/test/

Une petite explication s'impose, nous donnons d'abord au dossier le bon groupe et nous le mettons un « setgid » dessus afin que tous fichiers et dossiers créés dans ce dossier appartiennent au groupe « nogroup », ensuite nous ne donnons aucun droit d'écriture sur le dossier sauf au propriétaire « root » car « vsftpd » accorde automatiquement les droits d'écriture dans le dossier en fonction de ces droits et nous ne souhaitons pas forcément que tous les utilisateurs puisse écrire dedans. Nous gérerons ces droits dans « vsftpd ».

Maintenant nous allons configurer notre serveur FTP.

bebeserv:~# nano /etc/vsftpd.conf

Je change les lignes suivantes :

anonymous_enable=NO
local_enable=YES
write_enable=NO
local_umask=022
anon_upload_enable=NO
anon_mkdir_write_enable=NO
dirmessage_enable=NO
chown_uploads=NO
chown_username=nobody
xferlog_file=/var/log/vsftpd.log
xferlog_std_format=YES
idle_session_timeout=300
data_connection_timeout=60
nopriv_user=anonymous
ftpd_banner=Welcome to bebeserv.bebenet.local FTP service.
chroot_local_user=YES

Et je rajoute celles-ci :

guest_enable=YES
guest_username=nobody
max_clients=20
max_per_ip=5
force_dot_files=YES
hide_ids=YES
use_localtime=YES
user_config_dir=/etc/vsftpd/user_conf

# Connection sécurisée
#ssl_enable=YES
#allow_anon_ssl=YES
#force_local_data_ssl=YES
#force_local_logins_ssl=YES
#ssl_sslv2=YES
#ssl_sslv3=YES
#ssl_tlsv1=YES

Enregistrez et quittez. Maintenant configurons le fichier d'authentification PAM de « vsftpd » afin d'utiliser des utilisateurs virtuels :

bebeserv:~# nano /etc/pam.d/vsftpd

Commentez toutes les lignes et mettez ceci à la fin du fichier :

auth	required	/lib/security/pam_userdb.so db=/etc/vsftpd/login
account	required	/lib/security/pam_userdb.so db=/etc/vsftpd/login

Enregistrez et quittez. Maintenant allons créer notre base d'utilisateurs virtuels :

bebeserv:~# mkdir /etc/vsftpd
bebeserv:~# nano /etc/vsftpd/userdb

Créez l'utilisateur « test » correspondant au dossier que nous avons fait plus haut :

test
toto

Vérifiez toujours de bien mettre une ligne vide en fin de fichier ! La seconde ligne est le mot de passe de l'utilisateur ici donc « toto ». Le fichier doit être écrit strictement de la sorte (avec toujours une ligne vide à la fin) :

user1
pass1
user2
pass2
user3
pass3
...

Enregistrez et quittez. Maintenant formatons notre base de données au format « userdb ». pour ceci plutôt que de taper une ligne de commande fastidieuse et dont on ne se rappellera jamais, nous allons créer un petit script qui le fera pour nous.

Créons notre script :

bebeserv:~# nano /etc/vsftpd/vsftpd-makedb

Écrivez les lignes suivantes :

#!/bin/sh
db3_load -T -t hash -f /etc/vsftpd/userdb /etc/vsftpd/login.db

Enregistrez et quittez. Maintenant donnons les bons droits à notre script :

bebeserv:~# chmod 500 /etc/vsftpd/vsftpd-makedb

Ajoutons un lien symbolique afin d'avoir accès directement à cette nouvelle commande, comme toutes les autres commandes.

bebeserv:~# ln -s /etc/vsftpd/vsftpd-makedb /usr/local/bin/

Maintenant et après chaque modification de la table « userdb » il faudra faire :

bebeserv:~# vsftpd-makedb

Dorénavant notre utilisateur « test » existe pour « vsftpd » donnons lui des droits afin que « vsftp » sache ce qui lui est autorisé. Mais pour ceci, afin de nous rappeler des options en permanence, nous allons créer d'abord un fichier d'exemple :

bebeserv:~# mkdir /etc/vsftpd/user_conf
bebeserv:~# cd /etc/vsftpd/user_conf
bebeserv:/etc/vsftpd/user_conf# nano example

Écrivez :

# donne les droits de lecture
download_enable=YES
anon_world_readable_only=NO

# donne les droits d'écriture
write_enable=YES
anon_upload_enable=YES
anon_mkdir_write_enable=YES

# donne le droit de renommer de supprimer
anon_other_write_enable=YES

#donne le droit de faire des chmod
chmod_enable=YES
virtual_use_local_privs=YES

#affiche les fichier cachés
force_dot_files=YES

# donne un home dans /home/nobody 
# exemple : local_root=test le home de l'utilisateur sera :
# /home/nobody/test
local_root=test

# droits des fichiers créés
anon_umask=002

Enregistrez et quittez. Maintenant que nous avons un fichier d'exemple, créez celui de l'utilisateur « test » et modifiez les options si vous le souhaiter :

bebeserv:/etc/vsftpd/user_conf# cp example test

Si ce n'est déjà fait ajoutez les lignes suivantes à votre fichier « /etc/network/iptables » :

iptables -t filter -A INPUT -i eth0 -p tcp --dport 21 -d $MYIP -j ACCEPT
iptables -t filter -A INPUT -i eth0 -p tcp --sport 20 -d $MYIP -j ACCEPT

iptables -t filter -A OUTPUT -o eth0 -p tcp --dport 21 -s $MYIP -j ACCEPT
iptables -t filter -A OUTPUT -o eth0 -p tcp --sport 20 -s $MYIP -j ACCEPT

Et à la fin du fichier rajoutez :

modprobe ip_conntrack_ftp ports=21

Configurons « fail2ban » pour qu'il scanne les connexions FTP :

bebeserv:/etc/vsftpd/user_conf# nano /etc/fail2ban/jail.conf

Modifiez cette ligne :

vsftpd]
enabled  = true

Enregistrez et quittez. Maintenant que tout est prêt, redémarrez « iptables » et « vsftpd » :

bebeserv:/etc/vsftpd/user_conf# /etc/init.d/vsftpd start
[...]
bebeserv:/etc/vsftpd/user_conf# /etc/init.d/iptables-conf restart
[...]

Faisons un petit test de connexion :

bebeserv:/etc/vsftpd/user_conf# ftp localhost 21
Connected to localhost.
220 Welcome to bebeserv.bebenet.local FTP service.
Name :

Loguez vous avec l'utilisateur « test » avec le mot de passe « toto ». La connexion réussi votre serveur ftp fonctionne.

Quittez :

ftp> quit
221 Goodbye.
bebeserv:/etc/vsftpd/user_conf#

Dans cette configuration néanmoins les utilisateurs locaux ne peuvent pas se connecter en FTP classique. ce qui est en même temps un bonne chose car le FTP classique peut être remplacer par du SFTP (FTP par SSH) vous n'avez rien à changer pour que ceci fonctionne. ATTENTION ne confondez pas SFTP ET FTPS (FTP par SSL).

Afin de sécurisé aussi nos comptes virtuels nous allons faire en sorte qu'ils puisse se connecter en FTPS. Pour ceci nous allons avoir besoin de « open-ssl » pour générer les certificats adéquats et la connexion SSL.

bebeserv:/etc/vsftpd/user_conf# apt-get install openssl
[...]

Maintenant générons un certificat pour « vsftpd » :

bebeserv:/etc/vsftpd/user_conf# cd /etc/ssl/certs
bebeserv:/etc/ssl/certs# openssl req -x509 -nodes -days 730 -newkey rsa:1024 -keyout vsftpd.pem -out vsftpd.pem

Aux questions répondez comme ceci par exemple; le plus important étant le « Common Name » qui doit être l'adresse IP exact ou le nom de domaine exact du service), sachant que nous configurerons plus tard un sous domaine nommé « ftp » sur notre domaine « bebenet.local » j'utiliserai celui çi : « ftp.bebenet.local ».

Voici ce que j'ai répondu :

Country Name (2 letter code) [AU]:FR
State or Province Name (full name) [Some-State]:France
Locality Name (eg, city) []:Paris
Organization Name (eg, company) [Internet Widgits Pty Ltd]:bebenet.local
Organizational Unit Name (eg, section) []:bebenet.local
Common Name (eg, YOUR name) []:ftp.bebenet.local
Email Address []:alban@bebenet.local

Vous venez de créer un certificat valide pendant deux ans. Maintenant sécurisez votre certificat avec des droits correct :

bebeserv:/etc/ssl/certs# chmod 0600 vsftpd.pem

Maintenant décommentez les lignes suivantes dans « /etc/vsftpd.conf » :

# Connection sécurisée
ssl_enable=YES
allow_anon_ssl=YES
force_local_data_ssl=YES
force_local_logins_ssl=YES
ssl_sslv2=YES
ssl_sslv3=YES
ssl_tlsv1=YES

Enregistrez et quittez. Rechargez la configuration de « vsftpd » :

bebeserv:/etc/ssl/certs# /etc/init.d/vsftpd reload
[...]

Vous pouvez régler le client de votre utilisateur virtuel pour se connecter en FTPS (FTP with SSL auth SSL explicit) ou (FTP with SSL auth TLS explicit).

Pensez à régler votre client en mode actif sans quoi il n'ira pas plus loin que la connexion. En effet sans SSL le serveur est régler pour géré le mode actif comme passif sans problème, seulement SSL empêche la gestion du mode passif. Pour contrer ceci nous pourrions limité la plage de ports passif sous « vsftpd » et ouvrir dans « iptables » ces ports mais cette idée je ne l'implémenterai pas ici. Un petit rappel, une fois le SSL activer, les clients ne pourront plus se connecter sans mode SSL. pour les utilisateurs locaux SFTP (SSH) fonctionne toujours correctement.

Voilà pour ce chapitre.

bebeserv:/etc/ssl/certs# exit
logout
ALBAN@bebeserv:~$

Serveur Debian - openssh

Seza — Sun, 27 May 2007 13:58:00 +0200

CHAPITRE 2 : SSH

Puisque qu'ici nous allons faire pas mal de chose nous allons passez en « root » permanent :

ALBAN@bebeserv:~$ sudo -i
bebeserv:~#

Installons le client et le serveur SSH. Seul le serveur devrait nous servir mais il est toujours très pratique d'avoir un client à porter de main.

bebeserv:~# apt-get update
[...]
bebeserv:~# apt-get install openssh-client openssh-server
[...]

Commencez par couper « sshd » tant qu'il n'est pas configuré correctement :

bebeserv:~# /etc/init.d/ssh stop
[...]

Maintenant allons configurer tout ceci :

bebeserv:~# cd /etc/ssh
bebeserv:/etc/ssh#

Tout d'abord le client ssh :

bebeserv:/etc/ssh# nano ssh_config

Mettez les options suivantes :

CheckHostIP yes
EnableSSHKeysign yes
GSSAPIAuthentification yes
GSSAPIDelegateCredentials no
Protocol 2
ServerAliveCountMax 5
ServerAliveInterval 20
SetupTimeOut 30
TCPKeepAlive no
VerifyHostKeyDNS yes

Enregistrez et quittez. Maintenant passons au serveur :

bebeserv:/etc/ssh# nano sshd_config

Mettez les options suivantes :

X11Forwarding
MaxAuthTries 3
MaxStartups 1
AllowUsers ALBAN
LoginGraceTime 60
PermitRootLogin no
AuthorizedKeysFile %h/.ssh/authorized_keys
X11Forwarding no
TCPKeepAlive no
Banner /etc/ssh/banner
ClientAliveCountMax 5
ClientAliveInterval 20

Enregistrez et quittez. Créons notre bannière :

bebeserv:/etc/ssh# nano banner

Entrez le texte de votre choix :

ATTENTION les connexions sur ce serveur sont surveillées et tracées.

Tout acte malveillant, usurpation d'identité, vol de données pourra amener des poursuites judiciaires importantes !

Nous allons maintenant redémarrer notre serveur.

bebeserv:/etc/ssh# /etc/init.d/ssh start
[...]

Maintenant nous allons créer les clés RSA et DSA de notre utilisateur qui lui permettra d'assurer ses futures connexions.

bebeserv:/etc/ssh# ssh-keygen -t dsa -b 1024 
[...]

Des questions vous seront posées, faîtes « [Entrée] » partout sans répondre.

bebeserv:/etc/ssh# ssh-keygen -t rsa -b 1024 
[...]

Même démarche. Maintenant que tout est beau et propre nous allons devoir autoriser SSH à sortir de notre réseau. Éditez le fichier « /etc/network/iptables » et ajoutez les lignes suivantes.

Autorisons le client SSH :

iptables -t filter -A INPUT -p tcp --sport 22 -i eth0 -d $MYIP -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 22 -o eth0 -s $MYIP -j ACCEPT

Autorisons le serveur SSH :

iptables -t filter -A INPUT -p tcp --dport 22 -i eth0 -d $MYIP -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --sport 22 -o eth0 -s $MYIP -j ACCEPT

Maintenant SSH est ouvert à l'extérieur. Vous pouvez vous logguer depuis votre serveur vers un autre serveur en utilisant :

ssh user@server.com

Si vous souhaitez vous connecter à un serveur depuis le votre sans voir à y rentrer la clé en permanence :

ssh-copy-id -i ~/.ssh/id_dsa.pub user@server.com

Rentrez le mot de passe pour la dernière fois. Après « ssh user@server.com » se connectera automatiquement.

Notre configuration est faite de sorte que seul l'utilisateur « ALBAN » puisse utiliser SSH pour une connexion distante. Ainsi avec Putty.exe sous un poste Windows par exemple vous pouvez vous connecter et administrer votre serveur à distance.

Allons un peu plus loin et protégeons-nous des attaques SSH, nous allons installer le paquet « fail2ban » qui nous protégera de ceci et qui part la suite nous protégera aussi de ce même type d'attaque pour les protocoles HTTP, POP etc. Le principe de « fail2ban » est très simple, il scan les fichiers de log « /var/log/auth.log », « /var/log/apache/access.log » etc ... à la recherche de tentative d'authentification qui sont en échec. Au bout de 3 tentatives échouées par exemple il ajoutera une règle dans « iptables » afin de bannir pendant un certain temps l'adresse IP qui tente de se connecter sans y arriver. Ainsi les attaques brute force sont compromises. Vous l'aurez compris « fail2ban » joue avec « iptables » nous allons donc revenir sur les fichiers du chapitre 1 pour arranger tout ça.

Première chose, installons « fail2ban » :

bebeserv:/etc/ssh# apt-get install fail2ban
[...]

Une fois fais, « fail2ban » est déjà en action, voyez les modifications apporter sur notre « iptables » :

bebeserv:/etc/ssh# iptables -L -v -n

Afin de que notre script « iptables-conf » et celui de « fail2ban » ne s'embête pas au démarrage, sachant que les deux vont de paire nous allons supprimer le démarrage de « fail2ban » tout en gardant son script de démarrage de la manière suivante :

bebeserv:/etc/ssh# /etc/init.d/fail2ban stop
bebeserv:/etc/ssh# update-rc.d -f fail2ban remove

Maintenant nous allons améliorer « iptables-conf » pour y inclure « fail2ban »

bebeserv:/etc/ssh# nano /etc/init.d/iptables-conf

Modifiez les fonctions « start » et « stop » de la manière suivante :

iptables_start() {
		if [ -f /etc/network/iptables ]; then
				. /etc/network/iptables
		fi
		/etc/init.d/fail2ban start
}

iptables_stop() {
		/etc/init.d/fail2ban stop
		iptables -t filter -F INPUT
		iptables -t filter -P INPUT ACCEPT
		iptables -t filter -F OUTPUT
		iptables -t filter -P OUTPUT ACCEPT
}

Enregistrez et quittez. Maintenant allons paramétrer « fail2ban » : Rendez vous dans « /etc/fail2ban/ »

bebeserv:/etc/ssh# cd /etc/fail2ban
bebeserv:/etc/fail2ban# nano fail2ban.conf

Personnellement ici je change la dernière ligne du fichier de configuration :

socket = /var/run/fail2ban.sock

Je trouve ceci plus propre que de le mettre dans « /tmp », autant l'enregistrer avec ses collègues. Maintenant réglons la manière dont « fail2ban » travail :

bebeserv:/etc/fail2ban# nano jail.conf

« bantime = 600 » et « maxretry = 3 » me semble être des bonnes valeurs (pour 3 mauvaises tentatives le host est banni 10 minutes) Je ne rajoute pas mon propres réseau car je préfère ne pas faire confiance à mon réseau (question de sécurité, un cheval de troie sur un de mes PCs pourrait faire des dégâts) Plus bas vous voyez des sections dont une pour SSH activée. Nous laissons tel quel pour l'instant, nous activerons les autres services au fur et à mesure ou nous les monterons. Quittez et enregistrez si vous avez fait des modifications.

Redémarrez le tout :

bebeserv:/etc/fail2ban# /etc/init.d/iptables-conf restart

Voilà c'est terminer pour SSH.

Une dernière chose avant de clore le sujet. Vous avez sûrement remarquer qu'un nouveau fichier de log sera présent dans « /var/log » : « fail2ban.log ».

Il est de bon ton d'aller vérifier si le « logrotate » fera tourner ce fichier de log avant qu'il ne devienne trop gros et génère quelque défaillance du système. (il faut toujours avoir ce reflex). Allons donc dans « /etc/logrotate.d/ »

bebeserv:/etc/fail2ban# cd /etc/logrotate.d/
bebeserv:/etc/logrotate.d# ls

Il y a bien un fichier visiblement dédié à « fail2ban » Affichons le :

bebeserv:/etc/fail2ban# cat fail2ban

De ce que l'on peut en lire, ce fichier sera tourné toutes les semaines avec 4 fichiers conservés et compressés. Pour moi c'est bon =)

bebeserv:/etc/fail2ban# exit
logout
ALBAN@bebeserv:~$

Serveur Debian - Iptables

Seza — Wed, 23 May 2007 10:54:00 +0200

CHAPITRE 1 : IPTABLES

Si vous ne connaissez pas encore « iptables », c'est LA commande pour gérer les connexions réseau, faire des redirections de port, blacklister une adresse IP ou tout simplement ouvrir ou fermer des ports. C'est ce que l'on appelle un pare-feu ou firewall.

Par défaut « iptables » laisse tout ouvert et ne filtre rien. Notre but c'est de fermer un peu tout ça et de garder le minimum ouvert. Je ne rentrerai pas dans le détails de l'utilisation de « iptables » car bien trop de choses sont à voir mais nous allons l'utiliser d'une manière simple et efficace ce qui vous donnera les bases minimales pour commencer à appréhender « iptables ».

Nous allons paramétrer « iptables » de manière à l'utiliser que pour nos besoins. A l'heure actuelle, seul « apt » (la gestion des paquets Debian) et « ntpdate » (synchronisation de l'heure) font des connexions réseau. Nous allons donc tout bloquer puis ouvrir un passage à « apt » et « ntpdate ».

D'abord on supprime toutes les règles existante (des fois qu'ils y en aurait de rentrées) :

ALBAN@bebeserv:~$ sudo iptables -t filter -F INPUT
ALBAN@bebeserv:~$ sudo iptables -t filter -F OUTPUT

Maintenant on ferme les portes :

ALBAN@bebeserv:~$ sudo iptables -t filter -P INPUT DROP
ALBAN@bebeserv:~$ sudo iptables -t filter -P OUTPUT DROP

Un reflex qu'il faut avoir c'est de toujours autoriser la boucle locale (et ceci doit être toujours la première règle) :

ALBAN@bebeserv:~$ sudo iptables -t filter -A INPUT -i lo -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A OUTPUT -o lo -j ACCEPT

Dorénavant nous sommes totalement fermé de l'extérieur. Configurons « iptables » pour laisser « apt ». « apt » aura déjà besoin de faire des requêtes DNS (port 53 en UDP et TCP) pour résoudre les noms tel que « ftp.debian.fr » afin de pouvoir récupérer les listes et les paquets. Normalement un client DNS n'a besoin que du protocole UDP mais ce dernier est laxiste sur sa spécification et autorise aussi le TCP (qui est normalement réservé au transfert de zone DNS) Ouvrons le port DNS en TCP et UDP pour l'entrée et la sortie :

ALBAN@bebeserv:~$ sudo iptables -t filter -A INPUT -i eth0 -d 10.0.0.2 -p tcp --sport 53 -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A INPUT -i eth0 -d 10.0.0.2 -p udp --sport 53 -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A OUTPUT -o eth0 -s 10.0.0.2 -p tcp --dport 53 -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A OUTPUT -o eth0 -s 10.0.0.2 -p udp --dport 53 -j ACCEPT

Si vous posséder un serveur DNS ouvrez vous aurez besoin d'ouvrir les ports dans l'autre sens :

ALBAN@bebeserv:~$ sudo iptables -t filter -A INPUT -i eth0 -d 10.0.0.2 -p tcp --dport 53 -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A INPUT -i eth0 -d 10.0.0.2 -p udp --dport 53 -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A OUTPUT -o eth0 -s 10.0.0.2 -p tcp --sport 53 -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A OUTPUT -o eth0 -s 10.0.0.2 -p udp --sport 53 -j ACCEPT

De même ouvrons le port 80 en TCP pour que « apt » puisse télécharger les paquets :

ALBAN@bebeserv:~$ sudo iptables -t filter -A INPUT -i eth0 -d 10.0.0.2 -p tcp --sport 80 -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A OUTPUT -o eth0 -s 10.0.0.2 -p tcp --dport 80 -j ACCEPT

De même pour un serveur web ouvrez les ports dans l'autre sens :

ALBAN@bebeserv:~$ sudo iptables -t filter -A INPUT -i eth0 -d 10.0.0.2 -p tcp --dport 80 -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A OUTPUT -o eth0 -s 10.0.0.2 -p tcp --sport 80 -j ACCEPT

Maintenant autorisons « ntpdate » qui lui utilise le port 123 en UDP :

ALBAN@bebeserv:~$ sudo iptables -t filter -A INPUT -i eth0 -d 10.0.0.2 -p udp --sport 123 -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A OUTPUT -o eth0 -s 10.0.0.2 -p udp --dport 123 -j ACCEPT

A ce stade nous pourrions nous arrêter là tout es fonctionnel. Mais allons plus loin. Maintenant ajoutons une règle qui dira que toute connexion déjà établie avec le serveur donc déjà autoriser par « iptables » sera elle aussi autorisée (même sur un port fermé par exemple). Cette règle est facultative mais bien utile quand vous tester votre configuration vous permettant de tester avec la règle de log (voir ci-dessous) les paquets qui sont rejetés qui devrait être acceptés.

ALBAN@bebeserv:~$ sudo iptables -t filter -A INPUT -i eth0 -d 10.0.0.2 -m state --state RELATED,ESTABLISHED -j ACCEPT
ALBAN@bebeserv:~$ sudo iptables -t filter -A OUTPUT -o eth0 -s 10.0.0.2 -m state --state RELATED,ESTABLISHED -j ACCEPT

Dernière ces règles nous allons loguer dans le fichier « /var/log/debug » tout les paquets que nous allons bloquer avant de les bloquer :

ALBAN@bebeserv:~$ sudo iptables -t filter -A INPUT -i eth0 -d 10.0.0.2 -j LOG --log-prefix "Iptables INPUT dropped : " --log-level debug
ALBAN@bebeserv:~$ sudo iptables -t filter -A OUTPUT -o eth0 -s 10.0.0.2 -j LOG --log-prefix "Iptables OUPUT dropped : " --log-level debug

Il est est terminer des règles. Maintenant voyons quelques commandes utiles. Sauver votre configuration :

ALBAN@bebeserv:~$ sudo iptables-save > ~/iptables-sauvegarde

Restaurer votre configuration :

ALBAN@bebeserv:~$ sudo iptables-restore ~/iptables-sauvergade

Voir votre configuration complète :

ALBAN@bebeserv:~$ sudo iptables -L -v --line-numbers

Vérifier le log en temps réel (paquets rejetés) : (tapez « [CTRL + C] » pour sortir)

ALBAN@bebeserv:~$ sudo tail -f /var/log/debug

Quand le serveur redémarre vos règles « iptables » seront perdues, il faut donc automatiser la mise en place de ces règles. Allez dans « /etc/network »:

ALBAN@bebeserv:~$ cd /etc/network
ALBAN@bebeserv:/etc/network$

Créez le fichier « iptables » à côté du fichier « interface » :

ALBAN@bebeserv:/etc/network$ sudo nano iptables

Entrez les mêmes lignes que nous avons du taper pour configurer « iptables » (attention aux fautes de frappes !) :

# A modifier en fonction de votre adresse IP
MYIP=10.0.0.2

iptables -t filter -F INPUT
iptables -t filter -F OUTPUT

iptables -t filter -Z INPUT
iptables -t filter -Z OUTPUT

iptables -t filter -P INPUT DROP
iptables -t filter -P OUTPUT DROP

iptables -t filter -A INPUT -i lo -j ACCEPT
iptables -t filter -A INPUT -i eth0 -d $MYIP -p tcp --sport 53 -j ACCEPT
iptables -t filter -A INPUT -i eth0 -d $MYIP -p udp --sport 53 -j ACCEPT
iptables -t filter -A INPUT -i eth0 -d $MYIP -p tcp --sport 80 -j ACCEPT
iptables -t filter -A INPUT -i eth0 -d $MYIP -p udp --sport 123 -j ACCEPT
iptables -t filter -A INPUT -i eth0 -d $MYIP -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -t filter -A INPUT -i eth0 -d $MYIP -j LOG --log-prefix "Iptables INPUT dropped : " --log-level debug

iptables -t filter -A OUTPUT -o lo -j ACCEPT
iptables -t filter -A OUTPUT -o eth0 -s $MYIP -p tcp --dport 53 -j ACCEPT
iptables -t filter -A OUTPUT -o eth0 -s $MYIP -p udp --dport 53 -j ACCEPT
iptables -t filter -A OUTPUT -o eth0 -s $MYIP -p tcp --dport 80 -j ACCEPT
iptables -t filter -A OUTPUT -o eth0 -s $MYIP -p udp --dport 123 -j ACCEPT
iptables -t filter -A OUTPUT -o eth0 -s $MYIP -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -t filter -A OUTPUT -o eth0 -s $MYIP -j LOG --log-prefix "Iptables OUPUT dropped : " --log-level debug

Enregistrez le fichier « [CTRL + O] » et quittez « [CTRL + X] » :

Créez le fichier de démarrage,

ALBAN@bebeserv:/etc/network$ cd /etc/init.d/
ALBAN@bebeserv:/etc/init.d$ sudo nano iptables-conf

Entrez ceci :

#! /bin/sh
set -e

iptables_start() {
		if [ -f /etc/network/iptables ]; then
				. /etc/network/iptables
		fi
}

iptables_stop() {
		iptables -t filter -F INPUT
		iptables -t filter -F OUTPUT
		iptables -t filter -P INPUT ACCEPT
		iptables -t filter -P OUTPUT ACCEPT
}

case "$1" in
  start)
		echo -n "Apply Iptables configuration"
		iptables_start
		echo "."
		;;
  stop)
		echo -n "Clear Iptables configuration"
		iptables_stop
		echo "."
		;;

  restart)
		echo -n "Reloading Iptables configuration"
		iptables_stop
		iptables_start
		echo "."
		;;

  *)
		echo "Usage: /etc/init.d/iptables-conf {start|stop|restart}"
		exit 1
esac

exit 0

Donnons les bons droits à notre fichier :

ALBAN@bebeserv:/etc/init.d$ sudo chmod +x iptables-conf

Enregistrez et quittez. Rajoutez le script de démarrage dans le mode voulu avec la priorité voulue :

ALBAN@bebeserv:/etc/init.d$ sudo update-rc.d iptables-conf start 99 2 3 4 5 . stop 20 0 1 6 .
[...]

Testons le tout, affichons la configuration actuelle :

ALBAN@bebeserv:/etc/init.d$ sudo iptables -L -v --line-numbers
[...]

Stoppez le firewall :

ALBAN@bebeserv:/etc/init.d$ sudo /etc/init.d/iptables-conf stop
[...]

Vérifiez que tout est vide et autorisé :

ALBAN@bebeserv:/etc/init.d$ sudo iptables -L -v --line-numbers
[...]

Démarrons le firewall :

ALBAN@bebeserv:/etc/init.d$ sudo /etc/init.d/iptables-conf start
[...]

Vérifions que toutes les règles sont bien présentes :

ALBAN@bebeserv:/etc/init.d$ sudo iptables -L -v --line-numbers
[...]

Modifions nous même la configuration actuelle :

ALBAN@bebeserv:/etc/init.d$ sudo iptables -F INPUT
[...]
ALBAN@bebeserv:/etc/init.d$ sudo iptables -L -v --line-numbers
[...]

Redémarrons le firewall pour vérifier que tout revient comme nous l'avions configuré :

ALBAN@bebeserv:/etc/init.d$ sudo /etc/init.d/iptables-conf restart
[...]
ALBAN@bebeserv:/etc/init.d$ sudo iptables -L -v --line-numbers
[...]

Voilà c'est terminé pour ce chapitre !

ALBAN@bebeserv:/etc/init.d$ cd ~
ALBAN@bebeserv:~$