Convertir une base sql en utf8

Convertir une base sql en utf8v

Introduction

Il se peut que lors d’un changement de version de Mysql , ou bien lors de l’upgrade de l’une de vos machines , vous ayez un problème d’accents dans vos pages internet .
Votre encodage étant deffectueux , il convient de passer votre base de données en UTF-8, ceci à l’aide de quelques manipulations simples.

Installation

urpmi libjconv
installera votre paquetage le plus simplement du monde

Conversion

À présent nous allons exporter la base de données que vous souhaitez convertir en UTF-8.
Pour cela, nous allons utiliser mysqldump:
mysqldump –opt -u root -p ma_base > ma_base.sql
une petite sauvegarde au cas ou :
cp ma_base.sql ma_base.sql.bak
Pour convertir au format utf8
iconv -f iso-8859-1 -t utf8 ma_base.sql > ma_base_utf.sql
Et ensuite reintégrer la base dans le serveur sql : mysql -u root -p ma_base < ma_base_utf.sql

Encoder des fichiers déjà crées

Vous avez commencé à convertir votre site, et vous vous apercevez que vous avez des fichiers précédents encodés en latin. La fonction utf8_encode permet d’encoder une chaine de caractères donnée (encodée en latin1, soit ISO-8859-1) en UTF-8.
Lancer le script suivant dans votre répertoire et tous les fichiers ainsi que ceux de vos sous-répertoires seront encodés

<?php
function encoderDossier ($dossierAEncoder)
{
$dossier = opendir ($dossierAEncoder);while ($fichierAEncoder = readdir ($dossier))
{
if ($fichierAEncoder != ‘.’ AND $fichierAEncoder != ‘..’)
{
if (is_file ($fichierAEncoder))
{
$contenu = file_get_contents ($fichierAEncoder);
$fichier = fopen ($fichierAEncoder, ‘w’);
fputs ($fichier, html_entity_decode (utf8_encode ($contenu)));
fclose ($fichier);
}else
encoderDossier ($dossierAEncoder . $fichierAEncoder . ‘/’);
}
}
closedir ($dossier);
}

encoderDossier (‘./’);
?>

Source de l’article

 

Shell

Shell

Programmation shell

L e shell n’est pas qu’un simple interpréteur de commandes, mais dispose d’un véritable langage de programmation avec notamment une gestion des variables, des tests et des boucles, des opérations sur variables, des fonctions…

Structure et execution d’un script

Toutes les instructions et commandes sont regroupées au sein d’un script. Lors de son exécution, chaque ligne sera lue une à une et exécutée. Une ligne peut se composer de commandes internes ou externes, de commentaires ou être vide. Plusieurs instructions par lignes sont possibles, séparées par le « ; » ou liées conditionnellement par « && » ou « || ». Le « ; » est l’équivalent d’un saut de ligne.

Par convention les shell scripts se terminent généralement (pas obligatoirement) par « .sh » pour le Bourne Shell et le Bourne Again Shell, par « .ksh » pour le Korn Shell et par « .csh » pour le C Shell.
Pour rendre un script exécutable directement :
$ chmod u+x monscript
Pour l’exécuter :
$ ./monscript
Pour éviter le ./ :
$ PATH=$PATH:.
$ monscript

Quand un script est lancé, un nouveau shell « fils » est créé qui va exécuter chacune des commandes. Si c’est une commande interne, elle est directement exécutée par le nouveau shell. Si c’est une commande externe, dans le cas d’un binaire un nouveau fils sera créé pour l’exécuter, dans le cas d’un shell script un nouveau shell fils est lancé pour lire ce nouveau shell ligne à ligne.

Une ligne de commentaire commence toujours par le caractère « # ». Un commentaire peut être placé en fin d’une ligne comportant déjà des commandes.
# La ligne suivante effectue un ls
ls # La ligne en question
La première ligne a une importance particulière car elle permet de préciser quel shell va exécuter le script #!/bin/sh
#!/bin/ksh

Dans le premier cas c’est un script Bourne, dans l’autre un script Korn.

Les variables

On en distingue trois types : utilisateur, système et spéciales. Le principe est de pouvoir affecter un contenu à un nom de variable, généralement un chaîne de caractère, ou des valeurs numériques.

Nomenclature

Un nom de variable obéit à certaines règles :
1. Il peut être composé de lettres minuscules, majuscules, de chiffres, de caractères de soulignement
2. Le premier caractère ne peut pas être un chiffre
3. Le taille d’un nom est en principe illimité (il ne faut pas abuser non plus)
4. Les conventions veulent que les variables utilisateur soient en minuscules pour les différencier des variables système. Au choix de l’utilisateur.

Declaration et affectation

Une variable est déclarée dès qu’une valeur lui est affectée. L’affectation est effectuée avec le signe « = », sans espace avant ou après le signe. var=Bonjour

On peut aussi créer des variables vides. Celle-ci existera mais sans contenu. var=

Acces et affichage

On accède au contenu d’une variable en plaçant le signe « $ » devant le nom de la variable. Quand le shell rencontre le « $ », il tente d’interpréter le mot suivant comme étant une variable. Si elle existe, alors le $nom_variable est remplacé par son contenu, ou par un texte vide dans le cas contraire.

On parle aussi de référencement de variable.
$ chemin=/tmp/seb
$ pwd
/home/toto
$ ls $chemin
dump.log fic4 lien_fic1 liste_ls rep1 seb2
fic1 hardlink2_fic2 lien_fic2 ls.txt rep2 toto.tar.gz
fic2 hardlink3_fic2 liste mypass resultat.txt users
fic3 hardlink_fic2 liste2 nohup.out seb1
$ cd $chemin
$ pwd
/tmp/seb
$ cd $chemin/rep1
$ pwd
/tmp/seb/rep1

Pour afficher la liste des variables on utilise la commande set. Elle affiche les variables utilisateur et les variables système, nom et contenu. La commande echo permet d’afficher le contenu de variables spécifiques.

$ a=Jules
$ b=Cesar
$ set
EDITMODE=emacs
HOME=/home/seb
LD_LIBRARY_PATH=/mor/app/oracle/product/8.1.7/lib
LOGNAME=seb
MAIL=/usr/spool/mail/seb
MAILCHECK=600
MANPATH=/usr/man:/sqlbt/datatools/obacktrack/man
PATH=/home/oracle/bin:/usr/bin:.:/mor/app/oracle/product/8.1.7/bin:/sqlbt/datatools/obacktrack/bin:
PS1=$
PS2=>
SHELL=/bin/csh
SHLVL=1
TERM=xterm
USER=seb
a=Jules
b=Cesar
$ echo $a $b a conquis la Gaule
Jules Cesar a conquis la Gaule

Une variable peut contenir des caractères spéciaux, le principal étant l’espace. Mais $ c=Salut les copains
les: not found
$ echo $c
Ne marche pas.
Pou r cela il faut soit verrouiller les caractères spéciaux un par un, soit de les mettre entre guillemets ou apostrophes.
c=Salut\ les\ Copains # Solution lourde
c=”Salut les copains” # Solution correcte
c=’Salut les copains’ # Solution correcte

La principale différence entre les guillemets et les apostrophes est l’interprétation des variables et des substitutions. ” et ‘ se vérouillent mutuellement.
$ a=Jules
$ b=Cesar
$ c=”$a $b a conquis la Gaule”
$ d=’$a $b a conquis la Gaule’
$ echo $c
Jules Cesar a conquis la Gaule
$ echo $d
$a $b a conquis la Gaule
$ echo “Unix c’est top”
Unix c’est top
$ echo ‘Unix “trop bien”‘
Unix “trop bien”

Supression et protection

On supprime une variable avec la commande unset. On peut protéger une variable en écriture et contre sa suppression avec la commande readonly. Une variable en lecture seule même vide est figée. Il n’existe aucun moyen de la replacer en écriture et de la supprimer, sauf à quitter le shell.

$ a=Jules
$ b=Cesar
$ echo $a $b
Jules Cesar
$ unset b
$ echo $a $b
Jules
$ readonly a
$ a=Neron
a: is read only
$ unset a
a: is read only

Exportation

Par défaut une variable n’est accessible que depuis le shell où elle a été définie. $ a=Jules
$ echo ‘echo “a=$a”‘ > voir_a.sh
$ chmod u+x voir_a.sh
$ ./voir_a.sh
a=
La commande export permet d’exporter une variable de manière à ce que son contenu soit visible par les scripts et autres sous-shells. Les variables exportées peuvent être modifiées dans le script, mais ces modifications ne s’appliquent qu’au script ou au sous-shell. $ export a ./voir_a.sh a=Jules $ echo ‘a=Neron ; echo “a=$a”‘ >> voir_a.sh $ ./voir_a.sh a=Jules a=Neron $ echo $a Jules

Accolades

Les accolades de base « {} » permettent d’identifier le nom d’une variable. Imaginons la variable fichier contenant le nom de fichier ‘liste’. On veut copier liste1 en liste2.

$ fichier=liste
$ cp $fichier2 $fichier1
usage: cp [-fhip] [–] source_file destination_file
or: cp [-fhip] [–] source_file … destination_directory
or: cp [-fhip] [-R | -r] [–]
[source_file | source_directory] … destination_directory

Ça ne fonctionne pas car ce n’est pas $fichier qui est interprété mais $fichier1 et $fichier2 qui n’existent pas.
$ cp ${fichier}2 ${fichier}1
Dans ce cas, cette ligne équivaut à
$ cp liste2 liste1
Les accolades indiquent que fichier est un nom de variable.

Accolades et remplacement conditionnel

Les accolades disposent d’une syntaxe particulière. {variable:Remplacement}

Selon la valeur ou la présence de la variable, il est possible de remplacer sa valeur par une autre.

Remplacement Signification
{x:-texte} si la variable x est vide ou inexistante, le texte prendra sa place. Sinon c’est le contenu de la variable qui prévaudra.
{x:=texte} si la variable x est vide ou inexistante, le texte prendra sa place et deviendra la valeur de la variable.
{x:+texte} si la variable x est définie et non vide, le texte prendra sa place. Dans le cas contraire une chaîne vide prend sa place.
{x:?texte} si la variable x est vide ou inexistante, le script est interrompu et le message texte s’affiche. Si texte est absent un message d’erreur standard est affiché.

 

$ echo $nom
$ echo ${nom:-Jean}
$ echo $nom
$ echo ${nom:=Jean}
Jean
$ echo $nom
Jean
$ echo ${nom:+”Valeur définie”}
Valeur définie
$ unset nom
$ echo ${nom:?Variable absente ou non définie}
nom: Variable absente ou non définie
$ nom=Jean
$ echo ${nom:?Variable absente ou non définie}
Jean

Variables système

En plus des variables que l’utilisateur peux définir lui-même, le shell est lancé avec un certain nombre de variables prédéfinies utiles pour un certain nombre de commandes et accessibles par l’utilisateur.
Le contenu de ces variables système peut être modifié mais il faut alors faire attention car certaines ont une incidence directe sur le comportement du système.

Variable Contenu
HOME Chemin d’accès du répertoire utilisateur. Répertoire par défaut en cas de cd.
PATH Liste de répertoires, séparés par des « : » où le shell va rechercher les commandes externes et autres scripts et binaires. La recherche se fait dans l’ordre des répertoires saisis.
PS1 Prompt String 1, chaîne représentant le prompt standard affiché à l’écran par le shell en attente de saisie de commande.
PS2 Prompt String 2, chaîne représentant un prompt secondaire au cas où la saisie doit être complétée.
IFS Internal Field Separator, liste des caractères séparant les mots dans une ligne de commande. Par défaut il s’agit de l’espace de la tabulation et du saut de ligne.
MAIL chemin et fichier contenant les messages de l’utilisateur
MAILCHECK intervalle en secondes pour la vérification de présence d’un nouveau courrier. Si 0 alors la vérification est effectuée après chaque commande.
SHELL Chemin complet du shell en cours d’exécution
LANG Définition de la langue à utiliser ainsi que du jeu de caractères
LC_COLLATE Permet de définir l’ordre du tri à utiliser (si LANG est absent)
LC_NUMERIC Format numérique à utiliser
LC_TIME Format de date et d’heure à utiliser
LC_CTYPE Détermination des caractères et signes devant ou ne devant pas être pris en compte dans un tri.
USER Nom de l’utilisateur en cours.
LD_LIBRARY_PATH Chemin d’accès aux bibliothèques statiques ou partagées du système.
MANPATH Chemin d’accès aux pages du manuel.
LOGNAME Nom du login utilisé lors de la connexion.

Variables speciales

Il s’agit de variables accessibles uniquement en lecture et dont le contenu est généralement contextuel.

Variable Contenu
$? Code retour de la dernière commande exécutée
$$ PID du shell actif
$! PID du dernier processus lancé en arrière-plan
$- Les options du shell

$ cat param.sh
#!/usr/bin/sh
echo “Nom : $0”
echo “Nombre de parametres : $#”
echo “Parametres : 1=$1 2=$2 3=$3”
echo “Liste : $*”
echo “Elements : $@”
$ param.sh riri fifi loulou
Nom : ./param.sh
Nombre de parametres : 3
Parametres : 1=riri 2=fifi 3=loulou
Liste : riri fifi loulou
Elements : riri fifi loulou

La différence entre $@ et $* ne saute pas aux yeux. Reprenons l’exemple précédent avec une petite modification :
$ param.sh riri “fifi loulou”
Nom : ./param.sh
Nombre de parametres : 2
Parametres : 1=riri 2=fifi loulou 3=
Liste : riri fifi loulou
Elements : riri fifi loulou
Cette fois-ci il n’y a que deux paramètres de passés. Pourtant les listes semblent visuellement identiques. En fait si la première contient bien “riri fifi loulou”
La deuxième contient
“riri” “fifi loulou”
Soit bien deux éléments. Dans les premier exemple nous avions “riri” “fifi” “loulou”

Parametres de position

Les paramètres de position sont aussi des variables spéciales utilisées lors d’un passage de paramètres à un script.

Description

Variable Contenu
$0 Nom de la commande (du script)
$1-9 $1,$2,$3… Les neuf premiers paramètres passés au script
$# Nombre total de paramètres passés au script
$* Liste de tous les paramètres au format “$1 $2 $3 …”
$@ Liste des paramètres sous forme d’éléments distincts “$1” “$2” “$3” …

Redéfinition des paramètres

Outre le fait de lister les variables, la commande set permet de redéfinir le contenu des variables de position. Avec set valeur1 valeur2 valeur3 …

$1 prendra comme contenu valeur1, $2 valeur2 et ainsi de suite.
$ cat param2.sh
#!/usr/bin/sh
echo “Avant :”
echo “Nombre de parametres : $#”
echo “Parametres : 1=$1 2=$2 3=$3 4=$4”
echo “Liste : $*”
set alfred oscar romeo zoulou
echo “apres set alfred oscar romeo zoulou”
echo “Nombre de parametres : $#”
echo “Parametres : 1=$1 2=$2 3=$3 4=$4”
echo “Liste : $*”
./param2.sh riri fifi loulou donald picsou
Avant :
Nombre de parametres : 5
Parametres : 1=riri 2=fifi 3=loulou 4=donald
Liste : riri fifi loulou donald picsou
apres set alfred oscar romeo zoulou
Nombre de parametres : 4
Parametres : 1=alfred 2=oscar 3=romeo 4=zoulou
Liste : alfred oscar romeo zoulou

Réorganisation des paramètres

La commande shift est la dernière commande permettant de modifier la structure des paramètres de position. Un appel simple décale tous les paramètres d’une position en supprimant le premier : $2 devient $1, $3 devient $2 et ainsi de suite. Le $1 originel disparaît. $#, $* et $@ sont redéfinis en conséquence.

La commande shift suivie d’une valeur n effectue un décalage de n éléments. Ainsi avec
shift 4
$5 devient $1, $6 devient $2, …
$ cat param3.sh
#!/usr/bin/sh
set alfred oscar romeo zoulou
echo “set alfred oscar romeo zoulou”
echo “Nombre de parametres : $#”
echo “Parametres : 1=$1 2=$2 3=$3 4=$4”
echo “Liste : $*”
shift
echo “Après un shift”
echo “Nombre de parametres : $#”
echo “Parametres : 1=$1 2=$2 3=$3 4=$4”
echo “Liste : $*”

$ ./param3.sh
set alfred oscar romeo zoulou
Nombre de parametres : 4
Parametres : 1=alfred 2=oscar 3=romeo 4=zoulou
Liste : alfred oscar romeo zoulou
Après un shift
Nombre de parametres : 3
Parametres : 1=oscar 2=romeo 3=zoulou 4=
Liste : oscar romeo zoulou

Sortie de script

L a commande exit permet de mettre fin à un script. Par défaut la valeur retournée est 0 (pas d’erreur) mais n’importe quelle autre valeur de 0 à 255 peut être précisée. On récupère la valeur de sortie par la variable $?. $ exit 1

Environnement du processus

En principe seules les variables exportées sont accessibles par un processus fils. Si on souhaite visualiser l’environnement lié à un fils (dans un script par exemple) on utilise la commande env.

$ env
PATH=/home/oracle/bin:/usr/bin:.:/mor/app/oracle/product/8.1.7/bin
TERM=xterm
LOGNAME=oracle
USER=oracle
SHELL=/bin/csh
HOME=/home/oracle
SHLVL=1
MAIL=/usr/spool/mail/oracle
ORACLE_SID=ORAP
EPC_DISABLED=TRUE
ORACLE_BASE=/mor/app/oracle
ORACLE_HOME=/mor/app/oracle/product/8.1.7
EDITMODE=emacs
ORATAB=/etc/oratab
La commande env permet de redéfinir aussi l’environnement du processus à lancer. Cela peut être utile lorsque le script doit accéder à une variable qui n’est pas présente dans l’environnement du père, ou qu’on ne souhaite pas exporter. La syntaxe est
env var1=valeur var2=valeur … commande
Si la première option est le signe « – » alors c’est tout l’environnement existant qui est supprimé pour être remplacé par les nouvelles variables et valeurs.
$ unset a
$ ./voir_a.sh
a=
$ env a=jojo ./voir_a.sh
a=jojo
$ echo a=$a
a=

Substitution de commande

Le mécanisme de substitution permet de placer le résultat de commandes simples ou complexes dans une variable. On place les commandes à exécuter entre des accents graves « ` ». (Alt Gr + 7).

$ mon_unix=`uname`
$ echo ${mon_unix}
OSF1
$ machine=`uname -a | cut -d” ” -f5`
$ echo $machine
alpha
Attention, seul le canal de sortie standard est affecté à la variable. Le canal d’erreur standard sort toujours vers l’écran.

Tests de conditions

La commande test permet d’effectuer des tests de conditions. Le résultat est récupérable par la variable $? (code retour). Si ce résultat est 0 alors la condition est réalisée.

Tests sur chaîne

* test -z “variable” : zero, retour OK si la variable est vide (ex test -z “$a”)
* test -n “variable” : non zero, retour OK si la variable n’est pas vide (texte quelconque)
* test “variable” = chaîne : OK si les deux chaînes sont identiques
* test “variable” != chaîne : OK si les deux chaînes sont différentes

$ a=
$ test -z “$a” ; echo $?
0
$ test -n “$a” ; echo $?
1
$ a=Jules
$ test “$a” = Jules ; echo $?
0

Tests sur valeurs numériques

Les chaînes à comparer sont converties en valeurs numériques. La syntaxe est
test valeur1 option valeur2
et les options sont les suivantes :

Option Rôle
-eq Equal : Egal
-ne Not Equal : Différent
-lt Less than : inférieur
-gt Greater than : supérieur
-le Less ou equal : inférieur ou égal
-ge Greater or equal : supérieur ou égal

$ a=10
$ b=20
$ test “$a” -ne “$b” ; echo $?
0
$ test “$a” -ge “$b” ; echo $?
1
$ test “$a” -lt “$b” && echo “$a est inferieur a $b”
10 est inferieur a 20

Tests fichiers

La syntaxe est test option nom_fichier et les options sont les suivantes :

Option Rôle
-f Fichier normal
-d Un répertoire
-c Fichier en mode caractère
-b Fichier en mode bloc
-p Tube nommé (named pipe)
-r Autorisation en lecture
-w Autorisation en écriture
-x Autorisation en exécution
-s Fichier non vide (au moins un caractère)
-e Le fichier existe
-L Le fichier est un lien symbolique
-u Le fichier existe, SUID-Bit positionné
-g Le fichier existe SGID-Bit positionné

$ ls -l
-rw-r–r– 1 oracle system 1392 Aug 14 15:55 dump.log
lrwxrwxrwx 1 oracle system 4 Aug 14 15:21 lien_fic1 -> fic1
lrwxrwxrwx 1 oracle system 4 Aug 14 15:21 lien_fic2 -> fic2
-rw-r–r– 1 oracle system 234 Aug 16 12:20 liste1
-rw-r–r– 1 oracle system 234 Aug 13 10:06 liste2
-rwxr–r– 1 oracle system 288 Aug 19 09:05 param.sh
-rwxr–r– 1 oracle system 430 Aug 19 09:09 param2.sh
-rwxr–r– 1 oracle system 292 Aug 19 10:57 param3.sh
drwxr-xr-x 2 oracle system 8192 Aug 19 12:09 rep1
-rw-r–r– 1 oracle system 1496 Aug 14 16:12 resultat.txt
-rw-r–r– 1 oracle system 1715 Aug 16 14:55 toto.txt
-rwxr–r– 1 oracle system 12 Aug 16 12:07 voir_a.sh

$ test -f lien_fic1 ; echo $?
1
$ test -x dump.log ; echo $?
1
$ test -d rep1 ; echo $?
0

Tests combinés par critères ET OU NON

On peut effectuer plusieurs tests avec une seule instruction. Les options de combinaisons sont les mêmes que pour la commande find.

Critère Action
-a AND, ET logique
-o OR, OU logique
! NOT, NON logique
(…) groupement des combinaisons. Les parenthèses doivent être vérouillées \(…\).

$ test -d “rep1” -a -w “rep1” && exho “rep1: repertoire, droit en ecriture” rep1: repertoire, droit en ecriture

Syntaxe allégée

L e mot test peut être remplacé par les crochets ouverts et fermés « […] ». Il faut respecter un espace après et avant les crochets.
$ [ “$a” -lt “$b” ] && echo “$a est inferieur a $b”
10 est inferieur a 20

If … then … else

La structure if then else fi ‘est une structure de contrôle conditionnelle.
if
then

else

fi
On peut aussi préciser le elif, en fait un else if. Si la dernière condition n’est pas réalisée on en teste une nouvelle.

Exemple : test de la présence de paramètres
$ cat param4.sh
#!/usr/bin/sh
if [ $# -ne 0 ]
then
echo “$# parametres en ligne de commande”
else
echo “Aucun parametre; set alfred oscar romeo zoulou”
set alfred oscar romeo zoulou
fi
echo “Nombre de parametres : $#”
echo “Parametres : 1=$1 2=$2 3=$3 4=$4”
echo “Liste : $*”

$ ./param4.sh titi toto
2 parametres en ligne de commande
Nombre de parametres : 2
Parametres : 1=toto 2=titi 3= 4=
Liste : toto titi

$ ./param4.sh
Aucun parametre; set alfred oscar romeo zoulou
Nombre de parametres : 4
Parametres : 1=alfred 2=oscar 3=romeo 4=zoulou
Liste : alfred oscar romeo zoulou

Choix multiples case

La commande case esac permet de vérifier le contenu d’une variable ou d’un résultat de manière multiple.
case Valeur in
Modele1) Commandes ;;
Modele2) Commandes ;;
*) action_defaut ;;
esac

Le modèle est soit un simple texte, soit composé de caractères spéciaux. Chaque bloc de commandes lié au modèle doit se terminer par deux points-virgules.
Dès que le modèle est vérifié, le bloc de commandes correspondant est exécuté. L’étoile en dernière position (chaîne variable) est l’action par défaut si aucun critère n’est vérifié.

Caractère Rôle
* Chaîne variable (même vide)
? Un seul caractère
[…] Une plage de caractères
[!…] Négation de la plage de caractères
| OU logique

 

$ cat case1.sh
#!/usr/bin/sh
if [ $# -ne 0 ]
then
echo “$# parametres en ligne de commande”
else
echo “Aucun parametre; set alfred oscar romeo zoulou”
exit 1
fi
case $1 in
a*)
echo “Commence par a”
;;
b*)
echo “Commence par b”
;;
fic[123])
echo “fic1 fic2 ou fic3”
;;
*)
echo “Commence par n’importe”
;;
esac
exit 0

$ ./case1.sh “au revoir”
Commence par a
$ ./case1.sh bonjour
Commence par b
$ ./case1.sh fic2
fic1 ou fic2 ou fic3
$ ./case1.sh erreur
Commence par n’importe

Saisie de l’utilisateur

La commande read permet à l’utilisateur de saisir une chaîne et de la placer dans une ou plusieurs variable. La saisie est validée par entrée. read var1 [var2 …]

Si plusieurs variables sont précisées, le premier mot ira dans var1, le second dans var2, et ainsi de suite. S’il y a moins de variables que de mots, tous les derniers mots vont dans la dernière variable.
$ cat read.sh
#!/usr/bin/sh
echo “Continuer (O/N) ? \c”
read reponse
echo “reponse=$reponse”
case $reponse in
O)
echo “Oui, on continue”
;;
N)
echo “Non, on s’arrête”
exit 0
;;
*)
echo “Erreur de saisie (O/N)”
exit 1
;;
esac
echo “Vous avez continue. Tapez deux mots ou plus :\c”
read mot1 mot2
echo “mot1=$mot1\nmot2=$mot2”
exit 0

$ ./read.sh
Continuer (O/N) ? O
reponse=O
Oui, on continue
Vous avez continue. Tapez deux mots ou plus :salut les amis
mot1=salut
mot2=les amis

Les boucles

Elles permettent la répétition d’un bloc de commandes soit un nombre limité de fois, soit conditionnellement. Toutes les commandes à exécuter dans une boucle se placent entre les commandes do et done.

Boucle for

La boucle for ne se base pas sur une quelconque incrémentation de valeur mais sur une liste de valeurs, de fichiers …
for var in liste
do
commandes à exécuter
done
La liste représente un certain nombre d’éléments qui seront successivement attribuées à var.

Avec une variable

$ cat for1.sh
#!/usr/bin/sh
for params in $@
do
echo “$params”
done

$ ./for1.sh test1 test2 test3
test1
test2
test3

Liste implicite

Si on ne précise aucune liste à for, alors c’est la liste des paramètres qui est implicite. Ainsi le script précédent aurait pu ressembler à :
for params
do
echo “$params”
done

Avec une liste d’éléments explicite

$ cat for2.sh
#!/usr/bin/sh
for params in liste liste2
do
ls -l $params
done

$ ./for2.sh
-rw-r–r– 1 oracle system 234 Aug 19 14:09 liste
-rw-r–r– 1 oracle system 234 Aug 13 10:06 liste2

Avec des critères de recherche sur nom de fichiers :

$ cat for3.sh
#!/usr/bin/sh
for params in *
do
echo “$params \c”
type_fic=`ls -ld $params | cut -c1`
case $type_fic in
-) echo “Fichier normal” ;;
d) echo “Repertoire” ;;
b) echo “mode bloc” ;;
l) echo “lien symbolique” ;;
c) echo “mode caractere” ;;
*) echo “autre” ;;
esac
done

$ ./for3.sh
case1.sh Fichier normal
dump.log Fichier normal
for1.sh Fichier normal
for2.sh Fichier normal
for3.sh Fichier normal
lien_fic1 lien symbolique
lien_fic2 lien symbolique
liste Fichier normal
liste1 Fichier normal
liste2 Fichier normal
param.sh Fichier normal
param2.sh Fichier normal
param3.sh Fichier normal
param4.sh Fichier normal
read.sh Fichier normal
rep1 Repertoire
resultat.txt Fichier normal
toto.txt Fichier normal
voir_a.sh Fichier normal

Avec une substitution de commande

$ cat for4.sh
#!/usr/bin/sh
echo “Liste des utilisateurs dans /etc/passwd”
for params in `cat /etc/passwd | cut -d: -f1`
do
echo “$params ”
done

$ ./for4.sh
Liste des utilisateurs dans /etc/passwd
root
nobody
nobodyV
daemon
bin
uucp
uucpa
auth
cron
lp
tcb
adm
ris
carthic
ftp
stu

Boucle while

La commande while permet une boucle conditionnelle « tant que ». Tant que la condition est réalisée, le bloc de commande est exécuté. On sort si la condition n’est plus valable.
while condition
do
commandes
done

ou
while
bloc d’instructions formant la condition
do
commandes
done

Par exemple :

$ cat while1.sh
#!/usr/bin/sh
while
echo “Chaine ? \c”
read nom
[ -z “$nom” ]
do
echo “ERREUR : pas de saisie”
done
echo “Vous avez saisi : $nom”

Par exemple une lecture d’un fichier ligne à ligne :
#!/usr/bin/sh
cat toto.txt | while read line
do
echo “$line”
done

ou

#!/usr/bin/sh
while read line
do
echo “$line”
done < toto.txt

Boucle until

La commande until permet une boucle conditionnelle « jusqu’à ». Dès que la condition est réalisée, on sort de la boucle.

until condition
do
commandes
done

ou
until
bloc d’instructions formant la condition
do
commandes
done

Seq

La commande seq permet de sortir une séquence de nombres, avec un intervalle éventuel.

seq [debut] [increment] fin
ex :
$ seq 5
1
2
3
4
5

$ seq -2 3
-2
-1
0
1
2
3

$ seq 0 2 10
0
2
4
6
8
10

True et false

La commande true ne fait rien d’autre que de renvoyer 0. La commande false renvoie toujours 1. De cette manière il est possible de faire des boucles sans fin. La seule manière de sortir de ces boucles est un exit ou un break.
while true
do
commandes
exit / break
done

Break et continue

La commande break permet d’interrompre une boucle. Dans ce cas le script continue après la commande done. Elle peut prendre un argument numérique indiquant le nombre de boucles à sauter, dans le cadre de boucles imbriquées (rapidement illisible).

while true
do
echo “Chaine ? \c”
read a
if [ -z “$a” ]
then
break
fi
done

La commande continue permet de relancer une boucle et d’effectuer un nouveau passage. Elle peut prendre un argument numérique indiquant le nombre de boucles à relancer (on remonte de n boucles). Le script redémarre à la commande do.

Les fonctions

Les fonctions sont des bouts de scripts nommés, directement appelés par leur nom, pouvant accepter des paramètres et retourner des valeurs. Les noms de fonctions suivent les mêmes règles que les variables sauf qu’elles ne peuvent pas être exportées.

nom_fonction ()
{
commandes
return
}

Les fonctions peuvent être soit tapées dans votre script courant, soit dans un autre fichier pouvant être inclus dans l’environnement. Pour cela :
. nomfic
Le point suivi d’un nom de fichier charge son contenu (fonctions et variables dans l’environnement courant.
La commande return permet d’affecter une valeur de retour à une fonction. Il ne faut surtout par utiliser la commande exit pour sortir d’une fonction, sinon on quitte le script.
$ cat fonction
ll ()
{
ls -l $@
}
li ()
{
ls -i $@
}
$ . fonction
$ li
252 case1.sh 326 for4.sh 187 param.sh 897 resultat.txt
568 dump.log 409 lien_fic1 272 param2.sh 991 toto.txt
286 fonction 634 lien_fic2 260 param3.sh 716 voir_a.sh
235 for1.sh 1020 liste 42 param4.sh 1008 while1.sh
909 for2.sh 667 liste1 304 read.sh
789 for3.sh 1006 liste2 481 rep1

Expr

La commande expr permet d’effectuer des calculs sur des valeurs numériques, des comparaisons, et de la recherche dans des chaînes de texte.

Opérateur Rôle
+ Addition
Soustraction
* Multiplication
/ Division
% Modulo
!= Différent. Affiche 1 si différent, 0 sinon.
= Egal. Affiche 1 si égal, 0 sinon.
< inférieur. Affiche 1 si inférieur, 0 sinon.
> supérieur. Affiche 1 si supérieur, 0 sinon.
<= inférieur ou égal. Affiche 1 si inférieur ou égal, 0 sinon.
>= supérieur ou égal. Affiche 1 si supérieur ou égal, 0 sinon.
: Recherche dans une chaîne. Ex expr Jules : J* retourne 1 car Jules commence par J. Syntaxe particulière : expr “Jules” : “.*” retourne la longueur de la chaîne.

$ expr 7 + 3
10
$ expr 7 \* 3
21
$ a=`expr 13 ? 10`
$ echo $a
3
$ cat expr1.sh
#!/usr/bin/sh
cumul=0
compteur=0
nb_boucles=10
while [ “$compteur” -le “$nb_boucles” ]
do
cumul=`expr $cumul + $compteur`
echo “cumul=$cumul, boucle=$compteur”
compteur=`expr $compteur + 1`
done
$ ./expr1.sh
cumul=0, boucle=0
cumul=1, boucle=1
cumul=3, boucle=2
cumul=6, boucle=3
cumul=10, boucle=4
cumul=15, boucle=5
cumul=21, boucle=6
cumul=28, boucle=7
cumul=36, boucle=8
cumul=45, boucle=9
cumul=55, boucle=10
$ expr “Jules Cesar” : “.*”
11

Une variable dans une autre variable

Voici un exemple :
$ a=Jules
$ b=a
$ echo $b
a

Comment afficher le contenu de a et pas simplement a ? En utilisant la commande eval. Cette commande située en début de ligne essaie d’interpréter, si possible, la valeur d’une variable précédée par deux « $ », comme étant une autre variable.
$ eval echo \$$b Jules

Traitement des signaux

L a commande trap permet de modifier le comportement du script à la réception d’un signal.

commande Réaction
trap ” signaux Ignore les signaux. trap ” 2 3 ignore les signaux 2 et 3
trap ‘commandes’ signaux Pour chaque signal reçu exécution des commandes indiquées
trap signaux Restaure les actions par défaut pour ces signaux

 

Commande « : »

La commande « : » est généralement totalement inconnue des utilisateurs unix. Elle retourne toujours la valeur 0 (réussite). Elle peut donc être utilisée pour remplacer la commande true dans une boucle par exemple :
while :
do

done

Cette commande placée en début de ligne, suivie d’une autre commande, traite la commande et ses arguments mais ne fait rien, et retourne toujours 0. Elle peut être utile pour tester les variables.
$ : ls
: ${X:?”Erreur”}
X : Erreur

Délai d’attente

La commande sleep permet d’attendre le nombre de secondes indiqués. Le script est interrompu durant ce temps. Le nombre de secondes et un entier compris entre 0 et 4 milliards (136 ans). $ sleep 10

Sources de l’article

 

Auditer la sécurité de son réseau avec Nessus

Auditer la sécurité de son réseau avec Nessus
  • Introduction
  • Fonctionnement
  • Installation
  • Fonctionnement
  • PLugins
  • Usage

Introduction

Nessus est un scanner qui permet de vérifier si votre machine ou votre réseau présente des failles IL dispose de plus de 13000 plugins constamment mis à jour par une communauté de développeurs actifs Il signale un tas de vulnérabilités, telles que des faiblesses pouvant conduire à des attaques externes, des fautes de configuration, des patchs non appliqués, des absences de mots de passe sur des comptes système et des services jugés faibles ainsi que des dénis de service.

Fonctionnement:

Nessus ce présente en deux parties, un démon nessusd qui exécute les requêtes et nessus qui permet d’afficher les résultats via une interface graphique.Les tests sont joués par des plugins.

Installation:

Nessus s’installe sous Mandriva via le gestionnaire urpmi par un :

urpmi nessus en console et en root Ne pas oublier aussi d’installer le client avec un urpmi nessus-client À la fin on dispose des paquetages suivants, une fois installées les dépendances

nessus-plugins-2.2.10-4mdv2009.0
lib64nessus2-2.2.10-3mdv2009.0
nessus-2.2.10-2mdv2008.1
nessus-client-2.2.10-2mdv2008.1

Vous pouvez aussi opter pour la version 3, qui est la dernière version du programme à présent propriétaire, ceci en vous rendant à l’adresse du site

Fonctionnement:

Une fois Nessus installé, il vous faut créer un utilisateur nessus, avec la commande nessus-adduser qu’on lance en console et en root Entrez le nom de l’utilisateur, à l’invite authentification, appuyez simplement sur Entrée, saisissez ensuite le password, une deuxième fois, et laissez user rules vide en appuyant sur CTRL+D Voici la procédure :

nessus-adduser
Using /var/tmp as a temporary file holder
Add a new nessusd user
———————-
Login : toto
Authentication (pass/cert) [pass] :
Login password :
Login password (again) :
User rules
———-
nessusd has a rules system which allows you to restrict the hosts
that john has the right to test. For instance, you may want
him to be able to scan his own host only.
Please see the nessus-adduser(8) man page for the rules syntax
Enter the rules for this user, and hit ctrl-D once you are done :
(the user can have an empty rules set)
Login : toto
Password : ***********
DN :
Rules :
Is that ok ? (y/n) [y] y
user added.

Plugins

Lorsque vous vous enregistrez sur le site de Nessus, on vous envoie via l’adresse email que vous avez saisie, une clé d’enregistrement destinée à mettre à jour vos plugins Pour mettre à jour vos plugins, afin de disposer de la dernière base mise au point par les développeurs, faites nessus-fetch –register suivi de la clé d’activation qui vous a été envoyée par email Pour garder votre base de données à jour, il vous suffira d’employer régulièrement la commande
nessus-update-plugins, pourquoi pas à l’aide d’une tâche cron

Usage

À présent, il est temps de lancer le démon nessus, à l’aide de la commande nessusd -D ou bien tout simplement service nessusd start Il vous faut prévoir un certain temps d’attente, le temps de lancer les 25019 plugins disponibles, excusez du peu Ensuite, je me trouve confronté à ce message d’erreur:

All plugins loaded
**** /var/nessus/nessus-services could not be found. Install it and try again
[ÉCHEC ]

Ce fichier nessus-services se trouve dans /var/lib/nessus/nessus-services Or, si je crée un répertoire nessus dans /var et que je copie nessus-services dans /var/nessus, tout rentre dans l’ordre, le service se lance Pour scanner votre ordinateur, il faudra lancer le client avec la commande nessus Vous obtiendrez alors ce genre de fenêtre

Où il vous faudra saisir le login et le mot de passe du compte que vous avez créé avec nessus-adduser Ensuite il vous faut choisir le serveur sur lequel vous vous connectez, chez moi nessus tourne sur la même machine, donc localhost suffira Une fois authentifié, il vous faudra choisir la machine-cible à scanner, votre serveur, une machine de votre réseau Vous pouvez laisser les options par défaut dans un premier temps.

* L’onglet Plugin vous permet de choisir quels test effectuer.
* L’onglet Credentials vous permet de fournir éventuellement des logins/passwords pour accéder aux machines à tester.
* Scan options vous permet de choisir quels ports tester et la manière de détecter un port ouvert.
* Target permet de choisir quoi tester: Vous pouvez entrer l’adresse IP ou le nom de la machine à tester.

Nessus va effectuer des attaques sur votre réseau pour en découvrir les vulnérabilités Il faut savoir que ce type de programme laisse beaucoup de traces, notamment dans les logs, où il sera simple de remonter jusqu’à l’adresse de l’assaillant En revanche, les pirates où vous-même pourront disposer d’informations précises sur les failles présentes sur votre système, sous la forme d’un rapport expliquant les risques encourus.
N’hésitez pas à lancer nessus régulièrement

Sources de l’article

Installation de Snort Inline

Installation de Snort Inline
  • Introduction
  • Installation de snort
  • Installation des règles SNORT
  • Lancement de SNORT

Introduction

Snort est utile pour recueillir des informations en cas d’intrusion de réseau, scan de ports etc…….Snort_inline est un systeme concu pour bloquer des attaques en temps_réel. Nous allons voir comment installer et tester snort_inline.

Installation

Vous aurez besoin pour un système tel que RedHat ou mandrake du code source du noyau de votre distribution. Il vous faudra en outre faire tourner un serveur web. Vous aurez aussi besoin d’iptables disponibles en rpm (deja installé sur les dernieres distros mandriva), de la librairie libipq qui permet a snort_inline de communiquer avec iptables, de libnet et de pcre, la bibliothèque d’expressions régulières compatible avec Perl. Tous ces paquetages sont disponibles en rpm sous mandriva ,se renseigner pour les autres distributions.
Vous devez obtenir maintenant le dernier paquetage de snort_inline. À titre d’information, j’ai employé snort_inline-2.3.0-RC1.tar.gz dans cet article. À présent, exécutez les commandes décrites ci-dessous.
mv /home/snort/snort_inline-2.3.0-RC1.tar.gz /usr/local/
cd /usr/local
tar xzvf snort_inline-2.3.0-RC1.tar.gz
cd snort_inline-2.3.0-RC1
./configure
make

Configuration

Nous allons maintenant modifier quelques parametres dans le fichier de configuration snort_inline, avant qu’il soit prêt à être lancé. Tout d’abord, il faut modifier le fichier de configuration de snort_inline, en le faisant pointer sur le chemin correct pour pouvoir obtenir ses règles.
cp /usr/local/snort_inline-2.3.0-RC1/etc/classification.config /usr/local/snort_inline-2.3.0-RC1/rules/
cp /usr/local/snort_inline-2.3.0-RC1/etc/reference.config /usr/local/snort_inline-2.3.0-RC1/rules/

Déplaçons les fichiers de configuration et de définition de règles dans le répertoire /etc, où résident habituellement les fichiers de ce type:
mkdir /etc/snort
cp /usr/local/snort_inline-2.3.0-RC1/etc/* /etc/snort/
cp /usr/local/snort_inline-2.3.0-RC1/rules /etc/snort/ -R
Modifiez maintenant le fichier de conf snort_inline dans votre éditeur de texte favori :
var RULE_PATH /etc/snort_inline/drop_rules deviendra: var RULE_PATH /etc/snort/rules
Créons maintenant un répertoire pour snort_inline, pour enregistrer l’activité malveillante dans un journal :
mkdir /var/log/snort

Par défaut, tout le trafic s’écoulant vers le noyau et refluant vers l’espace utilisateur doit être intercepté par snort_inline, pour vérifier la présence de paquets de réseau malveillants. Le noyau s’en charge en poussant les données dans une file d’attente à l’aide du module ip_queue. Vous pouvez charger ip_queue et vérifier sa présence comme suit :

modprobe ip_queue lsmod | grep ip_queue
Ensuite, iptables doit être configuré pour envoyer le trafic à ip_queue. iptables -I INPUT -p tcp –dport 80 -j QUEUE
Lancer maintenant snort_inline:
snort_inline -c /etc/snort/snort.conf -Q -N -l /var/log/snort/ \ -t /var/log/snort/ -v

Vous devriez voir du texte défiler et snort_inline afficher un message semblable à celui-ci:

__== Initialisation Complete ==__
Dans l’affirmative, félicitations. Si vous recevez un message similaire à celui ci-dessous, c’est que vous avez oublié de charger le module ip_queue:
Reading from iptables Running in IDS mode Initializing Inline mode InitInline: : Failed to send netlink message: Connection refused

Regles

La dernière étape consiste à modifier tous les fichiers de règles, en transformant les règles d’alerte en règle de rejet. Une commande simple peut suffire, mais il faut la saisir avec exactitude. Si vous n’êtes pas sûr, faites une sauvegarde de votre dossier de règles avant de saisir cette commande, chose que vous devriez faire régulièrement.
cd /etc/snort/rules/ for file in $(ls -1 *.rules) do sed -e ‘s:^alert:drop:g’ ${file} > ${file}.new mv ${file}.new ${file} -f done
Il ne reste plus qu’à lancer snort en faisant: /usr/local/snort*/src/snort -c /etc/snort/snort.conf Ne pas oublier de fermer snort et d’annuler les regles iptables si vous voulez faire revenir votre système à la normale: Citation : iptables -D INPUT -p tcp –dport 80 -j QUEUE

Sources de l’article

 

Bash

Bash

Comment :

Le shell est un interpréteur de commande qui sert d’interface entre l’utilisateur et le système d’exploitation. Bash est le plus utilisé des shells, c’est celui sur lequel nous nous baserons tout au long de ce chapitre. De plus, Bash est aussi un language de programmation complet visant à simplifier et automatiser les taches quotidiennes des administrateurs.

Creation et invocation d’un script

Creation d’un script

Un script, ou fichier de commandes, est un ensemble de commandes placées dans un fichier texte. Chaque ligne de ce fichier correspond à une ligne qu’aurait pu entrer un opérateur. Un script est destiné à un interpréteur qui lit, analyse, et exécute les commandes qu’il contient. Dans le cas d’un shell-script, l’interpréteur est un des shells d’Unix (bash, sh…). Dans ce document, nous allons apprendre à écrire un script en Bourne-shell (bash ou sh). La première ligne d’un script doit spécifier le programme à appeler pour l’interpréter. Elle doit commencer par la séquence “#!” suivie d’au moins une espace puis du nom de l’interpréteur.
Pour un shell-script écrit en Bourne-shell, elle sera :
#! /bin/bash
Pour un script Perl, la première ligne sera :
#! /usr/bin/perl
Le nom d’un shell-script peut être quelconque, mais on choisit généralement :
– soit “mon script” (sans extension), pour que son nom ait l’air d’une commande Unix comme une autre.
– soit “mon script.sh” pour indiquer explicitement qu’il s’agit d’un shell-script.

Invocation d’un script

On peut exécuter un script comme toute autre commande en l’appelant par son nom. Pour cela, il faut d’une part que les droits d’exécution soient positionnés correctements : chmod +x mon_script
et, d’autre part, il faut que le chemin du fichier appartienne à la variable d’environnement PATH (sinon, vous devriez systématiquement préciser le chemin de votre script pour l’exécuter. Une autre façon d’exécuter un script, et qui aboutit au même résultat, est d’invoquer son interpréteur avec le nom du script en paramètre (exemple : “sh mon script.sh”).

Il faut savoir que, lancé ainsi, un script s’exécute dans un shell secondaire (sous-shell), totalement indépendant du shell qui l’a appelé Ceci aura pour effet d’annuler toute modification de l’environnement du script (changement de chemin avec cd, création ou modification de variables, etc…) dès lors que le script sera terminé.

Pour éviter cela, et donc permettre à un shell-script de modifier l’environnement de votre shell, il suffit d’appeler ce script grâce à la commande source (ou ‘.’). . mon_script ou source mon_script Toutes les commandes du script sont alors exécutées dans le shell actuel.

Premier exemple de script

#! /bin/bash
echo hello world
Execution de notre script :
$ ./hello.sh
Hello world
Une autre facon de le lancer, cette fois-ci en appelant le script par l’interpreteur :
$ bash hello.sh
Hello World
Enfin de cette facon le script est lancé dans le shell en cours :
$ . hello.sh ou source hello.sh

Hello World

Commentaires et taches de fond

Chaque ligne commençant par un # ne sera pas traitée comme une commande mais comme un commentaire par le shell.
#! /bin/bash
#debut du script
echo hello world
#fin du script
De plus, toute commande suivie du caractère ‘&’ s’executera en tâche de fond (arrière plan).

Valeur retournée par un shell-script a la fin de son execution

C’est la valeur retournée par la dernière commande exécutée dans le script. Par convention, une valeur de retour égale à 0 signifie que le script s’est bien déroulé. Inversement, toute autre valeur indique une erreur. De plus, on peut fixer cette valeur par la commande :
exit n
Dans ce cas, c’est n qui est retourné.
Comme pour toute commande, la valeur de retour d’un script peut être récupérée dans la variable $?.

Commandes d’un shell script

Commandes simples

Dans un script, on peut employer toute commande exécutable par l’utilisateur :
– un mot-clé appartenant au Bourne-shell (exemple : if, case, …)
– une commande interne (builtin) au Bourne-shell (exemple : echo, umask,…)
– une fonction définie par l’utilisateur avec le mot-clé function
– une commande externe (commande appartenant aux chemins de la variable PATH).
Pour savoir d’où provient une commande, on peut utiliser type.

 

Les attaques externes

Les attaques externes

Les attaques reseaux

Les attaques reseaux s’appuient sur des vulnerabilites liees directement aux protocoles ou à leur implementation. Il en existe un grand nombre. Neanmoins, la plupart d’entre elles ne sont que des variantes des cinq attaques reseaux les plus connues aujourd’hui.

Fragments attacks:

Cette attaque outrepasse la protection des equipements de filtrage IP. Pour sa mise en pratique, les pirates utilisent deux methodes : les Tiny Fragments et le Fragment Overlapping. Ces attaques etant historiques, les pare-feux actuels les prennent en compte depuis longtemps dans leur implementation.

Tiny Fragments

D’apres la RFC (Request For Comment) 791 (IP), tous les noeuds Internet (routeurs) doivent pouvoir transmettre des paquets d’une taille de 68 octets sans les fragmenter d’avantage. En effet, la taille minimale de l’en-tete d’un paquet IP est de 20 octets sans options. Lorsqu’elles sont presentes, la taille maximale de l’en-tete est de 60 octets. Le champ IHL (Internet Header Length) contient la longueur de l’en-tete en mots de 32 bits. Ce champ occupant 4 bits, le nombre de valeurs possibles vaut de 2^4 – 1 = 15 (il ne peut pas prendre la valeur 0000). La taille maximale de l’en-tete est donc bien 15*4 = 60 octets. Enfin, le champ Fragment Offset qui indique le decalage du premier octet du fragment par rapport au datagramme complet est mesure en blocs de 8 octets. Un fragment de donnees occupe donc au moins 8 octets. Nous arrivons bien à un total de 68 octets.

L’attaque consiste à fragmenter sur deux paquets IP une demande de connexion TCP. Le premier paquet IP de 68 octets ne contient comme donnees que les 8 premiers octets de l’en-tete TCP (ports source et destination ainsi que le numero de sequence). Les donnees du second paquet IP renferment alors la demande de connexion TCP (flag SYN à 1 et flag ACK à 0).

Or, les filtres IP appliquent la meme regle de filtrage à tous les fragments d’un paquet. Le filtrage du premier fragment (Fragment Offset egal à 0) determinant cette regle elle s’applique donc aux autres (Fragment Offset egal à 1) sans aucune autre forme de vérification. Ainsi, lors de la defragmentation au niveau IP de la machine cible, le paquet de demande de connexion est reconstitue et passe à la couche TCP. La connexion s’etablit alors malgre le filtre IP.

Fragment Overlapping

Toujours d’apres la RFC 791 (IP), si deux fragments IP se superposent, le deuxieme ecrase le premier. L’attaque consiste à forger deux fragments d’un paquet IP. Le filtre IP accepte le premier de 68 octets car il ne contient aucune demande de connexion TCP (flag SYN = 0 et flag ACK = 0). Cette regle d’acceptation s’applique, la encore, aux autres fragments du paquet. Le deuxieme (avec un Fragment Offset egal à 1) contenant les veritables donnees de connexion est alors accepté par le filtre IP. Ainsi, lors de la defragmentation les donnees du deuxieme fragment ecrasent celles du premier à partir de la fin du 8eme octet (car le fragment offset est egal à 1). Le paquet reassemble constitue donc une demande de connexion valide pour la machine cible. La connexion s’etablit malgre le filtre IP.

Spoofing

Le but de cette attaque est l’usurpation de l’adresse IP d’une machine. Ceci permet au pirate de cacher la source de son attaque (utilisée dans les denis de services dont nous discuterons plus tard) ou de profiter d’une relation de confiance entre deux machines. Nous expliquerons donc ici cette deuxieme utilisation de l’IP Spoofing.

Le principe de base de cette attaque consiste à forger ses propres paquets IP (avec des programmes comme hping2 ou nemesis) dans lesquels le pirate modifiera, entre autres, l’adresse IP source. L’IP Spoofing est souvent qualifiee d’attaque aveugle (ou Blind Spoofing). Effectivement, les reponses eventuelles des paquets envoyes ne peuvent pas arriver sur la machine du pirate puisque la source est falsifiee. Ils se dirigent donc vers la machine spoofee. Il existe neanmoins deux methodes pour recuperer des reponses :

1. le Source Routing : le protocole IP possede une option appelee Source Routing autorisant la specification du chemin que doivent suivre les paquets IP. Ce chemin est constitue d’une suite d’adresses IP des routeurs que les paquets vont devoir emprunter. Il suffit au pirate d’indiquer un chemin, pour le retour des paquets, jusqu’à un routeur qu’il controle. De nos jours, la plupart des implamentations des piles TCP/IP rejettent les paquets avec cette option ;

2. le Reroutage : les tables des routeurs utilisant le protocole de routage RIP peuvent etre modifiees en leur envoyant des paquets RIP avec de nouvelles indications de routage . Ceci dans le but de rerouter les paquets vers un routeur que le pirate maitrise.

Ces techniques ne sont plus (ou difficilement) utilisables : l’attaque est donc menee sans avoir connaissance des paquets emis par le serveur cible.
Le Blind Spoofing s’utilise contre des services de type rlogin ou rsh. En effet, leur mecanisme d’authentification se base uniquement sur l’adresse IP source de la machine cliente. Cette attaque relativement bien connue (surtout grace à Kevin Mitnick qui l’avait utilisée contre la machine de Tsutomu Shimomura en 1994) se deroule en plusieurs etapes

* determination de l’adresse IP de la machine de confiance en utilisant par exemple showmount -e qui montre ou sont exportes les systemes de fichiers ou rpcinfo qui apporte des informations supplamentaires ;
* mise hors service de l’hote de confiance via un SYN Flooding par exemple (nous aborderons les denis de service plus loin dans cet article). Cela est necessaire pour que la machine ne puisse pas repondre aux paquets envoyes par le serveur cible. Dans le cas contraire elle enverrait des paquets TCP RST qui mettraient fin à l’etablissement de la connexion ;
* prediction des numeros de sequence TCP : à chaque paquet TCP est associe un numero de sequence initiale. La pile TCP/IP du systeme d’exploitation le genere de maniere lineaire, dependante du temps, pseudo-aleatoire ou aleatoire selon les systemes. Le pirate peut uniquement appliquer cette attaque à des systemes generant des numeros de sequence previsibles (generation lineaire ou dependante du temps) ;
* l’attaque consiste à ouvrir une connexion TCP sur le port souhaite (rsh par exemple). Pour une meilleure comprehension, nous allons rappeler le mecanisme d’ouverture d’une connexion TCP. Elle s’effectue en trois phases (TCP Three Way Handshake) :
1. l’initiateur envoie un paquet comportant le flag TCP SYN et un numero de sequence x, est envoye à la machine cible ;
2. cette derniere repond avec un paquet dont les flag TCP SYN et ACK (avec un numero d’acquittement de x+1) sont actives. Son numero de sequence vaut y ;
3. l’initiateur renvoie un paquet contenant le flag TCP ACK (avec un numero d’acquittement de y+1) à la machine cible. Le pirate utilise la machine A tandis que la C represente la machine de confiance. La notion A(C) signifie que le paquet est envoye par A avec l’adresse IP Spoofee de C. A noter l’existence du programme mendax qui met en oeuvre ces differents mecanismes de l’IP Spoofing.

TCP Session Hijacking

Le TCP Session Hijacking permet de rediriger un flux TCP. Un pirate peut alors outrepasser une protection par un mot de passe (comme telnet ou ftp). La necessite d’une ecoute passive (sniffing) restreint le perimetre de cette attaque au reseau physique de la cible. Avant de detailler cette attaque, nous expliquerons quelques principes fondamentaux du protocole TCP.

Nous ne devoilerons pas ici les arcanes du protocole TCP, mais preciserons uniquement les points essentiels à la comprehension de l’attaque. L’en-tete TCP est constitue de plusieurs champs :

* le port source et le port destination, pour identifier la connexion entre deux machines ;
* le numero de sequence qui identifie chacun des octets envoyes ;
* le numero d’acquittement qui correspond au numero d’acquittement du dernier octet relu ;
* les flags, avec ceux qui vont nous int?resser sont :

o SYN qui synchronise les numeros de sequence lors de l’etablissement d’une connexion ;
o ACK, le flag d’acquittement d’un segment TCP ;
o PSH qui indique au recepteur de remonter les donnees à l’application.

Dans ce cas, il s’agit de la machine A qui a initialise une connexion TCP sur la machine B. Les numeros de sequence vont evoluer en fonction du nombre d’octets de donnees envoyees. Le numero de sequence est represente par Seq, le numero d’acquittement se trouve apres les flags PSH et ACK et le nombre d’octets de donnees envoye se trouve entre parentheses.

Cette attaque cree un etat de desynchronisation de chaque coté de la connexion TCP, rendant possible le vol de session. Une connexion est desynchronisee lorsque le numero de sequence du prochain octet envoye par la machine A est different du numero de sequence du prochain octet à recevoir par B. Et reciproquement, il y a desynchronisation lorsque le numero de sequence du prochain octet envoye par la machine B est different du numero de sequence du prochain octet à recevoir par A.

la fin de la première etape quand B recoit son paquet, A attends un paquet avec un numero d’acquittement de x+60. Si le prochain paquet qu’envoie B n’a pas ce numero d’acquittement alors A et B sont dits desynchronises.

Concretement, un pirate avec une machine C veut voler une session Telnet etablie entre les machines A et B. Dans un premier temps, la machine C sniffe le traffic Telnet (port TCP 23) entre A et B. Une fois que le pirate estime que A a eu le temps de s’authentifier aupres du service Telnet de la machine B, il desynchronise la machine A par rapport à B. Pour cela, il forge alors un paquet avec, comme adresse IP source, celle de la machine A et le numero d’acquittement TCP attendu par B. La machine B accepte donc ce paquet. En plus de desynchroniser la connexion TCP ce paquet permet au pirate d’injecter une commande via la session Telnet prealablement etablie par A. En effet, ce paquet peut transporter des donnees (flag PSH egal à 1).

La machine B accepte bien la commande envoyee par C, elle acquitte donc ce paquet en envoyant un paquet à A avec le flag ACK. Entre temps, si A a envoye un paquet à B celui-ci n’a pas ete accepté du fait de numero de sequence qui n’est pas celui attendu par B.

Un problame apparait alors : le Ack Storm. Il s’agit d’une multitude de ACK qui sont generes. Ils apparaissent lorsque A envoie un paquet TCP avec un numero de sequence non valide (car A est desynchronise) B le jette et envoie à A un ACK avec le numero de sequence qu’il attend. De son coté, A recoit ce ACK et comme le numero de sequence ne correspond pas à celui attendu il renvoie à son tour un ACK à B et B refait la meme chose…

Ce problame du Ack Storm peut etre regle si le pirate utilise l’ARP Spoofing. Dans ce cas, la machine C empoisonnera le cache ARP de la machine B en lui indiquant que l’adresse IP de A est desormais associee à l’adresse MAC de C. Ces differentes techniques sont implamentees par le programme hunt.

ARP Spoofing

Cette attaque, appelee aussi ARP Redirect, redirige le trafic reseau d’une ou plusieurs machine vers la machine du pirate. Elle s’effectue sur le reseau physique des victimes. Au prealable nous ferons un rappel sur l’utilite et le fonctionnement du protocole ARP.

Le protocole ARP (Address Resolution Protocol) implemente le mecanisme de resolution d’une adresse IP en une adresse MAC Ethernet. Les equipements reseaux communiquent en echangeant des trames Ethernet (dans le cas d’un reseau Ethernet bien sur) au niveau de la couche liaison de donnees. Pour pouvoir echanger ces informations il est necessaire que les cartes reseau possedent une adresse unique au niveau Ethernet, il s’agit de l’adresse MAC (Media Access Control).

Quand un paquet IP doit etre envoye la machine expeditrice a besoin de l’adresse MAC du destinataire. Pour cela une requete ARP en broadcast est envoyee à chacune des machines du reseau physique local. Cette requete pose la question : “Quelle est l’adresse MAC associee à cette adresse IP à”. La machine ayant cette adresse IP repond via un paquet ARP, cette reponse indiquant à la machine emettrice l’adresse MAC recherchee. Des lors, la machine source possede l’adresse MAC correspondant à l’adresse IP destination des paquets qu’elle doit envoyer. Cette correspondance sera gardee pendant un certain temps au niveau d’un cache (pour eviter de faire une nouvelle requete à chaque paquet IP envoye).

Cette attaque corrompt le cache de la machine victime. Le pirate envoie des paquets ARP reponse à la machine cible indiquant que la nouvelle adresse MAC correspondant à l’adresse IP d’une passerelle (par exemple) est la sienne. La machine du pirate recevra donc tout le trafic à destination de la passerelle, il lui suffira alors d’ecouter passivement le trafic (et/ou le modifier). Il routera ensuite les paquets vers la veritable destination.

L’ARP Spoofing sert dans le cas ou le reseau local utilise des switchs. Ceux-ci redirigent les trames Ethernet sur des ports differents selon l’adresse MAC. Il est des lors impossible à un sniffer de capturer des trames au-dela de son brin physique. L’ARP Spoofing permet ainsi d’ecouter le trafic entre des machines situees sur des brins differents au niveau du switch.

Pour mettre en oeuvre une attaque par ARP Spoofing, le pirate va utiliser un generateur de paquet ARP comme ARPSpoof ou nemesis. Soit la machine victime 10.0.0.171, sa passerelle par defaut 10.0.0.1 et la machine du pirate 10.0.0.227. Avant l’attaque un traceroute donne comme resultat :

[root@cible -> ~]$ traceroute 10.0.0.1 traceroute to 10.0.0.1 (10.0.0.1), 30 hops max, 40 byte packets 1 10.0.0.1 (10.0.0.1) 1.218 ms 1.061 ms 0.849 ms

Et le cache ARP de la machine cible est :

[root@cible -> ~]$ arp Address HWtype HWAddress Flags Mask Iface 10.0.0.1 ether 00:b0:c2:88:de:65 C eth0 10.0.0.227 ether 00:00:86:35:c9:3f C eth0

Le pirate lance alors ARPSpoof :
[root@pirate -> ~]$ arpspoof -t 10.0.0.171 10.0.0.1 0:0:86:35:c9:3f 0:60:8:de:64:f0 0806 42: arp reply 10.0.0.1 is-at 0:0:86:35:c9:3f 0:0:86:35:c9:3f 0:60:8:de:64:f0 0806 42: arp reply 10.0.0.1 is-at 0:0:86:35:c9:3f 0:0:86:35:c9:3f 0:60:8:de:64:f0 0806 42: arp reply 10.0.0.1 is-at 0:0:86:35:c9:3f 0:0:86:35:c9:3f 0:60:8:de:64:f0 0806 42: arp reply 10.0.0.1 is-at 0:0:86:35:c9:3f 0:0:86:35:c9:3f 0:60:8:de:64:f0 0806 42: arp reply 10.0.0.1 is-at 0:0:86:35:c9:3f 0:0:86:35:c9:3f 0:60:8:de:64:f0 0806 42: arp reply 10.0.0.1 is-at 0:0:86:35:c9:3f 0:0:86:35:c9:3f 0:60:8:de:64:f0 0806 42: arp reply 10.0.0.1 is-at 0:0:86:35:c9:3f

Les paquets envoyes sont des paquets ARP empoisonnant le cache ARP de la machine 10.0.0.171 avec des ARP Reply indiquant que l’adresse MAC associee à 10.0.0.1 est maintenant 00:00:86:35:c9:3f.

Desormais, le cache ARP de la machine 10.0.0.171 est :

[root@cible -> ~]$ arp Address HWtype HWAddress Flags Mask Iface 10.0.0.1 ether 00:00:86:35:c9:3f C eth0 10.0.0.227 ether 00:00:86:35:c9:3f C eth0

Pour verifier que le trafic passe maintenant par la machine 10.0.0.227 il suffit de faire un nouveau traceroute vers la passerelle 10.0.0.1 :

[root@cible -> ~]$ traceroute 10.0.0.1 traceroute to 10.0.0.1 (10.0.0.1), 30 hops max, 40 byte packets 1 10.0.0.227 (10.0.0.227) 1.712 ms 1.465 ms 1.501 ms 2 10.0.0.1 (10.0.0.1) 2.238 ms 2.121 ms 2.169 ms

Le pirate est desormais capable de sniffer le trafic de la machine 10.0.0.171 vers 10.0.0.1. Il ne faut pas que le pirate oublie d’activer le routage IP sur sa machine 10.0.0.227 (avec l’IP Forwarding – activer la cla > net.ipv4.ip_forward dans /etc/sysctl.conf ou fragrouter).

DNS Spoofing

Le protocole DNS (Domain Name System) a pour role de convertir un nom de domaine (par exemple www.test.com) en son adresse IP (par exemple 192.168.0.1) et reciproquement, à savoir convertir une adresse IP en un nom de domaine. Cette attaque consiste à faire parvenir de fausses reponses aux requ?tes DNS ?misent par une victime. Il existe deux methodes principales pour effectuer cette attaque.

DNS ID Spoofing

L’en-tete du protocole DNS comporte un champ identification qui permet de faire correspondre les reponses aux demandes. L’objectif du DNS ID Spoofing est de renvoyer une fausse reponse à une requete DNS avant le serveur DNS. Pour cela il faut predire l’ID de la demande. En local, il est simple de le predire en sniffant le reseau. neanmoins, cela s’avere plus complique à distance. Cependant il existe plusieurs methodes :

* essayer toutes les possibilit?s du champ ID. Cette methode n’est pas tres realiste puisqu’il y a 65535 possibilites pour le champ ID (car ce champ est code sur 16 bits) ;
* envoyer quelques centaines de requetes DNS dans l’ordre. Cette methode est bien evidemment peu fiable ;
* trouver un serveur qui genere des ID previsibles (incrementation de 1 de l’ID par exemple), ce genre de faille existe sur certaines version de Bind ou des machines Windows 9x.
Dans tous les cas, il est necessaire de repondre avant le serveur DNS, en le faisant tomber via un deni de service par exemple.

Pour parvenir à ses fins, l’attaquant doit controler un serveur DNS (ns.attaquant.com) ayant autorité sur le domaine attaquant.com. Le serveur DNS cible (ns.cible.com) est suppose avoir des numeros de sequence previsibles (s’incrementant de 1 à chaque nouvelle requete).

L’attaque se decompose en quatre etapes :

1. l’attaquant envoie une requete DNS pour le nom www.attaquant.com au serveur DNS du domaine cible.com
# le serveur DNS cible a donc relaye la demande au DNS du domaine attaquant.com ;
# l’attaquant est capable de sniffer la requete pour recuperer son ID (dans notre exemple l’ID a une valeur de 100) ;
# l’attaque falsifie l’adresse IP associee à un nom de machine, ici la machine victime est www.spoofed.com qui a normalement l’adresse IP 192.168.0.1. Le pirate emet une requete DNS de implemente du nom www.spoofed.com vers ns.cible.com. Immediatement apres, il envoie une multitude de reponses DNS falsifiees (donnant comme adresse IP celle du site de l’attaquant 10.0.0.1) à cette meme requete en ayant spoofe l’adresse IP source avec celle du serveur DNS du domaine spoofed.com. L’ID de chaque reponse sera incrementee de 1 à partir de celui recupere lors de la deuxieme etape (ID = 100) pour augmenter la chance de tomber sur le bon numero d’ID reponse, dans le cas ou ns.cible.com aurait du repondre à d’autre requete et donc incremente son ID DNS.
Le cache du serveur DNS cible est donc corrompu, et la prochaine machine demandant une implemente du nom www.spoofed.com recuperera l’adresse IP de la machine de l’attaquant et sera redirigee vers son site qui pourra etre une copie du vrai site pour tromper les internautes et leur voler des informations confidentielles.

DNS Cache Poisoning

Les serveurs DNS possedent un cache gardant en local, pendant un certain temps, les reponses de requetes passees. Ceci pour eviter de perdre du temps à interroger chaque fois le serveur de nom ayant autorité sur le domaine demande. Ce deuxieme type de DNS Spoofing va consister à corrompre ce cache avec de fausses informations. Voici un exemple de cache poisoning :

Les conditions de l’exemple precedent sont toujours valables. Voici les differentes etapes de l’attaque :

* envoyer une requete DNS de implemente du nom www.attaquant.com au serveur DNS du domaine cible.com ;
* Le serveur DNS cible envoie donc une requete portant sur une implemente du nom www.attaquant.com au serveur DNS de l’attaquant ;
* Le serveur DNS de l’attaquant enverra une reponse avec des enregistrements falsifiees qui permettront d’assigner un nom de machine avec une adresse IP appartenant à l’attaquant. Par exemple, le site www.cible.com pourra avoir un enregistrement DNS falsifie renvoyant l’adresse IP de www.attaquant.com au lieu de la bonne adresse IP.

Les attaques applicatives

Les attaques applicatives s’appuient principalement sur des vulnerabilites specifiques aux applications utilisees. Cependant, certaines attaques peuvent etre classees par type.

Les problemes de configuration

Un des premiers problames de securite engendre par les applications est celui des erreurs de configurations. Nous distinguerons deux types d’erreurs : les installations par defaut et les mauvaises configurations à proprement parler.

Des logiciels, comme les serveurs Web, installes par defaut ont souvent des sites exemples qui peuvent etre utilises par des pirates pour acceder à des informations confidentielles. Par exemple, il peut y avoir des scripts permettant d’obtenir les sources des pages dynamiques ou des informations sur le systeme utilise. En outre, lors d’une telle installation une interface d’administration à distance est disponible avec un login/mot de passe par defaut (trouvable dans le guide d’administration de l’application). Le pirate a donc la main sur le site et peut le modifier selon son bon vouloir.

Les principales failles generees par une mauvaise configuration sont des listes d’acces mal parametrees. Le pirate accede alors à des pages et autres bases de donnees privees.

Comme exemple classique de problame de configuration, les erreurs de parametrage du serveur Web Lotus Domino sont courantes. En effet, lors de l’installation de ce serveur, des bases Lotus de configuration sont accessibles sans aucune liste de controle d’acces. Concretement, si la base Lotus names.nsf est accessible via un navigateur Web sans demande d’authentification, il est alors possible d’obtenir de nombreuses informations comme le nom de tous les utilisateurs Lotus. Cette base n’est qu’un exemple, et Lotus Domino en contient un nombre important de sensibles.

Les bugs

Une mauvaise programmation des logiciels entraine obligatoirement des bugs. Ceux-ci seront la source des failles de securite les plus importantes. Ces vulnerabilites quand elles sont decouvertes vont permettre d’executer des commandes non autorisees, obtenir le source de pages dynamiques, rendre indisponible un service, prendre la main sur la machine…etc. Les plus connus de ces bugs et les plus interessants en ce qui concerne leur exploitation sont les buffer overflow.

Les buffer overflow

Le depassement de pile est une faille due à une mauvaise programmation. Effectivement, un buffer overflow apparait quand une variable passee en argument d’une fonction est recopiee dans un buffer sans que sa taille n’aie ete verifiee. Il suffit que la variable ait une taille superieure à l’espace memoire reservee pour ce buffer pour qu’un depassement de pile se produise. Celui-ci sera exploite en passant dans la variable un fragment de programme capable de faire demarrer un shell tout en obligeant ce debordement de pile à se produire. Dans le cas ou un pirate reussit cette attaque il obtiendra alors le moyen d’executer à distance des commandes sur la machine cible avec les droits de l’application attaquee. Le buffer overflow et son exploitation ont ete le sujet d’une serie d’articles de Linux Magazine.

Les scripts

Une mauvaise programmation des scripts a souvent une repercution sur la securite d’un systeme. En effet, il existe des moyens d’exploiter des failles de scripts developpes en Perl qui permettront de lire des fichiers hors racine Web ou d’executer des commandes non autorisees. Ces problames de programmation ont ete evoques dans le dernier article de Linux Mag sur les failles des developpements en Perl et PHP.

Man in the middle

L’objectif principal de cette attaque est de detourner le trafic entre deux machines. Cela pour intercepter, modifier ou detruire les donnees transmises au cours de la communication. Cette attaque est plus un concept qu’une attaque à part entiere. Il existe plusieurs attaques mettant en oeuvre ce principe du Man in The Middle, comme le DNS Man in the Middle qu’une utilisation du DNS Spoofing pour detourner le trafic entre un client et un serveur Web. De meme, une application recente a ete elaboree pour detourner du trafic SSH

Les denis de service

Cette attaque porte bien son nom puisque qu’elle aboutira à l’indisponibilite du service (application specifique) ou de la machine visee. Nous distinguerons deux types de deni de services, d’une part ceux dont l’origine est l’exploitation d’un bug d’une application et d’autre part ceux dus à une mauvaise implementation d’un protocole ou à des faiblesses de celui-ci.

Les denis de service applicatifs

Tout comme les vulnerabilites d’une application entrainent la possibilite de prendre le controle d’une machine (exemple du buffer overflow), elles peuvent aussi amener à un deni de service. L’application sera alors indisponible par saturation des ressources qui lui sont allouees ou un crash de celle-ci.

Les denis de service reseaux

Il existe differents types de deni de service utilisant les specificites des protocoles de la pile TCP/IP.

SYN Flooding

Nous avons vu qu’une connexion TCP s’etablie en trois phases (TCP Three Way Handshake). Le SYN Flooding exploite ce mecanisme d’etablissement en trois phases. Les trois etapes sont l’envoi d’un SYN, la reception d’un SYN-ACK et l’envoi d’un ACK. Le principe est de laisser sur la machine cible un nombre important de connexions TCP en attentes. Pour cela, le pirate envoie un tres grand nombre de demandes de connexion (flag SYN à 1), la machine cible renvoie les SYN-ACK en reponse au SYN refus. Le pirate ne repondra jamais avec un ACK, et donc pour chaque SYN recu la cible aura une connexion TCP en attente. Etant donne que ces connexions semi-ouvertes consomment des ressources memoires au bout d’un certain temps la machine est saturee et ne peut plus accepter de connexion. Ce type de deni de service n’affecte que la machine cible.
Le pirate utilise un SYN Flooder comme synk4, en indiquant le port TCP cible et l’utilisation d’adresses IP source alaatoires pour eviter toute identification de la machine du pirate.

UDP Flooding

Ce deni de service exploite le mode non connecte du protocole UDP. Il cree un “UDP Packet Storm” (generation d’une grande quantite de paquets UDP) soit à destination d’une machine soit entre deux machines. Une telle attaque entre deux machines entraine une congestion du reseau ainsi qu’une saturation des ressources des deux hotes victimes. La congestion est plus importante du fait que le trafic UDP est prioritaire sur le trafic TCP. En effet, le protocole TCP possede un mecanisme de controle de congestion, dans le cas ou l’acquittement d’un paquet arrive apres un long delai, ce mecanisme adapte la frequence d’emission des paquets TCP, le debit diminue. Le protocole UDP ne possede pas ce mecanisme, au bout d’un certain temps le trafic UDP occupe donc toute la bande passante n’en laissant qu’une infime partie au trafic TCP.

L’exemple le plus connu d’UDP Flooding est le Chargen Denial of Service Attack. La mise en pratique de cette attaque est simple, il suffit de faire communiquer le service chargen d’une machine avec le service echo d’une autre. Le service chargen genere des caracteres tandis que echo se contente de reemettre les donnees qu’il recoit. Il suffit alors au pirate d’envoyer des paquets UDP sur le port 19 (chargen) à une des victimes en spoofant l’adresse IP et le port source de l’autre. Dans ce cas le port source est le port UDP 7 (echo). L’UDP Flooding entraine une saturation de la bande passante entres les deux machines. Un reseau complet peut donc etre victime d’un UDP Flooding.

Packet fragment

Les denis de service de type Packet Fragment utilisent des faiblesses dans l’implementation de certaines pile TCP/IP au niveau de la defragmentation IP (reassemblage des fragments IP).
Une attaque connue utilisant ce principe est Teardrop. L’offset de fragmentation du second fragment est inferieur à la taille du premier ainsi que l’offset plus la taille du second. Cela revient à dire que le deuxieme fragment est contenu dans le premier (overlapping). Lors de la defragmentation certains systemes ne gerent pas cette exception et cela entraine un deni de service. Il existe des variantes de cette attaque : bonk, boink et newtear par exemple. Le deni de service Ping of Death exploite une mauvaise gestion de la defragmentation au niveau ICMP, en envoyant une quantite de donnees sup?rieure à la taille maximum d’un paquet IP. Ces differents denis de services aboutissent à un crash de la machine cible.

Smurfing

Cette attaque utilise le protocole ICMP. Quand un ping (message ICMP ECHO) est envoye à une adresse de broadcast (par exemple 10.255.255.255), celui-ci est demultiplie et envoye à chacune des machines du reseau. Le principe de l’attaque est de spoofer les paquets ICMP ECHO REQUEST envoyes en mettant comme adresse IP source celle de la cible. Le pirate envoie un flux continu de ping vers l’adresse de broadcast d’un reseau et toutes les machines repondent alors par un message ICMP ECHO REPLY en direction de la cible. Le flux est alors multiplie par le nombre d’hote composant le reseau. Dans ce cas tout le reseau cible subira le deni de service, puisque l’enorme quantite de trafic genere par cette attaque entraine une congestion du reseau.

deni de service distribue

Les denis de services distribues saturent le reseau victime. Le principe est d’utiliser plusieurs sources (daemons) pour l’attaque et des maitres (masters) qui les controlent. Les outils de DDoS (Distributed Denial of Service) les plus connus sont Tribal Flood Network (TFN), TFN2K, Trinoo et Stacheldraht.
Le pirate utilise des maitres pour controler plus facilement les sources. En effet, il a besoin de se connecter (en TCP) aux maitres pour configurer et preparer l’attaque. Les maitres se contentent d’envoyer des commandes aux sources en UDP. S’il n’y avait pas les maitres, le pirate serait oblige de se connecter à chaque source. La source de l’attaque serait detectee plus facilement et sa mise en place beaucoup plus longue.

Chaque daemon et master discutent en echangeant des messages specifiques selon l’outil utilise. Ces communications peuvent meme etre cryptees et/ou authentifiees. Pour installer les daemons et les masters, le pirate utilise des failles connues (buffer overflow sur des services RPC, FTP ou autres). L’attaque en elle-meme est un SYN Flooding, UDP Flooding ou autre Smurf Attack. Le resultat d’un deni de service est donc de rendre un reseau inaccessible.

Conclusion

Aujourd’hui, la securite contre les attaques à distance se renforce de plus en plus contrairement à la securite interne. Ce parent pauvre de la protection contre les pirates laisse encore de belles perspectives à des attaques en local comme le TCP Session Hijacking, l’ARP Spoofing et le DNS Spoofing. Par ailleurs, la prediction de numero de sequence (coeur de l’IP Spoofing) et les variantes de Fragments Attacks apparaissent uniquement à cause de bugs au niveau des OS des equipements reseaux. En ce qui concerne les attaques applicatives, elles ont encore de beaux jours devant elles grace à la complexite sans cesse croissante des applications liees au Web et aux delais de plus en plus courts imposes aux d?veloppeurs et aux administrateurs. Quant aux denis de service, ils seront toujours aussi redoutables dans leur forme distribuee tant que tout le monde ne sera pas sensibilise à la protection de leur machine personnelle.

Attaques par injection SQL

Attaques par injection SQL
  • Introduction
  • Qu’est qu’une attaque de type sql injection ?
  • L’attaque en question
  • Demonstration d’autres types d’attaques
  • Comment se proteger des attaques par injection sql ?
  • Conclusion

Introduction

Suite aux nombreuses vulnerabilites de type “sql injection” que l’on a pu rencontrer dans le passe et que l’on retrouve encore et toujours aujourd’hui, j’ai decide de vous ecrire un petit article pour presenter ce qu’est vraiment une injection sql d’une part, mais nous verrons aussi comment un attaquant peut les utiliser et comment s’en proteger le mieux possible.

Ce type d’attaque vise les serveurs web et plus particulierement les erreurs de programmation au niveau des scripts asp, cgi, php, etc. Ces memes scripts executant des requetes sql… Ce sujet, comme nous l’avons vu auparavant, est assez ancien mais on peut dire qu’il est toujours reste d’actualite ne serait-ce que suite à l’utilisation abondante du asp et du php. Aussi, pas mal d’articles sur ce sujet ont prïvïlegie celui-ci et il est bien entendu que certains n’y verront, pour sur, que le cote rebarbatif. Mais l’important pour nous, en ecrivant cet article est d’expliquer cela par nos propres mots de facon à aider les d�utants, et d’adapter ce type de vulnerabilites à l’actualite.

Qu’est qu’une attaque de type sql injection ?

Comme vous le savez certainement SQL (Structured Query Language) est un language de base de donnees, celles-ci representant le coeur de beaucoup d’applications web de nos jours. C’est un language base sur des requetes utilisant des instructions telles que INSERT (insertion de donnees dans la base de donnees), DELETE (pour en supprimer), UPDATE (pour en mettre à jour), SELECT (pour en selectionner et lire), et bien d’autres. Mais cette simplicite en fait aussi une proie facile aux detections de failles.

Exemple de requete :

SELECT * FROM users WHERE login = ‘damien’;

Cette requete aura pour effet de selectionner l’utilisateur (extrait de la table “users”) dont le login est “damien”. “SELECT *” signifiant qu’on selectionne tous les champs de cette table mais peu importe pour le moment.

Continuons sur cet exemple pour bien vous faire comprendre ce qu’est une attaque de type sql injection (Mon exemple n’etant pas du pur hasard puisqu’une attaque de ce type dans le but de recuperer un mot de passe ou de s’identifier est certainement la plus courante). Maintenant imaginons que ma page contienne un formulaire d’identification utilisateur de ce type :

Login :

Password :

La requete associee à ce formulaire permettant de verifier que les login / password entres sont valides par rapport à notre base de donnees serait :

mysql_query(“SELECT * FROM users WHERE utilisateur = ‘$login’ AND motdepasse = ‘$password'”);

Cette requete aurait pour effet de selectionner l’utilisateur en question si le nom d’utilisateur ET le mot de passe entres sont dans notre base de donnees. Si l’un des deux est errones la requete ne renverra aucun resultat.

L’attaque en question

Sachant que sur mon exemple la variable $login contient ce que j’ai tape dans mon premier champ de texte et que la variable $password contient de meme ce que j’ai tape dans le deuxieme champ de texte (mot de passe), imaginez ce que cela pourrait donner si j’entrais ceci dans le premier champ de texte

Si nous allons voir ce qui se passe du cote du code, ma requete deviendrait alors :

mysql_query(“SELECT * FROM users WHERE utilisateur = ” OR 1=1″); //’ AND motdepasse = ‘$password'”);

Et elle permettrait certainement d’identifier car la requete est vraie si un utilisateur “” existe OU si 1=1. Comme il est evident que 1 est egal à 1, elle serait vraie. Le signe “//” signifiant un commentaire en php, le reste serait rendu inutile. il est vrai que ma requete est un peu tiree par les cheveux, mais imaginez maintenant que je sache qu’un certain damien est possesseur des droits administrateurs et que je rentre ceci dans mon champ de texte :

il selectionnera alors l’utilisateur damien sans se preoccuper du mot de passe en suivant le meme raisonnement que precedemment. .

Demonstration d’autres types d’attaques

Dans notre exemple precedent, nous ne faisions que nous identifier et nous aurions tres bien pu recuperer un mot de passe de la meme facon. Mais ce n’est pas tout ce qu’on pourrait faire avec une injection sql. Maintenant que vous avez compris comment vous “fabriquer” vos propres requetes, voici quelques exemples de requetes venant à effectuer des modifications sur les donnees ou meme le systeme cette fois-ci.

login : ‘ OR 1=1″); drop table users;

password : n’importe lequel

Celle-ci supprimerait completement la table users.

login : ‘; exec master..xp_cmdshell ‘net stop firewall’; —

password : n’importe lequel

Sachant que je suis repasse dans une syntaxe sql utilisee sur asp, cette requete ci-dessus aurait pour effet d’executer une commande shell “net stop firewall” qui stopperait l’execution du service “firewall”. Et puisque le serveur sql est lance en tant que SYSTEM par defaut, nous aurions tout à fait ce droit d’arreter des services.

login : ‘; shutdown with nowait; —

password : n’importe lequel

admin’ —

admin’ #

admin’/*

‘ or 1=1– /////celle-la m’a permis de résoudre un challenge, merci à elle …………….

‘ or 1=1#

‘ or 1=1/*

‘) or ‘1’=’1–

‘) or (‘1’=’1–

Mais ce ne sont que quelques exemples car les possibilites sont nombreuses.

Comment se proteger des attaques par injection sql ?

Comme vous pouvez vous en douter, le seul moyen de prevenir ces attaques se trouve au niveau de la programmation. Si celle-ci est bien realisee, elles ne sont normalement plus possibles. Alors…quelles sont les rïsques de programmation à prendre en compte ?

– Tout d’abord, evitez d’utiliser un compte ayant tous les pouvoirs pour l’execution de votre serveur sql si possible.

– Supprimer les fonctions que vous n’utilisez pas telle que celle que nous avons vu : master..xp_cmdshell, et de maniere generale toutes celles commencant par “master..xp”.

– verifiez les entrees utilisateurs telles que les champs de texte. verifiez aussi que les nombres attendus soient bien des nombres avec une fonction telle que IsNumeric() par exemple.

– verifiez aussi les parametres des URL qui sont ajoutables.

– Utilisez les caracteres et fonctions d’echappement telles que AddStripSlashes() en php, voir les caracteristiques de la fonction et en general les documentations de vos languages de programmation web pour plus d’infos. Cela empechera par exemple l’entree utilisateur du caractere ‘ en l’echappant à l’aide d’un slash le precedant.

– Vous pouvez aussi empecher d’une maniere generale certaines sequences d’entrees utilisateurs telles que “;”, “insert”, “select”, “//”, “–“, etc.

– Attention aussi à limiter le nombre de caracteres qu’un utilisateur peut entrer dans un champ de texte, car ceci peut fort bien lui compliquer la tache.

– Pour finir, attention à ce que vous mettez dans les cookies, car un mot de passe (meme crypter en md5) est vite trouvé par une attaque de ce type. Et par la suite un remplacement de cette valeur dans le cookie ïncite l’attaquant à une attaque de type brute force ; c’est donc un joli cadeau.

Conclusion

Nous avons pu voir differents types d’attaques realisables par injection sql ainsi que des moyens de les prevenir, en esperant que votre vision de la programmation sql aura ete amelioree coté securite et que vous pourrez vous-memes essayer de remïedier à ces failles dans vos applications web si besoin est puisque c’est le but.

Volontairement je ne me suis pas attarde sur l’ajout de parametres dans une URL, qui peut provoquer une injection sql de la meme facon car le principe est le meme, sauf que les formulaires vulnerables seront des formulaires les plus souvent caches cette fois-ci.

Voila..souvenez vous qu’aucune application web utilisant une base de donnees n’est totalement securisee si vous ne vous en preoccupez pas.

Sources de l’article

 

Netcat

Netcat

Introduction

L’aide de netcat

Scanner des ports avec Netcat

Netcat client

Netcat serveur

Redirections

Autres options

Spoofer les header http avec netcat

Transférer des fichiers avec netcat

Cloner des disques durs ou des partitions

Introduction

Netcat, developpe à l’origine pour Unix puis pour Windows plus tard par stake, est un programme bien connu en ligne de commande. Il permet de faire pas mal de choses avec des sockets, c’est-à dire connexions reseau pour simplifier. Plus concretement, il permet d’ouvrir des connexions reseau, que ce soit UDP ou TCP, sans avoir besoin de programmer quoi que ce soit. Tres utile pour realiser des relations client/serveurs pour faire des tests ou autre.

En fait, on peut faire pas mal de choses, que l’on va voir en detail plus loin, avec Netcat. C’est pour cela que j’aime bien le comparer à un couteau suisse.

De plus, amis programmeurs sachez qu’il est open source, et donc on peut avoir acces aux sources (que ce soit pour la version Unix ou Windows). Et quand on voit la puissance du programme sur quelques Ko, cela peut etre interessant.

Avant de detailler ses fonctionnalites, vous avez la possibilites de le telecharger pour Linux ou pour Windows chez stake si vous ne l’avez pas deja fait

L’aide de netcat

Voici comment se presente l’aide de netcat, que vous pouvez obtenir en tapant la commande “nc -h”. Elle pourra vous rappeler la syntaxe des commandes netcat a tout moment.


Scanner des ports avec Netcat

Et oui Netcat peut aussi scanner des ports… Par exemple si je veux scanner les ports ouverts entre 1 et 300 de l’ip 192.168.0.2, je fais :

nc -v -w2 -z 192.168.0.2 1-300

Bon bien sr, ce n’est srement pas le meilleur outil pour scanner des ports, loin de la Mais on peut deja s’apercevoir qu’il en fait des choses.

Netcat client

Pour ouvrir une connexion sur un port, il suffit de taper la commande : nc ip_serveur port
Je vous donne quelques exemples certainement plus parlants :

– nc ftp.sunet.se 21 : cette commande se connectera sur le ftp ftp.sunet.se (port ftp = port 21). Ensuite il faut connaïtre les commandes ftp pour pouvoir aller plus loin, car tout ne se fera pas tout seul comme avec un client ftp Allez un petit exemple pour ceux qui ne comprendraient pas trop ce que je veux dire :


En face des fleches bleues, ce que j’ai du taper.

– nc hostname.com 23 : cette commande se connectera sur le port (23) telnet de l’adresse hostname.com. A noter que Netcat prend en charge completement le Telnet de meilleure facon. Pour cela utiliser plutot : nc -t hostname.com 23
De meme on pourrait se connecter à un serveur web sur le port 80 etc etc.

Netcat-serveur

Pour mettre Netcat en ecoute sur un port de votre machine, il suffit d’utiliser les options -l et -p (listen et port) comme ceci :

nc -l -p 80
-l : pour le mettre en mode listen / ecoute
-p : pour qu’il ecoute sur le port

Normalement, il ne se passe rien et netcat ne vous redonne pas la main pour taper quoique ce soit, mais rien n’est perdu pour autant.
Sur cet exemple avec le port 80, lancez la commande suivante dans une autre fenetre : telnet 127.0.0.1 80
De facon à vous connecter sur le port 80 precedemment ouvert sur votre machine. Et sur cette nouvelle fenetre, si vous tapez quelque chose, vous le devriez le voir appara�re sur la premi�e fenetre. Comme quoi la fenetre client communique bien avec la fenetre serveur, magique non?

Maintenant vous pourrez remarquer que si vous fermez votre fenetre cliente (telnet), la fenetre serveur vous redonne la main. Autrement dit Netcat n’est plus ouvert. Une autre commande existe pour palier à cela : elle permet de remettre le port en ecoute en permanence à la fin d’une connection cliente.

nc -L -p 80

En suivant la meme demarche que precedemment mais avec cette nouvelle option -L à la place de -l, vous devriez vous rendre compte de cette difference.

Une autre option assez pratique dans notre cas est -v ; le mode verbose (littéralement “bavard”). Dans ce mode netcat est plus explicite sur ce qui se passe, et meme encore un peu plus en faisant -vv, comme sur cet exemple :

nc -L -vv -p 80
Et vous pourrez vous en apercevoir des le lancement de la commande puisqu’il vous retournera la phrase suivante : listening on [any] 80 … On sait vraiment ce qui se passe, et c’est pratique surtout quand on debute avec Netcat.

A quoi cela va bien pouvoir nous servir concretement ? Et bien, voilà qui ne va pas vous donner la solution mais tout du moins qui va vous laissez reflechir dessus, puisque son utilisation n’a comme limites que nos idees… Lancez Netcat en mode listen sur le port 80. Sachant que le port 80 est le port d’ecoute par defaut des serveurs web, lancez votre navigateur prïvilegie et entrez l’url suivante :

http://127.0.0.1

Regardez maintenant votre fenetre de Netcat et vous devriez apercevoir le texte initial qu’envoie le navigateur aux sites web. Magique non? Par la suite autant vous dire qu’en se renseignant un peu sur les commandes http, vous pouvez repondre à votre navigateur et ainsi de suite, ce qui emulerait un vrai serveur web.

Redirections

Sachez aussi qu’avec Netcat, à l’image de ce qu’on peut faire sous Unix, vous pouvez rediriger les entrees et sorties à l’aide des caracteres < et >. Exemple :

nc -L -vv -p 21 > ftp.log logguera toutes les commandes envoyees à votre Netcat port 21

nc -L -vv -p 21 < ftp.txt
Dans ce sens c’est ftp.txt qui va servir de fichier d’ïnstruction à Netcat. Lancez un client telnet, et vous verrez que Netcat ne va plus recevoir les caracteres tapes au clavier mais bien ceux qui se trouvent dans notre ftp.txt.

L’option -e peut aussi servir de redirection dans le sens o elle permet d’executer un programme en entree. Par exemple :

nc -L -vv -p 21 -e cmd.exe

Lancera le cmd.exe dans notre fenetre cliente telnet. Mais encore mieux on pourrait detacher Netcat de la fenetre de commande dans laquelle on le lance. Et bien si vous voulez vous faire un petit serveur Netcat pour de multiples raisons, alors vous allez devoir supporter la fenetre de commande qui le lance en permanence ? Non pas vraiment puisque l’option -d permet de detacher Netcat de cette fenetre et donc de le faire tourner en tache de fond. Vous l’avez toujours dans votre liste de processus et pouvez ainsi le killer quand vous en avez plus besoin, mais il ne s’affiche plus a l’ecran. Ainsi une personne mal intentionnee n’aurait aucun mal à laisser un port en ecoute chez vous discretement…

Autres options

Les autres options en bref :

-n : pour n’entrer que des adresses ip numeriques, pas de noms d’hotes (mode client).
-o : pour logguer tous les octets mais en hexadecimal cette fois.
-w : timeout, permet d’arreter la tentative de connection si le temps defini par est depasse
-u : ce mode permet de travailler avec le protocole UDP au lieu de TCP (modes client et serveur).
-s : l’adresse ip locale sur laquelle vous allez vous mettre en ecoute.

Spoofer les header http avec netcat

Si vous souhaitez envoyer des requêtes http à un serveur web, vous pouvez maquiller les en-têtes http, créer de faux navigateurs et de faux referer ainsi que d’autres choses. Voici un exemple de maquillage d’entêtes http depuis google.com, vous devriez savoir quel genre d’entête vous avez besoin

netcat -v www.google.com 80
www.google.com [216.239.59.99] 80 (http) open
GET / HTTP/1.1
Host: www.google.com
User-Agent: mybrowser 😀
Accept: image/png,*/*;q=0.5
Accept-Language: en-gb,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 300
Connection: keep-alive
Referer: www.nosite.com
HTTP/1.1 302 Found
Location: http://www.google.co.uk/cxfer?c=PREF%3D:TM%3D1103918397:S%
3D_KtpIy_HOz4CJcYF&prev=/
Content-Type: text/html
Server: GWS/2.1
Content-Length: 217
Date: Fri, 24 Dec 2004 19:59:57 GMT

Transférer des fichiers avec netcat

Par exemple, on veut copier un fichier monfichier.tar.gz d’une machine1 vers une machine2. Sur la machine2 saisir

nc -lp 1234 > monfichier.tar.gz

Le port 1234 peut être remplacé par le port de votre choix et sur machine1 faites

nc -w 1 server2.example.com 1234 < monfichier.tar.gz

pour démarrer le transfert

Cloner des disques durs ou des partitions

On peut copier des disques ou des partitions depuis le réseau Par exemple, si je veux copier /dev/sda de machine1 vers machine2, je vais démonter ma partition sur le système cible, en bootant par exemple sur machine2 avec un live CD
La machine cible a pour adresse 192.168.0.12 on va éxécuter sur cette machine

nc -l -p 1234 | dd of=/dev/sda

Ensuite, depuis la machine1,

dd if=/dev/sda | nc 192.168.0.12 1234

pour démarrer la copie

Source de l’article

 

Configuration et optimiser apache

Configuration et optimiser apache

Introduction

Apache est un serveur Web libre qui est ce jour le serveur Web le plus utilisé sur Internet.
Il est trés important de mettre à jour et d’utiliser une version récente d’apache car:

– De nombreux bugs de sécurité ont été corrigé
– Cette documentation traite de la configuration des derniers serveurs apaches. Dans les anciennes versions, il y avait trois fichiers (httpd.conf, srm.conf, access.conf) mais maitenant tous sont regroupés dans un même fichier:

httpd.conf.
Même si la compabilité avec les anciennes versions a été conservée (on peut toujours utiliser les anciens fichiers) je ne traite ici QUE du fichier httpd.conf.

Hostnamelookups

la directive HostnameLookups qui traduit les ips en noms d’hôtes ajoute un temps certains de latence entre chaque requête. HostnameLookups doit donc être à Off, mais vous n’aurez plus la traduction en hôte , délicat pour vos procédures de traçage des logs comme webalizer ou awstats ? Qu’à cela ne tienne : http://httpd.apache.org/docs/2.2/programs/logresolve.htmllogresolve est fait pour vous.

Dans votre fichier de configuration d’apache ,httpd.conf ,placez HostnameLookups à Off,et repérez votre fichier ou apache place ses logs d’entrées ,à savoir : access.log
saisissez ensuite : CustomLog /path/to/logs/access.log combined
Vérifiez que la première partie de chaque ligne correspond à l’adresse IP , c’est cette adresse qui sera traduite en nom d’hôte par logresolve à l’aide de la commande :
/path/to/logresolve -c < access.log > access_log.resolved le programme logresolve faisant partie d’Apache . Il faudra prévoir ici un certain temps de latence proportionnel à la longueur de votre fichier de logs . Ensuite il suffit de placer dans votre fichier de configuration de webalizer (ou autre analyseur de logs)
LogFile /home/deny/access_log.resolved sans oublier de relancer webalizer bien sûr .

Allowoveride

La directive AllowOverride all n’est valable que si un fichier .htaccess est placé dans le répertoire ou se trouve cette directive . Pour éviter qu’Apache ne cherche des fichiers .htaccess partout et soit sujet de ce fait à ralentissement ,placez cette directive à None partout ou il n’y a pas de fichiers .htaccess.

MaxClients

La directive MaxClients fixe la limite maximale des requêtes simultanées supportées par le serveur; Suivez la formule Total de la mémoire vive consacrée au serveur web / Taille maximale des processus fils.

KeepAlive et KeepAliveTimeout

La directive KeepAlive est utilisée dans le cas de requêtes persistantes. Cela sert pour des pages HTML avec beaucoup d’images. La surcharge causée par les connexions TCP persistantes peut être supprimée en fixant KeepAlive à On.
Fixez de même une valeur basse à KeepAliveTimeout qui définit la durée d’attente de la prochaine requête.

La compression gzip avec apache2

gzip se sert du module mod_deflate ,installé par défaut avec apache2, pour servir des pages compressées ,ce qui en diminue la taille et augmente donc la vitesse.
Ouvrez votre fichier httpd.conf et vérifiez que vous avez la configuration suivante:

#
# AddEncoding allows you to have certain browsers uncompress
# information on the fly. Note: Not all browsers support this.
# Despite the name similarity, the following Add* directives have nothing
# to do with the FancyIndexing customization directives above.
#

AddEncoding x-compress .Z
AddEncoding x-gzip .gz .tgz
# Ici sur les deux lignes enlever le caractère # pour activer le gZip Encoding.
# If the AddEncoding directives above are commented-out, then you
# probably should define those extensions to indicate media types:
AddType application/x-compress .Z
AddType application/x-gzip .gz .tgz
AddOutputFilterByType DEFLATE text/php text/HTML text/txt
#Ajouter cette ligne pour ne compresser au format gZip que les extensions de page HTML suivante : .php .html .txt

Pour vérifier que le navigateur charge bien la page compressée , comparez le poids de votre page dans le navigateur,et son poids dans votre répertoire personnel .

Le caching avec apache Utiliser le cache permet de stocker une partie des données chez le client ,ou bien sur un serveur proxy. La bande passante du serveur sera donc épargnée . Ceci peut être effectué avec les modules mod_expires et mod_headers
Ouvrez votre httpd.conf et vérifiez que les modules suivants sont activés :

LoadModule expires_module modules/mod_expires.so
LoadModule headers_module modules/mod_headers.so

Pour activer le cache de vos sites ,une manière simple est de cibler vos fichiers par leurs extensions.
Positionnez ExpiresActive à on.

ExpiresActive On
<directory “=”” home=”” website=”” public_html”=””>
Options FollowSymLinks MultiViews
AllowOverride All
Order allow,deny
Allow from all
ExpiresDefault A300
<filesmatch “.html$”=””>
expiresbyType text/html M604800

<filesmatch “.(gif|jpg|png|js|css)$”=””>
Expires A2592000
expiresbyType image/gif A2592000

ExpiresDefault A300 fixe le délai d’expiration par défaut à 300 secondes après l’accès (A). Si vous utilisez M300 , le délai d’expiration sera de 300 secondes après la modification du fichier. La directive FilesMatch fixe les en-têtes de contrôle du cache pour tout fichier .html à 604800 secondes après modification. La seconde section FilesMatch fixe les en-têtes pour les fichiers images, JavaScript et fichiers CSS à 2592000 secondes (30 jours).

Il existe aussi des outils comme httperf pour mesurer les performances du serveur : http://www.hpl.hp.com/research/linux/httperf/
Téléchargez l’archive et placez-la dans votre répertoire /usr/local Ensuite désarchivez-la avec

gunzip httperf-0.8.tar.gz
tar xvf httperf-0.8.tar

compilez en root avec

./configure
make
make install

Il est important de lancer un programme httperf par client , l’application étant gourmande en mémoire. Voici un test sur mon serveur

httperf –server linux-pour-lesnuls.com –port 80
httperf –client=0/1 –server=linux-pour-lesnuls.com –port=80 –uri=/ –send-buffer=4096 –recv-buffer=16384 –num-conns=1 –num-calls=1
Maximum connect burst length: 0
Total: connections 1 requests 1 replies 1 test-duration 0.057 s
Connection rate: 17.5 conn/s (57.3 ms/conn, <=1 concurrent connections)
Connection time [ms]: min 57.3 avg 57.3 max 57.3 median 57.5 stddev 0.0
Connection time [ms]: connect 0.3
Connection length [replies/conn]: 1.000
Request rate: 17.5 req/s (57.3 ms/req)
Request size [B]: 73.0
Reply rate [replies/s]: min 0.0 avg 0.0 max 0.0 stddev 0.0 (0 samples)
Reply time [ms]: response 53.5 transfer 3.4
Reply size [B]: header 278.0 content 26444.0 footer 2.0 (total 26724.0)
Reply status: 1xx=0 2xx=1 3xx=0 4xx=0 5xx=0

et pour un test plus poussé
httperf –server linux-pour-lesnuls.com –port 80 –num-conns 100 –rate 10 –timeout 1
httperf –timeout=1 –client=0/1 –server=linux-pour-lesnuls.com –port=80 –uri=/ –rate=10 –send-buffer=4096
–recv-buffer=16384 –num-conns=100 –num-calls=1
Maximum connect burst length: 1
Total: connections 100 requests 100 replies 95 test-duration 10.502 s
Connection rate: 9.5 conn/s (105.0 ms/conn, <=6 concurrent connections)
Connection time [ms]: min 24.0 avg 62.5 max 458.0 median 26.5 stddev 83.9
Connection time [ms]: connect 0.0
Connection length [replies/conn]: 1.000
Request rate: 9.5 req/s (105.0 ms/req)
Request size [B]: 73.0
Reply rate [replies/s]: min 9.4 avg 9.5 max 9.6 stddev 0.1 (2 samples)
Reply time [ms]: response 58.6 transfer 3.9
Reply size [B]: header 278.0 content 26444.0 footer 2.0 (total 26724.0)
Reply status: 1xx=0 2xx=95 3xx=0 4xx=0 5xx=0
CPU time [s]: user 1.08 system 8.90 (user 10.3% system 84.7% total 95.0%)
Net I/O: 236.7 KB/s (1.9*10^6 bps)
Errors: total 5 client-timo 5 socket-timo 0 connrefused 0 connreset 0
Errors: fd-unavail 0 addrunavail 0 ftab-full 0 other 0
La ligne correspondant à Total donne le résumé du nombre de connexions initiées par le client du nombre de requetes envoyées et recues , et de la durée du test .
La ligne suivante indique que le taux de connexion a été de 9.5 par seconde, ce taux corresponds à une période de 99.1 milliseconds par connection. au cours duquel 6 connexions ont été initiées simultanément .
Je vous laisse consulter la documentation pour une explication détaillée des lignes suivantes .

Sources de l’article

Installer le driver NVIDIA sous mandrake et debian

Installer le driver NVIDIA sous mandrake et debian

Installation sous mandrake

A priori il ne devrait pas y avoir de grosses diffï½ences pour d’autres configurations avec des cartes nvidia. Par contre pas besoin de tout ces changements pour mandrake 10.0… Seuls certains suffisent. Enfin pour ceux qui ont un pack mandrake, le driver est disponible en RPM.

L’installation de ces pilotes n’ est pas absolument obligatoire… Par exemple les drivers installï½s par dï½aut ne donnent pas la 3d mais pour une utilisation normale(sans 3d) ils sont bien.
– installer les souces du noyau (pour connaitre son noyau faire uname -r) :
#urpmi kernel-source
– rendre le fichier exï½cutable :
chmod 755 NVIDIA-Linux-x86-1.0-6111-pkg1.run
– extraire le driver :
./NVIDIA-Linux-x86-1.0-6111-pkg1.run -x
– dans le dossier crï½, ï½iter usr/src/nv/nv.c avec un ï½diteur de texte (kate ou kwrite par exemple) :
kate NVIDIA-Linux-x86-1.0-6111-pkg1/usr/src/nv/nv.c
remplaï½r PM_SAVE_STATE par (ï½ la ligne 3697) PM_SUSPEND_MEM
– quitter le mode graphique (en root) :
#init 3
– se replaï½r dans le dossier NVIDIA-Linux-x86-1.0-6111-pkg1 et installer le driver (accepter la licence, ne pas aller chercher de noyau sur le site nvidia) :
#./nvidia-installer
– si ï½ l’installation, nvidia dï½ecte un conflit (chez moi, conflit avec rivafb) enlever le module incriminï½ :
#modprobe -r rivafb
– rajouter nvidia dans /etc/modprobe.preload (apres nvidia-agp) par exemple en utilisant emacs :

#emacs /etc/modprobe.preload
faire les modifications puis Ctrl X Ctrl C puis y pour sauvegarder le fichier
– ï½iter le fichier : /etc/X11/xorg.conf avec emacs comme prï½cï½emment par exemple (plus de details dans le README de nvidia) :
dans la section device, remplaï½er Driver “nv” ou Driver “fbdev” par Driver “nvidia”
vï½ifier que dans la section Module il y ait : Load “glx”, sinon le rajouter
– charger le module nvidia :
#modprobe nvidia
– vï½rifier que le serveur x est ok :
$startx
– redï½arrer et vï½rifier que tout est ok
Normalement un ï½ran nvidia s’affiche brievement au dï½marrage de X (on peut aussi l’enlever (voir le READ ME). Ensuite, on peut modifier les paramï½res graphiques (en mode graphique) via la commande :
$nvidia-settings
L’ensemble des options disponibles pour configurer votre driver figure dans le README de nvidia qui aprï½s installation se trouve aussi dans : /usr/share/doc/NVIDIA_GLX-1.0

Installation sous debian

POUR LES CARTES TYPE GEFORCE

Le mode opï½atoire sous une Debian est sensiblement pareil. En effet, aprï½s avoir tï½ï½charger le fichier de pilotes nvidia, il suffit de la lancer.
[root@tuxbihan]$./NVIDIA-Linux-x86-1.0-4496-pkg2.run

Aprï½ avoir accepter la licence vous vous apercevez qua ucun noyau ne st disponible pour cette distribution et qui l va compiler les sources pour celle-ci.
Trï½s vite vous allez vous apercevoir qu il n a pas rï½ssi.
Pour information, les personnes qui ont compilï½es leurs noyau peuvent passer ï½la suite car les headers sont dï½jï½inclus dans le rï½pertoire de votre noyau. Penser tout de mï½e ï½ vï½ifier que votre lien symbolique est prï½sent 🙂

Solutions

Installer les kernel-header de votre distribution.
Pour cela taper uname -r pour voir la version de votre noyau :
Exemple :
[root@tuxbihan]$ uname -r
2.4.18-bf2.4
[root@tuxbihan]$
Installer les kernel header ï½la ide de la commande apt-get
[root@tuxbihan]$apt-get install kernel-headers-2.4.18-bf2.4
Cette commande permet di nstaller dans le rï½pertoire /usr/src les fichiers d entï½e nï½cessaire ï½la compilation de notre moyaut nvidia. Bien entendu installer les headers correpondant ï½ votre version de noyau !!
Une fois installer il faut crï½r un lien symbolic pointant vers ces fichiers ï½ l aide de la commande ln
[root@tuxbihan]$ cd /usr/src
[root@tuxbihan]$ ln -s /usr/src/kernel-headers-2.4.18-bf2.4 linux

Explications

il semblerait qu avec la debian les drivers nvidia ne trouve pas le rï½ertoire par dï½faut pour la compilation pour cela ln -s permet de crï½r une lien symbolic (lien qui va pointer vers le bon rï½pertoire).
Vï½ifions que lien ï½ bien ï½ï½ crï½
[root@tuxbihan]$ls
kernel-headers-2.4.18-bf2.4
linux
[root@tuxbihan]$
Ok tout est installer et pret pour un nouvel essai.
Relancer le script
[root@tuxbihan]$./NVIDIA-Linux-x86-1.0-4496-pkg2.run
Accepter les termes du contrat et cette fois ci vous devriez avoir une installation complï½te.
Relancer votre serveur grahique et apprï½ier la puissance de linux :))
POUR LES CARTES DE TYPE NFORCE/NFORCE2
Vous avez la possibilitï½ de rï½upï½rer le bon fichier source pour la compilation NVIDIA nforce
Les explications donnï½s avant sont identiques sauf que pour les nforces il faudra compiler vous mï½mes les sources ï½la ide des commandes.
[root@tuxbihan]$ ./configure
puis
[root@tuxbihan]$ make
et
[root@tuxbihan]$ make install
Cette solution est ï½ utiliser si vous avez un noyau de type 2.4.XX
Si vous avez compilï½votre noyau 2.6, vous aurez peut-ï½tre remarquï½qui l faut valider lo ption nforce.
Pour cela il faut rentrer dans le rï½pertoire ou vous avez installï½les sources
[root@tuxbihan]$ cd /usr/src/linux-2.6.XX/
[root@tuxbihan]$ make menuconfig
Rentrer dans le rï½pertoire “Character devices”
et activer l option NVIDIA nforce/nforce2
Enregistrer les modifications et compiler le noyau ï½la ide des commandes suivantes. Attention pour le noyau 2.6 vous avez des mise ï½ jour ï½effectuer et des paramï½tres ï½configurer !
[root@tuxbihan]$ make-kpkg clean
[root@tuxbihan]$ make-kpkg –initrd –revision=perso-2.6.4-1 kernel_image
lo ption –revision permet de nommer la version de votre compilation ce qui est bien pratique pour sy retrouver.
une fois compilï½ installï½votre nouveau noyau en faisant attention de ne pas ï½craser un noyau qui marche bien :))
[root@tuxbihan]$dkpg -i kernel-image-perso-2.6.4-1_i386.deb
L avantage est que la carte vidï½, la carte son et la carte rï½seau sont rï½onnus. Pour plus di nfo sur la compilation du noyau 2.6 sur Debian, voir le lien ici
Pour les heureux possï½sseurs de deux ï½rans, vous aurez la possbilitï½ d activer la deuxiï½e sortie par la configuration de votre votre XFree86. Pour plus di nfo voir mon article Configuration du n double ï½cran.
Pierre Le Mignant http://www.tuxbihan.org/article.php3?id_article=43

Installation sous mandriva 2007

Après avoir installé la mandriva 2007 il est possible que vous n’arriviez pas à tirer profit de la 3D avec votre carte NVIDIA
voici la marche à suivre :

va sur http://easyurpmi.zarb.org/ sélectionne ‘2007 officielle’, ‘i586’ (si c’est bien la version 32-bit que tu as installé), et ‘urpmi’.
Valide.
Coche les sources ‘plf-free’ et ‘plf-non-free’, sélectionne les serveurs free (ftp://ftp.free.fr/blabla) pour les 2.
Valide.
Sélectionne le code généré, et copie-le (control-c ou clic droit/copier)
Ouvre un terminal.
Tape su, et valide. Entre ton mot de passe administrateur, et valide.
Puis colle le texte copié sur le site d’easyurpmi. Ca doit ressembler à ça:

urpmi.addmedia plf-free
ftp://ftp.free.fr/pub/Distributions_Linux/plf/mandriva/2007.0/free/release/binary/i586/
with hdlist.cz
urpmi.addmedia plf-nonfree
ftp://ftp.free.fr/pub/Distributions_Linux/plf/mandriva/2007.0/non-free/release/binary/i586/
with hdlist.cz

Il doit mettre un p’tit moment à accepter tes entrées, et à télécharger les descriptions de sources.
tape urpmi kernel-source-stripped. Il te propose d’installer plein de trucs. Accepte. tape urpmi nvidia. Il te propose d’installer le paquetage nvidia et dkms-nvidia. Accepte.
Ca prend un moment pour télécharger, puis pour installer – il compile le pilote (en gros). S’il n’y a pas de message d’erreur, tape: init 3
X se ferme, et te met en mode ligne de commande. tape ‘root’ comme login, valide, et ton mot de passe root. Valide.
Tu as désormais accès à la ligne de commande. Tape nvidia-xconfig. Valide. Il te demande si tu es sûr de vouloir configurer. Accepte.
tape exactement:
init 5 & exit
valide.
Maintenant, tu vas dans le panneau de config de Mandriva, tu vas sur Matériel/3D, et il doit te permettre d’utiliser le bureau 3D.
Astuce donnée par Mitch sur la liste Mandriva-débutant

Sources de l’article