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

Bon Par4noiD, vous avait expliqué le scanning de port par ouverture de socket complète. Le problème avec ce type de scanning est qu'il est très facilement repéré 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 réponse de l'hôte 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 troisième, 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 méthode reste repérable mais pas avec les outils classique comme rtclog présenté 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 désavantage est l'obligation de la faire tourner en route car l'on doit construire ses paquet soit même.

Explication de la construction du paquet TCP.
Un paquet TCP est fait de la façon suivante :
0                                   15|16                                     31
|------------------------------------------------------------------------------|
| Numéro du port source (16 bits)     | Numéro du port de destination (16 bits)|
|------------------------------------------------------------------------------|
|                         numéro de séquence sur 32 bits                       |
|------------------------------------------------------------------------------|
|                       numéro d'acquittement sur 32 bits                      |
|------------------------------------------------------------------------------|
| longueur de l'entête 4| 6 | flags 6 |      taille de fenêtre sur 16-bits     |
|------------------------------------------------------------------------------|
|         checksum sur 16-bits        |        pointeur urgent sur 16-bits     |
|------------------------------------------------------------------------------|
|                          options (s'il y en a)                               |
|------------------------------------------------------------------------------|
|                          données (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 données urgentes dans le paquet)
ACK est la pour indique que le numéro d'acquittement est valide (numéro de
sequence du prochain paquet).
PUSH : pour que le gestionnaire réseau passe la trame le plus vite possible au
soft.
RST : réinitialise la connexion.
SYN : signal de synchronisation pour les numéro de séquence
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 numéro 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]