Oct 042012
 

Voici un script d’init pour linux, pour limiter la bande passante utilisée sur une interface réseau et avec une IP.
tc se trouve dans le paquet debian iproute.

#!/bin/bash
### BEGIN INIT INFO
# Provides:          tc
# Required-Start:    $syslog $network $remote_fs
# Required-Stop:     $syslog $network $remote_fs
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Bandwidth Shaping
# Description:       Bandwidth Shaping
### END INIT INFO
#  tc uses the following units when passed as a parameter.
#  kbps: Kilobytes per second 
#  mbps: Megabytes per second
#  kbit: Kilobits per second
#  mbit: Megabits per second
#  bps: Bytes per second 
#       Amounts of data can be specified in:
#       kb or k: Kilobytes
#       mb or m: Megabytes
#       mbit: Megabits
#       kbit: Kilobits
#
 
#
# Name of the traffic control command.
TC=/sbin/tc
 
# The network interface we're planning on limiting bandwidth.
IF=eth0             # Interface
 
# Download limit (in mega bits)
DNLD=10mbit          # DOWNLOAD Limit
 
# Upload limit (in mega bits)
UPLD=10mbit          # UPLOAD Limit
 
# Burst limit
BURST=2mbit
 
# IP address of the machine we are controlling
IP=10.0.1.1     # Host IP
 
# Filter options for limiting the intended interface.
U32="$TC filter add dev $IF protocol ip parent 1:0 prio 1 u32"
 
start() {
    $TC qdisc add dev $IF root handle 1: htb default 30
    $TC class add dev $IF parent 1: classid 1:1 htb rate $DNLD burst $BURST cburst $BURST
    $TC class add dev $IF parent 1: classid 1:2 htb rate $UPLD burst $BURST cburst $BURST
    $U32 match ip dst $IP/32 flowid 1:1
    $U32 match ip src $IP/32 flowid 1:2
}
 
stop() {
    $TC qdisc del dev $IF root
}
 
restart() {
    stop
    sleep 1
    start
}
 
show() {
    $TC -s qdisc ls dev $IF
    echo ""
    $TC -s class show dev $IF
}
 
showfilter() {
    $TC -s filter show dev $IF
}
 
case "$1" in
 
  start)
    echo -n "Starting bandwidth shaping: "
    start
    echo "done"
    ;;
 
  stop)
    echo -n "Stopping bandwidth shaping: "
    stop
    echo "done"
    ;;
 
  restart)
    echo -n "Restarting bandwidth shaping: "
    restart
    echo "done"
    ;;
 
  show)
    echo "Bandwidth shaping status for $IF:"
    show
    echo ""
    ;;
 
  showfilter)
    echo "Filter shaping status for $IF:"
    showfilter
    echo ""
    ;;
 
  *)
    pwd=$(pwd)
    echo "Usage: ./tc {start|stop|restart|show|showfilter}"
    ;;
 
esac
 
exit 0
Juin 252012
 

Le multiplexage SSH consiste à créer une connexion MASTER et passer les connexions suivantes (dite SLAVE) par la connexion MASTER.
L’avantage est que les connexions SLAVE ne rouvrent pas une autre négociation de connexion, et se font donc beaucoup plus vite.

Pour utiliser le multiplexage SSH, il faut utiliser un socket

  • Création de la connexion MASTER :
ssh -MS socket-ssh user@host
  • Si besoin, création de la connexion MASTER en background :
ssh -NMS socket-ssh user@host &

ou

ssh -NnfMS socket-ssh user@host
  • Connexion slave :
ssh -S socket-ssh user@host
  • Fermer la connexion MASTER si background :
kill <le PID>

ou

ssh -O exit -S socket-ssh user@host
 Posted by at 13 h 42 min  Tagged with:
Mai 112012
 
#!/bin/bash
# Nom du lv a backup
lv='var_lib_mysql'
 
# Connect mysql
mysql='/usr/bin/mysql -uroot -p'
 
# Chemin
chem='/mnt/snapshot'
backup='/var/backup'
rapport='/tmp/rapport_backup.txt'
log='/var/log/backup.log'
 
# Size
snapshot_size='30G'
 
# Bin
rsync='/usr/bin/rsync'
cut='/usr/bin/cut'
grep='/bin/grep'
awk='/usr/bin/awk'
lvs='/sbin/lvs'
vgs='/sbin/vgs'
lvdisplay='/sbin/lvdisplay'
lvcreate='/sbin/lvcreate'
lvremove='/sbin/lvremove'
mount='/bin/mount'
umount='/bin/umount'
rm='/bin/rm'
df='/bin/df'
 
