[Lundi] Table 5

Résumé du 22/09/2008
======================

Groupe 3R11

I- Introduction au cours de AIR.

II- Vérification du bon fonctionnement des machines :
Nous avons malheureusement dû faire une réinstallation de quelques machines

machine GW : Partition (/dev/hda1)
Installation et configuration faites
Configuration du bon ordre des cartes réseaux

machine DMZ : choix de la Partition(/dev/hda2)

Définition du Login et password pour chaque machine
Login : vénérable grand maitre
Password : Lundi

III- Conslusion :
Les trois machines sont installées et la/les carte(s) réseau de chacune ces
machines est/sont configurée(s) et fonctionnelle(s).

Plan d’adressage :

GateWay :
* eth0 : 172.16.0.205
* eth1 : 172.16.15.1
* eth2 : 172.16.25.1
* GW : 172.16.0.4 (Belenos)

Client :
* eth0 : 172.16.25.2
* GW : 172.16.25.1

DMZ :
* eth0 : 172.16.15.2
* GW : 172.16.15.1

Schéma:

Résumé du 29/09/2008
=================

I- Recherche d'informations sur NetFilter.

sources:
http://www.ibisc.univ-evry.fr/~petit/Enseignement/AdminSystem/Administration-reseau-avancee/2006-02-ASRA-fw-nat-Cours2-netfilter.pdf

http://irp.nain-t.net/doku.php/130netfilter:020_conntrack

http://oceanpark.com/notes/firewall_example.html

Netfilter dispose d'une commande à tout faire : IPtables qui va permettre, entre autres, d'écrire des chaînes de règles dans des tables.
Il existe dans Netfilter deux principales tables qui vont servir à contenir des règles de filtrage:

Table Filter va contenir toutes les règles qui permettront de filtrer les paquets. Cette table contient trois chaînes :
* la chaîne INPUT : décidera du sort des paquets entrant localement sur l'hôte
* la chaîne OUTPUT :ce ne sont que les paquets émis par l'hôte local qui seront filtrés ;
* la chaîne FORWARD :les paquets qui traversent l'hôte, suivant les routes implantées, seront filtrés ici.

La table NAT :permet d'effectuer toutes les translations d'adresses nécessaires. Cette table contient trois chaînes :
* La chaîne PREROUTING :Permet de faire de la translation d'adresse de destination. Cette méthode est intéressante si l'on veut faire croire au monde extérieur, par exemple, qu'il y a un serveur WEB sur le port 80 de la passerelle, alors que celui-ci est hébergé par un hôte du réseau privé, sur le port 8080.
* La chaîne POSTROUTING :permet de faire de la translation d'adresse de la source, comme du masquage d'adresse, la méthode classique pour connecter un réseau privé comme client de l'Internet, avec une seule adresse IP publique.
* La chaîne OUTPUT :va permettre de modifier la destination de paquets générés localement (par la passerelle elle-même).

En conslusion donc, les chaînes sont des ensembles de règles que nous allons écrire dans chaque table. Ces chaînes vont permettre d'identifier des paquets qui correspondent à certains critères.

Les cibles enfin sont des sortes d'aiguillage qui dirigeront les paquets satisfaisant aux critères. Les cibles préconstruites sont :
* ACCEPT :Les paquets qui satisfont aux critères sont acceptés, ils continuent leur chemin dans la pile,
* DROP :Les paquets qui satisfont aux critères sont rejetés, on les oublie, on n'envoie même pas de message ICMP . Un trou noir, quoi.
* LOG :C'est une cible particulière qui permet de tracer au moyen de syslog les paquets qui satisfont aux critères.

Suivant les contextes, d'autres cibles deviennent accessibles, comme REJECT (similaire à DROP, mais avec envoi d'un message d'erreur ICMP à la source du paquet rejeté), RETURN, REDIRECT…

II- Manipulation :

* Affiche les chaines et les règles:

iptables -L

* Permet au noyau Linux de faire transiter les paquets entres ses interfaces réseaux:

echo 1 > /proc/sys/net/ipv4/ip_forward

* Rejeter les paquets:

iptables -A FORWARD -i eth2 -s 172.16.15.2 -j drop

Test effectué : ping www.google.be sur la machine cliente. Résultat : les paquets sont rejetés.


* Supprimer la règle 1:

iptables -D FORWARD 1

* Fermeture des portes et transfert d'information:

iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT DROP

* Sur la GW:
Nous avons écrit un script de démarrage :

