✎ linux:securite_linux [Fabwice WorkShop Techno]

Modifiez cette page et cliquez sur « Enregistrer ». Voyez le guide de mise en page pour une aide à propos du formatage. Veuillez ne modifier cette page que si vous pouvez l'améliorer. Si vous souhaitez faire des tests, faites vos premiers pas dans le bac à sable.

====== Sécurité Linux ======

===== Sécurité globale =====
//**Supprimer tout ce qui ne sert pas ou au moins désactiver.**//

*Supprimer les services inutiles dans  **/etc/inetd.conf**.
   
   *Désactivez ou supprimer les droits des fichiers qui ont un **SUID/SGID root**: 
<code bash>
>$find / -user root -a $ -perm -4000 -o -perm -2000 $ -print 
>$chmod a-s nomduprogramme  #pour désactiver les bits "s"
</code>

*Remplacer par **SSH** les programmes "remote commands" (rsh, rlogin, rcp)
  
   *Restreindre les droits au maximum:
<code bash>     
>$chmod -R 700 /etc/rc.d/init.d
</code>

===== FireWall=====
===Netfilter & Iptables===

==Installation==
<code bash>
$urpmi iptables

$chmod +x /etc/init.d/firewall 
$update-rc.d firewall defaults 
</code>

==Liste des règles actuelles==
<code bash>
$iptables -L
</code>

==Exemple de script==
Fichier ///etc/init.d/firewall//
<code bash>
#!/bin/bash
/etc/init.d/fail2ban stop
echo "[Setting firewall rules...]"

# Configuration:
PORTSSH=22
IPSERVER=XXX.XXX.XXX.XXX

# config de base
# Vider les tables actuelles
        iptables -t filter -F
        iptables -t filter -X
echo "[Vidage : OK]"

# Autoriser SSH
        iptables -t filter -A INPUT -p tcp --dport $PORTSSH -j ACCEPT
echo "[Autoriser SSH : OK]"

# Ne pas casser les connexions etablies
        iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
        iptables -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
echo "[Ne pas casser les connexions établies : OK]"

# Interdire toute connexion entrante
        iptables -t filter -P INPUT DROP
        iptables -t filter -P FORWARD DROP
echo "[Interdire toute connexion entrante : OK]"

# Interdire toute connexion sortante
        iptables -t filter -P OUTPUT DROP
echo "[Interdire toute connexion sortante : OK]"

# Autoriser les requetes DNS, FTP, HTTP, NTP (pour les mises a jour)
        iptables -t filter -A OUTPUT -p tcp --dport 21 -j ACCEPT
        iptables -t filter -A OUTPUT -p tcp --dport 80 -j ACCEPT
        iptables -t filter -A OUTPUT -p udp --dport 53 -j ACCEPT
        iptables -t filter -A OUTPUT -p udp --dport 123 -j ACCEPT
echo "[Autoriser les requetes DNS, FTP, HTTP, NTP : OK]"

# Autoriser loopback
        iptables -t filter -A INPUT -i lo -j ACCEPT
        iptables -t filter -A OUTPUT -o lo -j ACCEPT
echo "[Autoriser loopback : OK]"

# Autoriser ping
        iptables -t filter -A INPUT -p icmp -j ACCEPT
        iptables -t filter -A OUTPUT -p icmp -j ACCEPT
echo "[Autoriser ping : OK]"

# Gestion des connexions entrantes autorisées
#
# iptables -t filter -A INPUT -p <tcp|udp> --dport <port> -j ACCEPT

# HTTP
        iptables -t filter -A INPUT -p tcp --dport 80 -j ACCEPT
        iptables -t filter -A INPUT -p tcp --dport 443 -j ACCEPT
#iptables -t filter -A INPUT -p tcp --dport 8443 -j ACCEPT
echo "[Autoriser serveur Apache : OK]"

# Flash Media Server 2
#iptables -t filter -A INPUT -p tcp --dport 1935 -j ACCEPT
#iptables -t filter -A INPUT -p tcp --dport 1111 -j ACCEPT
#echo "[Autoriser serveur Flash Media Server 2 : OK]"

# FTP
modprobe ip_conntrack_ftp
        iptables -t filter -A INPUT -p tcp --dport 20 -j ACCEPT
        iptables -t filter -A INPUT -p tcp --dport 21 -j ACCEPT
        iptables -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
echo "[Autoriser serveur FTP : OK]"

# Mail
        iptables -t filter -A INPUT -p tcp --dport 25 -j ACCEPT
        iptables -t filter -A INPUT -p tcp --dport 110 -j ACCEPT
        iptables -t filter -A INPUT -p tcp --dport 143 -j ACCEPT
        iptables -t filter -A OUTPUT -p tcp --dport 25 -j ACCEPT
        iptables -t filter -A OUTPUT -p tcp --dport 110 -j ACCEPT
        iptables -t filter -A OUTPUT -p tcp --dport 143 -j ACCEPT
echo "[Autoriser serveur Mail : OK]"

# Steamcast
        iptables -t filter -A INPUT -p tcp --dport 8000 -j ACCEPT
        #iptables -t filter -A INPUT -p tcp --dport 8001 -j ACCEPT
echo "[Autoriser serveur ShoutCast autonome : OK]"

# Syn-Flood
        if [ -e /proc/sys/net/ipv4/tcp_syncookies ] ; then
            echo 1 > /proc/sys/net/ipv4/tcp_syncookies
        fi

iptables -A FORWARD -p tcp --syn -m limit --limit 1/second -j ACCEPT
        iptables -A FORWARD -p udp -m limit --limit 1/second -j ACCEPT
echo "[Limiter le Syn-Flood : OK]"

# Spoofing
        if [ -e /proc/sys/net/ipv4/conf/all/rp_filter ] ; then
                 echo 1 > /proc/sys/net/ipv4/conf/all/rp_filter
                 echo 1 > /proc/sys/net/ipv4/conf/default/rp_filter
                 echo 1 > /proc/sys/net/ipv4/conf/eth0/rp_filter
                 echo 1 > /proc/sys/net/ipv4/conf/lo/rp_filter
        fi

iptables -N SPOOFED
        iptables -A SPOOFED -s 127.0.0.0/8 -j DROP
        iptables -A SPOOFED -s 169.254.0.0/12 -j DROP
        iptables -A SPOOFED -s 172.16.0.0/12 -j DROP
        iptables -A SPOOFED -s 192.168.0.0/16 -j DROP
        iptables -A SPOOFED -s 10.0.0.0/8 -j DROP

echo "[Bloquer le Spoofing : OK]"

# Parametrage au niveau du noyau
if [ -e /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts ] ; then
            echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts
fi
if [ -e /proc/sys/net/ipv4/conf/all/accept_redirects ] ; then
            echo 0 > /proc/sys/net/ipv4/conf/all/accept_redirects
fi
if [ -e /proc/sys/net/ipv4/conf/all/send_redirects ] ; then
            echo 0 > /proc/sys/net/ipv4/conf/all/send_redirects
fi

# openvpn config
	echo 1 > /proc/sys/net/ipv4/ip_forward
	iptables -t nat -A POSTROUTING -s 10.10.0.0/24 -o eth0 -j MASQUERADE

# WootWoot
	iptables -I INPUT -d $IPSERVER -p tcp --dport 80 -m string --to 70 --algo bm --string 'GET /w00tw00t.at.ISC.SANS.' -j DROP

/etc/init.d/fail2ban start
echo Firewall mis a jour avec succes !

</code>

Le nombre de paquets rejetés par iptable:
<code bash>
$ iptables -L INPUT -nvx
</code>

===== Attaques via NFS =====

Je rappelle que NFS est un protocole qui permet de partager un ensemble de fichiers sur un réseau. On peut le retrouver couplé à NIS pour l'authentification

La particularité est que le client fait toujours confiance au serveur,un compte "root" sur une machine cliente peut très bien compromettre le serveur et inversement

== Protection ==

*Utiliser la commande mount avec l'option -nosuid avec les clients, ce qui permet d'empêcher la modification ou l'utilisation des programmes setuid sur un systéme de fichier NFS.

*Utilisez l'option root-squash dans le fichier /etc/exports. pour empêcher un client root de devenir root sur le système de fichiers NFS stockés sur le serveur.

*Protéger l'accès à votre serveur NFS en filtrant à partir de l' adresse IP, les différents clients.

*Vérifié que les services RPC ne sont pas actifs sur le serveur depuis internet:
<code bash>
[root@nowhere /root]# rpcinfo -p machinecible
</code>
S'il y a des services disponible, configurer le firewall ou désactiver ce service

*Ne pas autoriser de connexion extérieur aux SMTP, et fermer le port 25,
    sinon configurer le SMTP pour empêcher le relayage

*XWINDOW est en écoute sur le port 6000
    pour fermer son accès:
<code bash>
[root@nowhere /root]# xhost -
</code>

====== Système de prévention d'intrusion ======
IPS <==> Intrusion Prévention System

====== Détection d'intrusion ======
IDS <==> Intrusion Detection System

===== Snort =====

==== Snort ====

==== Snort Snarf ====

==== Acid ====

====== Tests de protection ======

===== Nessus =====

===== Les rootkits=====

==== Chkrootkit ====
<code bash>
$aptitude install chkrootkit
#analyse de votre système
$chkrootkit
</code>

==== Rkhunter ====
<code bash>
$aptitude install rkhunter
# Mise à jour de Rootkit Hunter :
$ rkhunter --update
# Analyse de votre système
$rkhunter -c --sk
</code>

=== Faux positif ===
<code bash>
Warning: The file properties have changed:
        File: /usr/bin/dpkg
</code>

Pour comparer les valeurs md5sum avec ceux déclarés dans /var/lib/dpkg/info

creer un script avec le nom de fichier comme parametre:
<code bash>
#!/bin/sh
FIC=`echo $1 | sed -e 's|^/||'`
MD=`dpkg -S $FIC  | grep -E " /$FIC\$" | head -n 1 |sed -e 's|^$.*$: .*|grep -E \" '$FIC'$\" /var/lib/dpkg/info/\1.md5sums|' | sh | cut -d" " -f1`
MDRE=`md5sum /$FIC | cut -d" " -f1`
echo $MD
echo $MDRE
if [ $MDRE = $MD ] ; then
echo $FIC OK
else
echo $FIC Compromis
fi
</code>

<code bash>
./verifMD5.sh /usr/bin/dpkg
e48554cfc042607d45dfb56ad2ec22f2
e48554cfc042607d45dfb56ad2ec22f2
usr/bin/dpkg OK
</code>

Source  [[http://forum.debian-fr.org/viewtopic.php?f=3&t=17559&hilit=rkhunter|forum.debian-fr.org]]

====== Monitoring du serveur ======

===== Logwatch =====
Logwatch est par un démon pouvant analyser et résumer les logs générés par les autres services durant la journée pour en détecter d'éventuelles anomalies ou en tirer des statistiques. Il permet d'envoyer un e-mail récapitulatif quotidien à l'administrateur.

==== Instalation ====
<code bash> $ aptitude install logwatch </code>

==== Configuration ====
Pour la configuration generique :  ///usr/share/logwatch/default.conf//

Creer le fichier ///etc/logwatch/conf/logwatch.conf//

Ajouter la ligne suivante:
<code bash>
Detail = High
Service = All
</code>

Test du parametrage precedent :
<code bash>
$ logwatch --detail high --service all --range today
</code>

customisation du cron:
<code bash>
$ nano /etc/cron.daily/00logwatch

#!/bin/bash

#Check if removed-but-not-purged
test -x /usr/share/logwatch/scripts/logwatch.pl || exit 0

#execute
/usr/sbin/logwatch --mailto root --detail high --service all --range today
</code>

===== Monit =====
Monit est un utilitaire de surveillance système qui permet à un administrateur de contrôler facilement les fichiers, les processus, les répertoires, ou des dispositifs sur votre système Debian. Il peut également être utilisé pour la commande automatique d'entretien et de réparation - notamment par l'exécution des commandes lorsque des erreurs surviennent.

==== Instalation ====
<code bash> $ aptitude install monit </code>

==== Configuration ====

Editer le fichier ///etc/monit/monitrc// pour rajouter des tests. Voir les details sur le site [[http://mmonit.com/monit/|mmonit.com]]

<code bash>
# Config
set daemon 620
set logfile syslog facility log_daemon
set mailserver localhost, smtp.***.com
set mail-format {
    from: monit@$HOST
    subject: $HOST - Monit : $EVENT $SERVICE
    }
set alert monitoring @ gwadanina.net
set httpd port 808080 and
    allow user:pass

# System
check system ***.com
    if loadavg (1min) > 4 then alert
    if loadavg (5min) > 2 then alert
    if memory usage > 75% then alert
    if cpu usage (user) > 70% then alert
    if cpu usage (system) > 30% then alert
    if cpu usage (wait) > 20% then alert

# Apache 2
check process httpd with pidfile /var/run/apache2.pid
group apache
start program = "/etc/init.d/apache2 start"
stop program = "/etc/init.d/apache2 stop"
if failed host 127.0.0.1 port 80
protocol http then restart
if 5 restarts within 5 cycles then timeout
if cpu is greater than 85% for 2 cycles then alert
if cpu > 90% for 5 cycles then restart
if children > 250 then restart
if totalmem > 500 MB for 5 cycles then restart
if loadavg(5min) greater than 10 for 8 cycles then stop

# check file httpd.conf
#     with path /usr/local/apache/conf/httpd.conf
#     # Reload apache if the httpd.conf file was changed
#     if changed checksum
#        then exec "/usr/local/apache/bin/apachectl graceful"

# MySQL
check process mysqld with pidfile /var/run/mysqld/mysqld.pid
group database
start program = "/etc/init.d/mysql start"
stop program = "/etc/init.d/mysql stop"
if failed host 127.0.0.1 port 3306 then restart
if 5 restarts within 5 cycles then timeout

# SSH
check process sshd with pidfile /var/run/sshd.pid
group ssh
start program "/etc/init.d/ssh start"
stop program "/etc/init.d/ssh stop"
if failed host 127.0.0.1 port 22 protocol ssh then restart
if 5 restarts within 5 cycles then timeout

# Postfix
check process postfix with pidfile /var/spool/postfix/pid/master.pid
group mail
start program = "/etc/init.d/postfix start"
stop  program = "/etc/init.d/postfix stop"
if failed port 25 protocol smtp then restart
if 5 restarts within 5 cycles then timeout

# FTP
check process proftpd with pidfile /var/run/proftpd.pid
group ftp
start program = "/etc/init.d/proftpd start"
stop program  = "/etc/init.d/proftpd stop"
if failed port 21 protocol ftp then restart
if 5 restarts within 5 cycles then timeout

# Disk
check device sda1 with path /dev/sda1
if space usage > 85% then alert
group system

check process clamav with pidfile /var/run/clamav/clamd.pid
    group virus
    start program = "/etc/init.d/clamav-daemon start"
    stop  program = "/etc/init.d/clamav-daemon stop"
    if failed host localhost port 3310 then restart
    if 5 restarts within 5 cycles then timeout

check process cron with pidfile /var/run/crond.pid
    group system
    start program = "/etc/init.d/cron start"
    stop  program = "/etc/init.d/cron stop"
    if 5 restarts within 5 cycles then timeout

check process fail2ban with pidfile /var/run/fail2ban/fail2ban.pid
    start program = "/etc/init.d/fail2ban start"
    stop  program = "/etc/init.d/fail2ban stop"
    if failed unixsocket /var/run/fail2ban/fail2ban.sock then restart
    if 5 restarts within 5 cycles then timeout

#Check host for which services up/down on particular port.
check host test.com with address 127.0.0.1
    if failed port 80 protocol http then alert

</code>

Pour lancer en tant que service, éditer le fichier ///etc/default/monit// et mettre la variable //startup// à 1 puis relancer le service ///etc/init.d/monit restart//

===== Logcheck =====
Recherche de violations de sécurité/messages anormaux

===== Syslog =====

====== Analyse de la machine ======
Usage de la crontab

=== Crontab ===
Pour avoir la liste des taches programmées pour le user courant
crontab -l

Pour éditer la liste des taches programmées
crontab -e

==== Chkroot ====

====== PGP ======
[[linux:securite::cle_pgp|Utilisation de PGP sous linux]]

===== Affichage de connexion =====
    *Nombre d'échec de connexion précédent
    *Date et heure de denière connexion
    *Nombre d'échec pour s'autentifier (total)

===== Connexion =====

*jsp => form autocomplète="off"
    *Temps d'attente croissant entre chaque échec. Mais reset du compteur apres 24 heures, et max attente > une heure sinon attaque par deni de service.

===== Mot de passe =====
    *Limitation dans le temps des mots de passe par defaut pour la première utilisation.
    *Taille min 8 char, debut et fin non en chiffre, pas trois charactère consecutif, pas nom et prenom.
    *Au minimun, il faut: un char non alphanumérique, une majuscule, un minuscule, un chiffre et un symbole.  
    *Durée de vie, un à deux mois max.
    *Historique crypté de 5 dernier mots de passe, afin d'éviter leurs réutilisations.

====== Attaques ======

[[http://www.ibiblio.org/pub/Linux/docs/HOWTO/other-formats/html_single/Firewall-Piercing.html|Firewall Piercing mini-HOWTO]]

====== Nmap ======
=== Audit ===

<code bash>
[root@nowhere /tmp]# nmap -sS -P0 -A -v 192.168.1.1
</code>

=== Difficulté pour IP spoofing ===

Donne un indication sur la difficulté qu'aura le pirate à procéder à une attaque par IP spoofing contre votre serveur.

<code bash>
[root@nowhere /tmp]# nmap -O -v 192.168.1.1
</code>

Plus le chifre //Difficulty// est élevé, moins une attaque sera facile!

====== Maintenance du systeme ======
Mettre le script dans cron et gerer les certificats pour ssh entre les serveurs:

<code bash>
$ nano /etc/maintenance-service.sh

#!/bin/bash                                                                                                                                 
# Script de backup quotidien pour un serveur Debian                                                                                            
# backup du serveur MySQL databases (Dump toutes les bases et les compresses en tar.gz                                                      
# backup de la liste des packages installes                                                                                                 
# backup sur un serveur distant                                                                                                             
#                                                                                                                                           
# Written by Fabwice                                                                                                                        
# http://gwadanina.net                                                                                                                      
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#       Gestion des parametres de configuration               #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
# --------- Parametres du systeme                                                                                                           
MYSQL="$(which mysql)"                                                                                                                      
MYSQLDUMP="$(which mysqldump)"                                                                                                              
GZIP="$(which gzip)"                                                                                                                        
MKDIR="$(which mkdir)"                                                                                                                      
MYSQLCHECK="$(which mysqlcheck)"                                                                                                            
RSYNC="$(which rsync)"                                                                                                                      
SSH="$(which ssh)"                                                                                                                          
MAIL="$(which mail)"                                                                                                                        
TAR="$(which tar)"                                                                                                                          
TOUCH="$(which touch)"                                                                                                                      
RM="$(which rm)"                                                                                                                            
TRAP="$(which trap)"                                                                                                                        
FIND="$(which find)"                                                                                                                        
MD5SUM="$(which md5sum)"                                                                                                                    
HOSTNAME="$(hostname)"                                                                                                                      
TOUCH_REMOTE="/bin/touch"                                                                                                                   
DPKG="$(which dpkg)"                                                                                                                        
                                                                                                                                            
#--------- Date du jour                                                                                                                     
DATE_NOW="$(date +%Y-%m-%d)"                                                                                                                
ANNEE_MOIS_NOW="$(date +%Y-%m)"                                                                                                             
                                                                                                                                            
#--------- Configuration du serveur local                                                                                                   
LOCAL_USER="backup"                                                                                                                        
LOCAL_GROUP="backup"                                                                                                                       
BACKUP_REPO="/home/$LOCAL_USER/BACKUP"                                                                                                      
BACKUP_REPO_TMP="/home/$LOCAL_USER/tmp"                                                                                                     
CURRENT_WORKING_REPO="$BACKUP_REPO/$ANNEE_MOIS_NOW/$DATE_NOW"                                                                               
CURRENT_WORKING_REPO_SQL="$CURRENT_WORKING_REPO/mysql"                                                                                      
TMP_BACKUP_REPO="$BACKUP_REPO_TMP/backup_etc_modif_$DATE_NOW";                                                                              
LOCKFILE="$CURRENT_WORKING_REPO/.lockfile"                                                                                                  
                                                                                                                                            
# fichier de configuration local                                                                                                            
CUSTOM_CONFIG="/etc/maintenance-service.cfg"                                                                                                
                                                                                                                                            
# --------- Configuration du serveur de backup distant                                                                                      
REMOTE_USER="backup"                                                                                                               
REMOTE_HOST="....hd.free.fr"                                                                                                            
REMOTE_PORT=22                                                                                                                            
REMOTE_PATH="/home/$REMOTE_USER/backupdir/backup"                                                                                           
REMOTE_PATH_FIN_DE_TRANSFERT="$REMOTE_PATH/BACKUP/$ANNEE_MOIS_NOW/$DATE_NOW/FIN_DE_TRANSFERT"                                               
                                                                                                                                            
# ----------- Fichier de log de travail                                                                                                     
LOG_INFO="$CURRENT_WORKING_REPO/backup_$DATE_NOW.log"                                                                                       
                                                                                                                                            
# -----------  Configuration de la conservation des fichiers                                                                                
CONSERVATION_FICHIER_IS_ACTIVE="yes"                                                                                                        
NBR_JOURS_CONSERVATION=90                                                                                                                   
REPOSITORY_CHMOD="770"                                                                                                                      
LISTE_REPO_A_SAUVEGARDER="/etc/ /home/gwadanina.net"                                    
                                                                                                                                            
# --------- Configuration du serveur MySQL en local                                                                                         
SQL_LOCAL_USER="backup"                                                                                                                  
SQL_LOCAL_PASSWORD="_secret"                                                                                                              
SQL_LOCAL_SERVER_HOST="localhost"                                                                                                           
                                                                                                                                            
# Database a ne pas sauvegarder (a separer par des espaces)                                                                                 
DATABASE_A_NE_PAS_SAUVEGARDER="information_schema"                                                                                          
                                                                                                                                            
# --------- Configuration des Mails de notifications                                                                                        
NOTIFICATION_MAIL_IS_ACTIVE="yes"                                                                                                           
NOTIFICATION_MAIL_ADRESSES="backup"                                                                                                    
NOTIFICATION_MAIL_SUJET="[BACKUP-$HOSTNAME]_$DATE_NOW"                                                                                      
                                                                                                                                            
# --------- Nombre de jour depuis la derniere installation du systeme                                                                       
# format de date ANNEEMOISJOURHEUREMINUTE                                                                                                   
DATE_INSTALLATION_SYSTEME=201111031000                                                                                                      
DATE_INSTALLATION_SYSTEME_FICHIER="$BACKUP_REPO/DATE_INSTALLATION_SYSTEME.$DATE_INSTALLATION_SYSTEME"                                       
                                                                                                                                            
# --------- Chargement d'une configuration sur le serveur                                                                                   
if [ -e $CUSTOM_CONFIG ]; then                                                                                                              
   source $CUSTOM_CONFIG                                                                                                                    
   echo "Chargement d'une configuration sur le serveur: $CUSTOM_CONFIG"                                                                     
fi                                                                                                                                          
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#       Preparation de l'environnement de travail             #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
# --------- Creation du repertoires de sauvegarde                                                                                           
[ ! -d "$CURRENT_WORKING_REPO" ] && "$MKDIR" -p "$CURRENT_WORKING_REPO" || :                                                                
# --------- Creation du repertoires de sauvegarde sql                                                                                       
[ ! -d "$CURRENT_WORKING_REPO_SQL" ] && "$MKDIR" -p "$CURRENT_WORKING_REPO_SQL" || :                                                        
# --------- Creation du repertoire temporaire                                                                                               
[ ! -d "$TMP_BACKUP_REPO" ] && "$MKDIR" -p "$TMP_BACKUP_REPO" || :                                                                          
                                                                                                                                            
# --------- Creation du fichier de log                                                                                                      
LOG_INFO="$CURRENT_WORKING_REPO/backup_$(date +%Y-%m-%d_%H.%M.%S).log";                                                                     
echo "[$(date +%F-%T)] - Sur le serveur $HOSTNAME, le repertoire de travail est : " "$CURRENT_WORKING_REPO" > "$LOG_INFO";                  
                                                                                                                                            
# --------- Creation du fichier d'unicite de programme                                                                                      
if [ ! -e $LOCKFILE ]; then                                                                                                                 
   $TRAP "$RM -f $LOCKFILE; exit" INT TERM EXIT 2> /dev/null                                                                                
   $TOUCH $LOCKFILE                                                                                                                         
   echo "[$(date +%F-%T)] - Creation du fichier d'unicite de programme : $LOCKFILE" >> "$LOG_INFO";                                         
else                                                                                                                                        
   echo "[$(date +%F-%T)] - Le programme est deja en cours d'execution car le fichier $LOCKFILE existe" >> "$LOG_INFO";                     
   echo "[$(date +%F-%T)] - Le programme est deja en cours d'execution car le fichier $LOCKFILE existe" ;                                   
   echo "[$(date +%F-%T)] - Fin du traitement" >> "$LOG_INFO";                                                                              
   exit 1                                                                                                                                   
fi                                                                                                                                          
                                                                                                                                            
# --------- Verification de l'existence des programmes sur le serveur                                                                       
                                                                                                                                            
COMMANDES_NECESSAIRES="$MYSQL $MYSQLDUMP $GZIP $MKDIR $MYSQLCHECK $RSYNC $SSH $MAIL $TAR $TOUCH $RM $TRAP $HOSTNAME"                        
COMMANDES_MANQUANTES=0                                                                                                                      
for COMMANDE_NECESSAIRE in "$COMMANDES_NECESSAIRES"; do                                                                                     
  if ! hash "$COMMANDE_NECESSAIRE" >/dev/null 2>&1; then                                                                                    
    printf "Command not found in PATH: %s\n" "$COMMANDE_NECESSAIRE" >&2                                                                     
    echo "[$(date +%F-%T)] - Erreur, le programme $COMMANDE_NECESSAIRE est necessaire" >> "$LOG_INFO";                                      
    ((COMMANDES_MANQUANTES++))                                                                                                              
  fi                                                                                                                                        
done                                                                                                                                        
                                                                                                                                            
if (($COMMANDES_MANQUANTES > 0)); then                                                                                                      
  echo "[$(date +%F-%T)] - Erreur, plusieurs programmes manquent pour l'execution du script" >> "$LOG_INFO";                                
  echo "[$(date +%F-%T)] - Fin du traitement" >> "$LOG_INFO";                                                                               
  exit 1                                                                                                                                    
fi                                                                                                                                          
                                                                                                                                            
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#       Lancement de la sauvegarde de la base de donnees      #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
echo "[$(date +%F-%T)] - Creation de la liste de toutes les bases de données" >> "$LOG_INFO";                                               
LISTE_BASE_DONNEES="$($MYSQL -u$SQL_LOCAL_USER -h$SQL_LOCAL_SERVER_HOST -p$SQL_LOCAL_PASSWORD -Bse 'show databases')";                      
                                                                                                                                            
if [ ! $? -eq 0 ] ; then                                                                                                                    
    echo "[$(date +%F-%T)] - Une erreur s'est produite lors de la creation de la liste des bases de données " >> "$LOG_INFO";               
fi                                                                                                                                          
                                                                                                                                            
echo "[$(date +%F-%T)] - Liste des bases de donnees : $LISTE_BASE_DONNEES" >> "$LOG_INFO";                                                  
                                                                                                                                            
for BASE in $LISTE_BASE_DONNEES                                                                                                             
do                                                                                                                                          
    # analyse et verification des tables                                                                                                    
    $MYSQLCHECK -u$SQL_LOCAL_USER -h$SQL_LOCAL_SERVER_HOST -p$SQL_LOCAL_PASSWORD --auto-repair  --optimize  "$BASE";                        
    if [ ! $? -eq 0 ] ; then                                                                                                                
        echo "[$(date +%F-%T)] - Une erreur s'est produite lors de l'analyse ou la verification de la table " "$BASE" "" >> "$LOG_INFO";    
    fi                                                                                                                                      
    skipdb=-1                                                                                                                               
    if [ "$DATABASE_A_NE_PAS_SAUVEGARDER" != "" ] ; then                                                                                    
        for i in $DATABASE_A_NE_PAS_SAUVEGARDER                                                                                             
        do                                                                                                                                  
            [ "$BASE" == "$i" ] && skipdb=1 && echo "[$(date +%F-%T)] - Pas de backup pour la base $BASE" >> "$LOG_INFO" || :               
        done                                                                                                                                
    fi                                                                                                                                      
                                                                                                                                            
    # Creation des dumps de la base                                                                                                         
    if [ "$skipdb" == "-1" ] ; then                                                                                                         
        echo "[$(date +%F-%T)] - Dump de la base $BASE" >> "$LOG_INFO";                                                                     
        SQL_FILE_NAME="$CURRENT_WORKING_REPO_SQL/$BASE.$DATE_NOW.sql.gz";                                                                   
        $MYSQLDUMP -u$SQL_LOCAL_USER -h$SQL_LOCAL_SERVER_HOST -p$SQL_LOCAL_PASSWORD $BASE | $GZIP -f -9 > "$SQL_FILE_NAME";                 
        if [ ! $? -eq 0 ] ; then                                                                                                            
            echo "[$(date +%F-%T)] - An error occurred in backing up " "$BASE" "tables." >> "$LOG_INFO";                                    
        else                                                                                                                                
            # taille de l'archive                                                                                                           
            FILESIZE=`ls -lh $SQL_FILE_NAME | awk '{print $5}'`                                                                             
            echo "[$(date +%F-%T)] - Creation de l'archive : $SQL_FILE_NAME ($FILESIZE)" >> "$LOG_INFO";                                    
        fi                                                                                                                                  
    fi                                                                                                                                      
done                                                                                                                                        
                                                                                                                                            
echo "[$(date +%F-%T)] - Creation d'un fichier de checksum pour les bases de donnees" >> "$LOG_INFO";                                       
$MD5SUM "$CURRENT_WORKING_REPO_SQL"/*.sql.gz > "$CURRENT_WORKING_REPO_SQL/sql.checksum.md5";                                                
                                                                                                                                            
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#        Suppression des anciens fichiers d'archive           #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
if [ "$CONSERVATION_FICHIER_IS_ACTIVE" = "yes" ] ; then                                                                                     
    echo "[$(date +%F-%T)] - Recherche et supprime les archives de plus $NBR_JOURS_CONSERVATION jours" >> "$LOG_INFO";                      
    "$FIND" "$BACKUP_REPO" -maxdepth 1 -type f -ctime +$NBR_JOURS_CONSERVATION  -exec $RM -v {} \;                                          
    if [ ! $? -eq 0 ] ; then                                                                                                                
        echo "[$(date +%F-%T)] - Une erreur s'est produite lors de la recherche et suppression des anciennes archives" >> "$LOG_INFO";      
    fi                                                                                                                                      
fi                                                                                                                                          
                                                                                                                                            
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#        Sauvegarde de la liste des packages installes        #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
echo "[$(date +%F-%T)] - Lancement de dpkg selection" >> "$LOG_INFO";                                                                       
$DPKG --get-selections | $GZIP -f -9  > "$CURRENT_WORKING_REPO/dpkg_--get-selections.$DATE_NOW.txt.gz";                                     
if [ ! $? -eq 0 ] ; then                                                                                                                    
  echo "[$(date +%F-%T)] - Une erreur s'est produite lors de la sauvegarde de la liste des packages installes " >> "$LOG_INFO";             
fi                                                                                                                                          
                                                                                                                                            
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#        Sauvegarde de la liste des configuration modifiés    #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
echo "[$(date +%F-%T)] - Lancement de la sauvegarde des fichiers de configuration modifiés" >> "$LOG_INFO";                                 
                                                                                                                                            
# creation du fichier de reference pour la date d'installation du systeme                                                                   
[ ! -d "$DATE_INSTALLATION_SYSTEME_FICHIER" ] && "$TOUCH" -t "$DATE_INSTALLATION_SYSTEME" "$DATE_INSTALLATION_SYSTEME_FICHIER" || :         
                                                                                                                                            
"$FIND" /etc -cnewer "$DATE_INSTALLATION_SYSTEME_FICHIER" -type f -exec cp --parents '{}' "$TMP_BACKUP_REPO" \;                             
if [ ! $? -eq 0 ] ; then                                                                                                                    
  echo "[$(date +%F-%T)] - Une erreur s'est produite lors de la sauvegarde des fichiers de configuration modifiés" >> "$LOG_INFO";          
else                                                                                                                                        
  $TAR czf "$CURRENT_WORKING_REPO/etc_modif_$DATE_NOW.tar.gz" "$TMP_BACKUP_REPO";                                                           
  if [ ! $? -eq 0 ] ; then                                                                                                                  
        echo "[$(date +%F-%T)] - Une erreur s'est produite lors de la sauvegarde des fichiers de configuration modifiés" >> "$LOG_INFO";    
  else                                                                                                                                      
        $RM -rf "$TMP_BACKUP_REPO"                                                                                                          
  fi                                                                                                                                        
fi                                                                                                                                          
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#        Lancement du backup des repertoires                  #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
                                                                                                                                            
echo "[$(date +%F-%T)] - Lancement du backup des sites" >> "$LOG_INFO";                                                                     
                                                                                                                                            
for REPO in $LISTE_REPO_A_SAUVEGARDER                                                                                                       
do                                                                                                                                          
   NOM_REPO=$(basename $REPO);                                                                                                              
   echo "[$(date +%F-%T)] - Traitement du repertoire $NOM_REPO pour $REPO" >> "$LOG_INFO";                                                  
   NBR_FICHIER_MODIFIER_HIER=$($FIND $REPO -type f -mmin -1440 -exec ls -l {} \; | grep -v '/galerie/_data/templates_c/' | grep -v '/galerie/_data/tmp/' | grep -v '/galerie/local/GThumb/' | grep -v '/galerie/local/combined/' | grep -v '/wiki/data/cache/' | grep -v '_dokuwiki.changes.trimmed' | wc -l);                                                                                  
   if [ ! $NBR_FICHIER_MODIFIER_HIER -eq 0 ] ; then                                                                                         
        echo "[$(date +%F-%T)] - Creation d'un nouveau fichier " >> "$LOG_INFO";                                                            
                                                                                                                                            
        # liste des differences entre version                                                                                               
        $FIND $REPO -type f -mmin -1440 -exec ls -l {} \; | grep -v '/galerie/_data/templates_c/' | grep -v '/galerie/_data/tmp/' | grep -v '/galerie/local/GThumb/' | grep -v '/galerie/local/combined/' | grep -v '/wiki/data/cache/'  | grep -v '_dokuwiki.changes.trimmed' ; >> "$LOG_INFO";                                                                                                
        # liste des fichiers modifies to file                                                                                               
        $TAR czf "$CURRENT_WORKING_REPO/$NOM_REPO.$DATE_NOW.tar.gz" "$REPO";                                                                
   else                                                                                                                                     
        echo "[$(date +%F-%T)] - Pas de modification pour le repertoire $REPO" >> "$LOG_INFO";                                              
        # ln -fs date hier                                                                                                                  
   fi                                                                                                                                       
done                                                                                                                                        
if [ ! $? -eq 0 ] ; then                                                                                                                    
  echo "[$(date +%F-%T)] - Une erreur s'est produite lors du lancement du backup des sites" >> "$LOG_INFO";                                 
fi                                                                                                                                          
                                                                                                                                            
echo "[$(date +%F-%T)] - Creation d'un fichier de checksum pour les sites" >> "$LOG_INFO";                                                  
$MD5SUM "$CURRENT_WORKING_REPO"/*.gz > "$CURRENT_WORKING_REPO/backup.checksum.md5";                                                         
                                                                                                                                            
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#        Mise a jour des droits des fichiers                  #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
echo "[$(date +%F-%T)] - mise a jour des droits des fichiers" >> "$LOG_INFO";                                                               
chown -R $LOCAL_USER:$LOCAL_GROUP $BACKUP_REPO $BACKUP_REPO_TMP;                                                                            
chmod -R 770 $BACKUP_REPO $BACKUP_REPO_TMP;                                                                                                 
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#        Synchronisation des fichiers vers le serveur distant #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
echo "[$(date +%F-%T)] - debut de de synchronisation vers le serveur $REMOTE_HOST" >> "$LOG_INFO";                                          
su - "$LOCAL_USER" -c "$RSYNC -azv -e '$SSH -p $REMOTE_PORT' $BACKUP_REPO $REMOTE_USER@$REMOTE_HOST:$REMOTE_PATH";                          
if [ ! $? -eq 0 ] ; then                                                                                                                    
  echo "[$(date +%F-%T)] - Erreur de synchronisation vers le serveur $REMOTE_HOST" >> "$LOG_INFO";                                          
fi                                                                                                                                          
                                                                                                                                            
# --------- Envoi d'un fichier vide de fin de transfert                                                                                     
su - "$LOCAL_USER" -c "$SSH -p $REMOTE_PORT $REMOTE_USER@$REMOTE_HOST '$TOUCH_REMOTE $REMOTE_PATH_FIN_DE_TRANSFERT'" >> "$LOG_INFO";        
if [ ! $? -eq 0 ] ; then                                                                                                                    
  echo "[$(date +%F-%T)] - Erreur d'envoi d'un fichier vide de fin de transfert" >> "$LOG_INFO";                                            
fi                                                                                                                                          
                                                                                                                                            
                                                                                                                                            
# --------- Retourne la liste des nouveaux fichiers sur le serveur distant depuis 24 heures                                                 
echo "[$(date +%F-%T)] - liste des nouveaux fichiers" >> "$LOG_INFO";                                                                       
su - "$LOCAL_USER" -c "$SSH -p $REMOTE_PORT $REMOTE_USER@$REMOTE_HOST '$FIND $REMOTE_PATH/ -type f -mmin -1440 -exec ls -l {} \; | sort -k7 '" | awk '{print $5, $8, $9}' >> "$LOG_INFO";                                                                                               
if [ ! $? -eq 0 ] ; then                                                                                                                    
  echo "[$(date +%F-%T)] - Erreur lors du retour de la liste des nouveaux fichiers sur le serveur distant depuis 24 heures" >> "$LOG_INFO"; 
fi                                                                                                                                          
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#        Vidage des repertoires /tmp du systeme               #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
echo "[$(date +%F-%T)] - Suppression des fichiers cree par apache de plus de 30 jours du repertoire /tmp" >> "$LOG_INFO";                   
"$FIND" /tmp/sess_* -type f -atime +30 -user www-data -exec $RM {} \;                                                                       
if [ ! $? -eq 0 ] ; then                                                                                                                    
  echo "[$(date +%F-%T)] - Une erreur s'est produite lors du la suppression des fichiers cree par apache de plus de 30 jours du repertoire /tmp" >> "$LOG_INFO";                                                                                                                        
fi                                                                                                                                          
                                                                                                                                            
echo "[$(date +%F-%T)] - Suppression des fichiers de plus de 30 jours des repertoires tmp des utilisateurs" >> "$LOG_INFO";                 
"$FIND" /home/*/tmp/ -type f -atime +30 -exec $RM {} \;                                                                                     
if [ ! $? -eq 0 ] ; then                                                                                                                    
  echo "[$(date +%F-%T)] - Une erreur s'est produite lors du la suppression des fichiers de plus de 30 jours des repertoires tmp des utilisateurs" >> "$LOG_INFO";                                                                                                                      
fi                                                                                                                                          
                                                                                                                                            
echo "[$(date +%F-%T)] - Suppression des fichiers de plus de 50 jours du repertoire de cache" >> "$LOG_INFO";                               
"$FIND" /var/tmp/ -type f -atime +50 -exec $RM {} \;                                                                                        
if [ ! $? -eq 0 ] ; then                                                                                                                    
  echo "[$(date +%F-%T)] - Une erreur s'est produite lors du la suppression des fichiers de plus de 50 jours du repertoire de cache" >> "$LOG_INFO";                                                                                                                                    
fi                                                                                                                                          
# ----------------------------------------------------------- #                                                                             
#        Fin du traitement de la maintenance                  #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
# --------- Suppression du fichier d'unicite de programme                                                                                   
if [ -e $LOCKFILE ]; then                                                                                                                   
   $RM $LOCKFILE                                                                                                                            
#   $TRAP - INT TERM EXIT                                                                                                                   
   echo "[$(date +%F-%T)] - Suppression du fichier d'unicite de programme" >> "$LOG_INFO";                                                  
fi                                                                                                                                          
                                                                                                                                            
echo "[$(date +%F-%T)] - Fin du traitement" >> "$LOG_INFO";                                                                                 
                                                                                                                                            
# ----------------------------------------------------------- #                                                                             
#        Envoi d'un mail recapitulatif (desactivable)         #                                                                             
# ----------------------------------------------------------- #                                                                             
                                                                                                                                            
if [ "$NOTIFICATION_MAIL_IS_ACTIVE" = "yes" ] ; then                                                                                        
  $MAIL -s "$NOTIFICATION_MAIL_SUJET" "$NOTIFICATION_MAIL_ADRESSES" < "$LOG_INFO";                                                          
  if [ ! $? -eq 0 ] ; then                                                                                                                  
    echo "[$(date +%F-%T)] - Erreur d'envoi du mail" >> "$LOG_INFO";                                                                        
  else                                                                                                                                      
    echo "[$(date +%F-%T)] - Envoi du mail OK" >> "$LOG_INFO";                                                                              
  fi                                                                                                                                        
fi                                                                                                                                          
                                                                                                                                            
echo "$LOG_INFO";                                                                                                                           
exit 0;

</code>

<code bash>
$ nano /etc/refresh-backup-complet.sh

#!/bin/bash
# Script de touch pour refresh backup complet d'un serveur Debian

# Written by Fabwice
# http://fabwice.com

LISTE_REPO_A_SAUVEGARDER="/home/gwadanina.net"

# --------- Parametres du systeme
TOUCH="$(which touch)"

#--------- Configuration du serveur local
LOCAL_USER="backup"
LOCAL_GROUP="backup"

echo "[$(date +%F-%T)] - Lancement du touch des sites";

for REPO in $LISTE_REPO_A_SAUVEGARDER
do
    NOM_REPO=$(basename $REPO);
    echo "[$(date +%F-%T)] - Traitement du repertoire $NOM_REPO pour $REPO";

REFRESH_BACKUP_FILE="$REPO/.refresh_backup";
    $TOUCH $REFRESH_BACKUP_FILE;
    chown -R $LOCAL_USER:$LOCAL_GROUP $REFRESH_BACKUP_FILE;
	chmod -R 600 $REFRESH_BACKUP_FILE;
done

if [ ! $? -eq 0 ] ; then
  echo "[$(date +%F-%T)] - Une erreur s'est produite lors du lancement du touch des sites";
fi

</code>

====== Connections à distance ======

===== Envoi de mail lors du log sous root =====

<code bash>
$ nano ~/.bashrc
# rajouter dans le fichier:

SUJET_MAIL="Accès Shell Root le `date` sur le `hostname`"
EMAIL_MESSAGE="Shell Root de `who -m`"
EMAIL="support@_fabwice.com_"

echo $EMAIL_MESSAGE | mail -s "$SUJET_MAIL" "$EMAIL"

# pour tester faire:
$ su -
# constater l'envoi du mail

</code>

===== OpenSSH =====
[[serveur:openssh]]

===== Fish =====
<code bash>
#Konqueror fait du ssh en mode graphique.
$fish://utilisateur@fabwice.com
</code>

===== Fail2ban =====
Pour bloquer une IP après un certain nombre de tentatives échouées. Utile pour les attaques par force brute de ssh.

===Configuration ===
fichier ///etc/fail2ban/jail.conf//

La configuration par defaut est correcte.
L'on peut mettre un log pour ssh : logfile = /var/log/fail2ban-ssh.log

<code bash>
$/etc/init.d/fail2ban restart
</code>

==ERROR: time data did not match format==

Si vous avez l'erreur ci dessus rajouter dans le fichier ///etc/default/fail2ban// 
<code bash>
export LC_ALL=C 
</code>

==Ajout de la Géolocalisation ==

<code bash>
$ aptitude install libgeoip1 geoip-bin
# test avec google.fr
$ geoiplookup 216.239.59.104
$ cp /usr/share/fail2ban/server/actions.py /usr/share/fail2ban/server/actions.py.old
$ nano /usr/share/fail2ban/server/actions.py
</code>

Remplacer //import time, logging// par //import time, logging, commands//

Remplacer logSys.warn("[%s] Ban %s" % (self.jail.getName(), aInfo["ip"])
par
//logSys.warn("[%s] Ban %s %s" % (self.jail.getName(), aInfo["ip"], commands.getstatusoutput('geoiplookup ' + aInfo["ip"])[1][23:]))//

rajouter dans cron: @monthly sleep $[$RANDOM/1024]; wget -q http://geolite.maxmind.com/download/geoip/database/GeoLiteCountry/GeoIP.dat.gz -O - | gunzip > /usr/share/GeoIP/GeoIP.dat.new && mv /usr/share/GeoIP/GeoIP.dat.new /usr/share/GeoIP/GeoIP.dat

=== Testez l'état des jails ===

<code bash> 
# état de toutes les règles
$ /usr/bin/fail2ban-client status
# détail pour une règle en particulier
$ /usr/bin/fail2ban-client status ssh
</code>

Résumé

Note : En modifiant cette page, vous acceptez que le contenu soit placé sous les termes de la licence suivante : CC Attribution-Share Alike 4.0 International