# DATE
TODAY=$(date '+%Y.%m.%d')
DELETE=$(date -d now-1days '+%Y.%m.%d')
 
function quit {
	# Send rapport if error
	if [ -s /tmp/rapport_backup.txt ]; then
	        /usr/bin/mail -s "Erreur de backup $DATE" user@test.fr < /tmp/rapport_backup.txt
	        $rm /tmp/rapport_backup.txt
		exit 1
	fi
	$rm /tmp/rapport_backup.txt
	exit 0
}
 
echo "Debut des verifs et suppression des anciens backups : `date +%Y.%m.%d-%Hh%M`" >> $log
 
## Suppression rapport 
if [ -f $rapport ]; then
        $rm $rapport
fi
 
## Verifications paquet 
if ! dpkg -l rsync |grep ^ii >/dev/null ; then 
        apt-get install rsync --force-yes &> /dev/null
        if ! dpkg -l rsync |grep ^ii >/dev/null ; then
                echo "Erreur : Installation paquet rsync !!!!" >> $rapport
		quit
        fi
fi
 
# Verif lv existe
if ! $lvdisplay | $grep 'LV Name' | $cut -d/ -f4 | $grep $lv &> /dev/null ; then
	echo "Erreur : LV $lv n'existe pas" >> $rapport
	quit
fi
 
# Verif si chem existe
if [ ! -d $chem ] ; then
	/bin/mkdir $chem
fi
if [ ! -d $chem ] ; then
	echo "Erreur : Impossible de créer $chem" >> $rapport
	quit
fi
 
# Verif si backup existe
if [ ! -d $backup ] ; then
	/bin/mkdir $backup
fi
if [ ! -d $backup ] ; then
	echo "Erreur : Impossible de créer $backup" >> $rapport
	quit
fi
 
# Verif freespace for snap
VG=$($lvs | $grep $lv | $awk '{print $2}' | uniq )
VG_free=$($vgs | $grep $VG | $awk '{print $7}' | $cut -d'G' -f1 | $cut -d'g' -f1 | $cut -d',' -f1)
if [ $(echo $snapshot_size | $cut -d'G' -f1 | $cut -d'g' -f1 | $cut -d',' -f1) -ge $VG_free ] ; then
	echo "Erreur : Pas assez de place pour créer le snaphot" >> $rapport
	quit
fi
 
# Verif si snap existe
if $lvs | $grep $VG | $grep lvmsnap &> /dev/null ; then
	echo "Erreur : LV lvmsnap existe" >> $rapport
	quit
fi
 
# Verif si chem déjà monté
if $mount | $grep $chem &> /dev/null ; then
	echo "Erreur : $chem déjà monté">> $rapport
        quit
fi
 
# Delete old backup
if [ -d $backup/$DELETE ] ; then
	$rm -r $backup/$DELETE
fi
if [ -d $backup/$DELETE ] ; then
	echo "Erreur : Impossible de supprimer $backup/$DELETE" >> $rapport
	quit
fi
 
# Chemin lv mapper
LVmapper=$(echo $lv | sed 's/-/--/' )
 
# Compare freespace backup > usedspace source (if source mount)
if $mount | $grep $LVmapper &> /dev/null ; then
	LVmount=$($mount | $grep $LVmapper | $awk '{print $3}')
	if [ $($df -P $backup | $grep '/' | $awk '{print $4}') -lt $($df -P $LVmount | $grep '/' | $awk '{print $3}') ] ; then
		echo "Erreur : Espace restant sur la destination du backup non suffisant" >> $rapport
		quit
	fi