#!/bin/sh
iptables -F
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A OUTPUT -p tcp --sport 22 -j ACCEPT

Test : Connexion depuis une autre machine: ssh entre machines des différentes tables:

ssh 172.16.25.1 -l vénérable grand maitre

Tous les ports et protocoles associés aux services se trouvent:

cat /etc/services/services | grep ssh

To be continued ...

Résumé du 06/10/2008
====================

Installation de wireShark sur les machines (dmz / gw / client) afin de pouvoir analyser les paquets qui transitent et donc savoir plus facilement les règles iptables à appliquer :

Voici le script utilisé (attention, il est peut-être nécessaire de modifier la version des sources disponibles dans ttp://www.wireshark.org/download/src/ :

Code:


#!/bin/sh
# $Id: wireshark.SlackBuild,v 1.1 2006/12/17 16:48:13 vénérable grand maitre Exp vénérable grand maitre $
# Copyright (c) 2006 Eric Hameleers <alien@slackware.com>
# -----------------------------------------------------------------------------
#
# Slackware SlackBuild script
# ===========================
# By:        Eric Hameleers <alien@slackware.com>
# For:      wireshark
# Descr:    network protocol analyzer
# URL:      http://www.wireshark.org/
# Needs:    libpcap
# Changelog:
# 0.99.4-1:  17/Dec/2006 by Eric Hameleers <alien@slackware.com>
#            * Initial build.
#
# Run 'sh wireshark.SlackBuild --cleanup' to build a Slackware package.
# The package (.tgz) plus descriptive .txt file are created in /tmp .
# Install using 'installpkg'.
#
# -----------------------------------------------------------------------------

# --- INIT ---
# Set initial variables:

PRGNAM=wireshark
VERSION=${VERSION:-1.0.3}
ARCH=${ARCH:-i486}
BUILD=${BUILD:-1}

DOCS="AUTHORS* ChangeLog COPYING FAQ INSTALL* NEWS README README.linux \
      doc/randpkt.txt doc/README.*"

# Where do we look for sources?
CWD=`pwd`
SRCDIR=`dirname $0`
[ "${SRCDIR:0:1}" == "." ] && SRCDIR=${CWD}/${SRCDIR}

# Place to build (TMP) package (PKG) and output (OUTPUT) the program:
TMP=${TMP:-/tmp/build}
PKG=$TMP/package-$PRGNAM
OUTPUT=${OUTPUT:-/tmp}

# Input URL: http://www.wireshark.org/download/src/wireshark-0.99.4.tar.gz
SOURCE="$SRCDIR/${PRGNAM}-${VERSION}.tar.gz"
SRCURL="http://www.wireshark.org/download/src/${PRGNAM}-${VERSION}.tar.gz"

##
## --- with a little luck, you won't have to edit below this point --- ##
##

# Exit the script on errors:
set -e
trap 'echo "$0 FAILED at line $LINENO!" | tee $OUTPUT/error-${PRGNAM}.log' ERR
# Catch unitialized variables:
set -u
P1=${1:-1}

# Slackware 11 and up need other option (gcc > 3.3.x)
if [ `gcc -dumpversion | tr -d  '.' |cut -c 1-2` -gt 33 ]; then
  MOPT=tune
else
  MOPT=cpu
fi

case "$ARCH" in
  i386)      SLKCFLAGS="-O2 -march=i386 -m${MOPT}=i686"
            SLKLDFLAGS=""; LIBDIRSUFFIX=""
            ;;
  i486)      SLKCFLAGS="-O2 -march=i486 -m${MOPT}=i686"
            SLKLDFLAGS=""; LIBDIRSUFFIX=""
            ;;
  s390)      SLKCFLAGS="-O2"
            SLKLDFLAGS=""; LIBDIRSUFFIX=""
            ;;
  powerpc)  SLKCFLAGS="-O2"
            SLKLDFLAGS=""; LIBDIRSUFFIX=""
            ;;
  x86_64)    SLKCFLAGS="-O2 -fPIC"
            SLKLDFLAGS="-L/usr/lib64"; LIBDIRSUFFIX="64"
            ;;
  athlon-xp) SLKCFLAGS="-march=athlon-xp -O3 -pipe -fomit-frame-pointer"
            SLKLDFLAGS=""; LIBDIRSUFFIX=""
            ;;
esac

if [ ! -d $TMP/tmp-$PRGNAM ]; then
  mkdir -p $TMP/tmp-$PRGNAM # location to build the source
elif [ "$P1" != "--oldbuild" ]; then
  # If the "--oldbuild" parameter is present, we keep
  #  the old build files and continue;
  # By default we remove the remnants of previous build and continue:
  rm -rf $TMP/tmp-$PRGNAM/*
fi

if [ ! -d $PKG ]; then
  mkdir -p $PKG  # place for the package to be built
else
  rm -rf $PKG/*  # We always erase old package's contents:
fi

if [ ! -d $OUTPUT ]; then
  mkdir -p $OUTPUT  # place for the package to be saved
fi


# --- SOURCE FILE AVAILABILITY ---

if ! [ -f ${SOURCE} ]; then
  if ! [ "x${SRCURL}" == "x" ]; then
    # Check if the $SRCDIR is writable at all - if not, download to $OUTPUT
    [ -w "$SRCDIR" ] || SOURCE="$OUTPUT/`basename $SOURCE`"
    echo "Source '`basename ${SOURCE}`' not available yet..."
    echo "Will download file to `dirname $SOURCE`"
    wget -nv -O "${SOURCE}" "${SRCURL}" || true
    if [ $? -ne 0 ]; then
      echo "Downloading '`basename ${SOURCE}`' failed... aborting the build."
      mv -f "${SOURCE}" "${SOURCE}".FAIL
      exit 1
    fi
  else
    echo "File '`basename ${SOURCE}`' not available... aborting the build."
    exit 1
  fi
fi

if [ "$P1" == "--download" ]; then
  echo "Download complete."
  exit 0
fi

# --- PACKAGE BUILDING ---

echo "++"
echo "|| $PRGNAM-$VERSION"
echo "++"

cd $PKG

# Explode the package framework:
if [ -f $SRCDIR/_$PRGNAM.tar.gz ]; then
  explodepkg $SRCDIR/_$PRGNAM.tar.gz
fi

cd $TMP/tmp-$PRGNAM


# --- TARBALL EXTRACTION,PATCH,MODIFY ---

echo "Extracting the source archive(s) for $PRGNAM..."
if `file ${SOURCE} | grep -q ": bzip2"`; then
  tar -xjvf ${SOURCE} || true
elif `file ${SOURCE} | grep -qi ": zip"`; then
  unzip ${SOURCE} || true
elif `file ${SOURCE} | grep -qi ": 7-zip"`; then
  7za -x ${SOURCE} || true
else
  tar -xzvf ${SOURCE} || true
fi
if [ $? -ne 0 ]; then
  echo "Error in unpacking '${SOURCE}!' Aborting..."
  exit $?
fi
if [ -d ${PRGNAM}-${VERSION} ]; then
  cd ${PRGNAM}-${VERSION}
else
  cd  ${PRGNAM}*  # a little less specific
fi

chown -R vénérable grand maitre.vénérable grand maitre *
find . -perm 777 -exec chmod 755 {} \;
find . -perm 666 -exec chmod 644 {} \;


# --- BUILDING ---

echo Building ...

LDFLAGS="$SLKLDFLAGS" \
CFLAGS="$SLKCFLAGS" \
./configure --prefix=/usr \
            --libdir=/usr/lib${LIBDIRSUFFIX} \
            --localstatedir=/var \
            --sysconfdir=/etc \
            --enable-wireshark \
            --enable-gtk2 \
            --with-pcre \
            --enable-randpkt \
            --with-plugins=/usr/lib${LIBDIRSUFFIX}/${PRGNAM} \
            --program-prefix="" \
            --program-suffix="" \
            $ARCH-slackware-linux \
            2>&1 | tee $OUTPUT/configure-${PRGNAM}.log
make 2>&1 | tee $OUTPUT/make-${PRGNAM}.log

#
# Install all the needed stuff to the package dir
#
# Use installwatch if available, to produce a logfile of the installation
# process that is more easily readable:
if `which installwatch  > /dev/null 2>&1`; then
  installwatch -o $OUTPUT/install-${PRGNAM}.log \
    make DESTDIR=$PKG install install-man
else
  make DESTDIR=$PKG install install-man 2>&1 |tee $OUTPUT/install-${PRGNAM}.log
fi

# Kismet needs the wtap.h header in order to link against
# Wireshark's wiretap library:
mkdir -p $PKG/usr/include
cp -a wiretap/wtap.h $PKG/usr/include/

# Install the missing .desktop entry:
mkdir -p $PKG/usr/share/{applications,pixmaps}
cp -a image/wsicon*.png $PKG/usr/share/pixmaps/
( cd $PKG/usr/share/pixmaps && ln -s wsicon64.png wsicon.png )
sed -e s"#^Icon=\(.*\)#Icon=/usr/share/pixmaps/\1#" ${PRGNAM}.desktop > $PKG/usr/share/applications/$PRGNAM.desktop


# --- DOCUMENTATION ---

mkdir -p $PKG/usr/doc/$PRGNAM-$VERSION
cp -a $DOCS $PKG/usr/doc/$PRGNAM-$VERSION || true
chmod -R a-w $PKG/usr/doc/$PRGNAM-$VERSION/*

# Move incorrectly installed man pages, if any
[ -d $PKG/usr/share/man ] && \
  mv $PKG/usr/share/man $PKG/usr/ && rmdir $PKG/usr/share || true
# Compress the man page(s)
[ -d $PKG/usr/man ] && (
  cd  $PKG/usr/man
  find . -type f -name "*.?" -exec gzip -9f {} \;
  for i in `find . -type l -name "*.?"` ; do ln -s $( readlink $i ).gz $i.gz ; rm $i ; done
  )

# Strip binaries
( cd $PKG
  find . | xargs file | grep "executable" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
  find . | xargs file | grep "shared object" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
)


# --- OWNERSHIP, RIGHTS ---

chmod -R o-w $PKG


# --- PACKAGE DEscriptION ---

mkdir -p $PKG/install
cat $SRCDIR/slack-desc > $PKG/install/slack-desc
if [ -f $SRCDIR/doinst.sh ]; then
  cat $SRCDIR/doinst.sh >> $PKG/install/doinst.sh
fi


# --- BUILDING ---

# Build the package:
cd $PKG
makepkg --linkadd y --chown n $OUTPUT/${PRGNAM}-${VERSION}-${ARCH}-${BUILD}.tgz \
  2>&1 | tee $OUTPUT/makepkg-${PRGNAM}.log
(cd $OUTPUT && md5sum ${PRGNAM}-${VERSION}-${ARCH}-${BUILD}.tgz > ${PRGNAM}-${VERSION}-${ARCH}-${BUILD}.tgz.md5)
cat $PKG/install/slack-desc | grep "^${PRGNAM}" > $OUTPUT/${PRGNAM}-${VERSION}-${ARCH}-${BUILD}.txt


# --- CLEANUP ---

# Clean up the extra stuff:
if [ "$P1" = "--cleanup" ]; then
  rm -rf $TMP/tmp-$PRGNAM
  rm -rf $PKG
fi



Modification du script pour séparer en modules selon les différents besoins.

Code:

#!/bin/sh

#fichier firewall : reprend l'ensemble des modules à charger

#Flush des règles IPTABLES

iptables -F

#Choix de la politique par défaut : on bloque !

iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP

#ACTIVATION DE L'IP FORWARDING
./ip_forward
#ACTIVATION DES PARAMETRES SSH
./ssh


Code:

#!/bin/sh
#fichier ip_forward
#ACTIVATION DE L'IP FORWARDING
echo 1 > /proc/sys/net/ipv4/ip_forward


Code:

#!/bin/sh
#fichier no_firewall
iptables -F
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT

Code:

#!/bin/sh
#Fichier ssh

#Activation du ssh d'une machine du réseau dmz vers la gateway

iptables -A INPUT -p tcp --dport 22 -i eth2 -j ACCEPT
iptables -A OUTPUT -p tcp --sport 22 -o eth2 -j ACCEPT -m state --stat ESTABLISHED

#Activation du ssh d'une machine du réseau client vers la gateway

iptables -A INPUT -p tcp --dport 22 -i eth0 -j ACCEPT
iptables -A OUTPUT -p tcp --sport 22 -o eth0 -j ACCEPT -m state --stat ESTABLISHED

#Activation du ssh du réseau dmz vers le réseau client et vice-versa

iptables -A FORWARD -p tcp --dport 22 -i eth0 -o eth2 -j ACCEPT
iptables -A FORWARD -p tcp --sport 22 -i eth0 -o eth2 -j ACCEPT
iptables -A FORWARD -p tcp --dport 22 -i eth2 -o eth0 -j ACCEPT
iptables -A FORWARD -p tcp --sport 22 -i eth2 -o eth0 -j ACCEPT