///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
                       Prog Anti-Scan TCP : proTecT U !
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
  
  C'est article nécessite les connaissances de base en prog c, notamment en prog c reseau. Tout ceux à qui ce savoir fait défaut peuvent consulter l'excellent, (nous ne répéterons jamais assez!), article de HotCode de NoRoute2.

  Ok, si j'ai décidé d'écrire cet article c'est parce qu'aujourd'hui beaucoup de hackers utilisent des scanners à connection complète (pour voir si tel ou tel port est ouvert, on tente une connection : si elle a lieu, on la coupe et on renvoie port open, si une erreur se produit à la connection c'est que le port est fermé).
  Ces types de scan sont tres largement répandu, à tort...ils reposent en effet  sur une connection complète et c'est bien là leur faiblesse!! Car en établissant une connection complète votre ordinateur permet à votre 'victime' de récupérer un tas d'info sur vous au travers d'une structure sin_addr.     
AtHACKons les explications techniques en observant d'abord le code c d'un scan tcp.

-----------------------------------CUT HERE------------------------------------- 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <netdb.h>
#include <arpa/inet.h>

struct in_addr resolve(char *name) {
  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; }

void main(int argc,char **argv) {

int sock;
struct sockaddr_in addr;
int port;
char *victim;
int rc;

victim=argv[1];

printf("Created by Par4noID and SLy (members of RtC)\n");
printf("This is a tOOl of RtC TecH\n"); 
 
addr.sin_family=AF_INET;
addr.sin_addr=resolve(victim);

 if (addr.sin_addr.s_addr==INADDR_NONE) { printf("Connection Problem\n") ;
exit(0); }

 for (port=1;port<=10000;port++) {

sock=socket(AF_INET,SOCK_STREAM,0);
addr.sin_port=htons(port);
rc=connect(sock,(struct sockaddr*)&addr,sizeof(addr));
close(sock);
 if (rc<0) { continue; }

 printf("PORT %3ld is openED\n",port) ; }

exit(0);
} 
-----------------------------------CUT HERE------------------------------------- 

Si vous avez bien compris le principe du scan tcp, vous n'aurez aucun mal à comprendre le code suivant, celui de mon anti-scan tcp. Pour l'utiliser taper 

bash$ RTClog 41             où 41 est le port que l'on écoute.   

Vous pouvez le tester en scannant votre machine par:

bash$ RTCscan localhost
 
Dans le mAg3, nous attaquerons les techniques scan/anti-scan SYN, pour enfin venir à bout de certains mythes, qui circulent sur les chats (et qui arrangent nos amis les V), comme par exemple le pseudo-anonymat des scans SYN.
 
 
-----------------------------------CUT HERE------------------------------------- 
/* Code c d'un anti-scan tcp */
/* Written by Par4noId, member of the g4ng RTC */
/* http://www.chez.com/rtcgang */
/* Cet outil est un prog de sécurité développé dans le cadre RTCtools */

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdio.h>

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

    const char *port; 
    int msock;

    /* on definit la socket de reception: celle qui va recevoir les infos sur 	l'agresseur */

    struct sockaddr_in sin;
    int lsin; 
  
    if (argc != 2) { 
        printf("RTClog numéro_du_port_que_l'on_ecoute\n"); 
        exit(1);
    }
 
    /* initialisation des variables */
    port = argv[1];
    lsin= sizeof(sin);

    /* affichage des infos pour la celebrite!! */

    printf("\nRTClog is a tOOl of RTCtech\n");
    printf("Written by Par4noID\n");
        
    msock = socket_passive (port,2); 

    /* le prog doit s'éxécuter en tache de fond. Pour ce faire on copie le 	 	 process par l'appel fork() puis on teste le résultat : si on est dans 	 le shell on sort. */

    if (fork() != 0) {
       exit(1);
    }

    /* on lance une boucle sans fin qui s'éxécutera en tache de fond car le                   process du shell est fini */

    while(1) {

        /* accept attend une connection, lorsque celle-ci se produit remplit la            structure sin dont on affiche le champ sin_addr (addresse IP de celui qui a établi la connection */

        accept(msock, (struct sockaddr *)&sin, &lsin);    

        /* on fait un appel system plutot que de se taper la prog xlib            correspondante!! */

        system("xmessage -center atHACK"); 
        printf("Scanning from: %s \n", inet_ntoa(sin.sin_addr));
    }
       
}


/* Code d'une fonction d'ouverture passive d'un port by Par4noID
   membre du g4ng RTC   */

int socket_passive (const char *port, int qlong) {

  /* Structure decrivant la socket que l'on ouvre*/
  struct sockaddr_in sin;
  int s;  

  /* Creation d'une socket tcp classique */
  s= socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (s<0) { 
     printf("erreur socket\n"); 
  } 

  /* On remplit la structure sockaddr_in correspondante pour établir une socket      passive*/

  sin.sin_family = AF_INET;
  sin.sin_port = htons(atoi(port));
  sin.sin_addr.s_addr = INADDR_ANY;

  /* On associe la socket au numero du port par la fonction bind */

  if ( bind (s, (struct sockaddr *)&sin, sizeof(sin)) < 0 ) {
     printf("Erreur dans l'allocation de port\n");
  }

  /* Reste a placer la socket en mode passif */

  if ( listen(s, qlong) < 0 ) {
     printf("Erreur dans la mise en place du mode passif\n");
  } 

  return s;

}
-----------------------------------CUT HERE------------------------------------- 

                                                                  Par4noID