fi
 
 
# Backup
	## Log time 
        echo "Debut du backup : `date +%Y.%m.%d-%Hh%M`" >> $log
 
	# Chemin dev lv
	LVS=$($lvdisplay | $grep 'LV Name' | $grep $lv | $awk '{print $3}')
 
	# Stop replication
	$mysql -e"stop slave;"
	if ! $mysql -e"show slave status\G" | $grep "Slave_SQL_Running" | $grep "No" &> /dev/null ; then
		echo "Erreur : La réplication ne s'arrête pas avant le snaphost" >> $rapport
                quit
        fi
	# Create snap
	$lvcreate -L$snapshot_size -s -n lvmsnap $LVS
 
	# Start replication
	$mysql -e"start slave;"
	if ! $mysql -e"show slave status\G" | $grep "Slave_SQL_Running" | $grep "Yes" &> /dev/null ; then
                echo "Waring : La réplication ne démarre pas après le snapshot" >> $rapport
        fi
	SNAP=$($lvdisplay | $grep 'LV Name' | $grep lvmsnap | $awk '{print $3}')
	if [ ! $SNAP ] ; then
		echo "Erreur : Impossible de créer le snaphost"  >> $rapport
		quit
	fi
 
	$mount $SNAP $chem
 
	# Copy
	$rsync -a $chem/ $backup/$TODAY/ >> $rapport
 
	$umount $chem
 
	# Check snapshot used
	if [ $($lvs | $grep lvmsnap | $awk '{print $6}') = 100.00 ] ; then
		echo "Erreur : Snapshot plein à la fin du backup" >> $rapport
		$rm -rf $backup/$TODAY
		$lvremove -f $SNAP
		quit
	fi
	if [ $($df $backup/$TODAY | $grep '/' | $awk '{print $3}') -le 0 ] ; then
		echo "Erreur : Destination du backup plein après la copie" >> $rapport
                $rm -rf $backup/$TODAY
		$lvremove -f $SNAP
		quit
        fi
	$lvremove -f $SNAP
 
	## Log time 
        echo "Fin du backup : `date +%Y.%m.%d-%Hh%M`" >> $log
 
quit
Avr 022012
 

Pour se protéger des attaques SYN FLOOD :

Limiter le nombre de connexions parallèles par IP :

iptables -A INPUT -p tcp --syn --dport 80 -m connlimit --connlimit-above 20 -j DROP

Pour se protéger des attaques par SYN FLOOD et QUERY FLOOD :

Limiter le nombre de connexions par seconde par IP (exemple 20 maximum sur 10 secondes sur le port 80):
Le Hitcount ne doit pas être supérieur à 20

iptables -A INPUT -p tcp --dport 80 -i eth0 -m state --state NEW -m recent --set
iptables -I INPUT -p tcp --dport 80 -m state --state NEW -m recent --update --seconds 10 --hitcount 20 -j DROP

Plus radical, limiter le nombre de paquet syn par seconde :

iptables -A INPUT -p tcp --syn -m limit --limit 10/s --limit-burst 13 -j DROP

Ou limiter le nombre de paquet syn par seconde par range d’ip (exemple /28) :

iptables -A INPUT -p tcp --dport 80 --tcp-flags SYN SYN -m hashlimit --hashlimit-name Web \
--hashlimit-above 10/second --hashlimit-mode srcip --hashlimit-burst 13 --hashlimit-srcmask 28 -j DROP

Pour bloquer une requête HTTP :

iptables -I INPUT -p tcp --dport 80 -m string --to 70 --algo bm --string 'GET /w00tw00t' -j DROP

Pour log les IPs qui flood ajouter :

iptables -N flood
iptables -A flood -j LOG --log-prefix "FLOOD "
iptables -A flood -j DROP

et remplacer DROP par flood aux règles précédentes

Mar 062012
 

Si votre routeur a un cache arp trop long, il est possible d’envoyer une trame ARP en broadcast ou ciblant directement le routeur où on déclare une IP et la MAC correspondante, et ainsi rafraîchir le cache.

Un inconvénient, la plupart des équipements réseau sécurise leur cache ARP pour éviter du ARP spoofing. Ils refusent les paquets de réponse ARP qui ne correspondent pas à une demande.

Un petit script pour envoyer ces paquets automatiquement en récupérant les adresses définis et la passerelle du système :

#!/bin/bash
 
TEST_IP=8.8.8.8
if [ ! -x /sbin/ip ] ; then
        apt-get install iproute -y
fi
if [ ! -x /bin/grep ] ; then
        apt-get install grep -y
fi
 
GW=`/sbin/ip route list | /bin/grep default | /usr/bin/awk '{print $3}'`
DEV=`/sbin/ip route list | /bin/grep default | /usr/bin/awk '{print $5}'`
 
if [ ! -x /usr/sbin/arping ] ; then
        apt-get install arping -y
fi
 
if [ ! -x /usr/bin/fping ] ; then
        apt-get install fping -y
fi
 
for ip in `/sbin/ip address list $DEV | /bin/grep "inet " | /usr/bin/awk '{print $2}' | /usr/bin/cut -d'/' -f1` ; do
        if [ `/usr/bin/fping -S $ip -c 1 $TEST_IP 2>&1 | /bin/grep "0% loss" | /usr/bin/wc -l` -eq 0 ] ; then
                echo "ARPING from $ip"
                /usr/sbin/arping -S $ip -c 1 -w 2 -i $DEV $GW &> /dev/null
        fi
done
 Posted by at 13 h 27 min  Tagged with: