Salut, j'ai une question sur ce morceau de code : http://www.binarytides.com/tcp-syn-portscan-in-c-with-linux-sockets/

Et plus précisément sur la fonction start_sniffer() :

int start_sniffer()
{
    int sock_raw;
     
    int saddr_size , data_size;
    struct sockaddr saddr;
     
    unsigned char *buffer = (unsigned char *)malloc(65536); //Its Big!
     
    printf("Sniffer initialising...\n");
    fflush(stdout);
     
    //Create a raw socket that shall sniff
    sock_raw = socket(AF_INET , SOCK_RAW , IPPROTO_TCP);
     
    if(sock_raw < 0)
    {
        printf("Socket Error\n");
        fflush(stdout);
        return 1;
    }
     
    saddr_size = sizeof saddr;
     
    while(1)
    {
        //Receive a packet
        data_size = recvfrom(sock_raw , buffer , 65536 , 0 , &saddr , &saddr_size);
         
        if(data_size <0 )
        {
            printf("Recvfrom error , failed to get packets\n");
            fflush(stdout);
            return 1;
        }
         
        //Now process the packet
        process_packet(buffer , data_size);
    }
     
    close(sock_raw);
    printf("Sniffer finished.");
    fflush(stdout);
    return 0;
}

Cette fonction est utilisée pour récupérer les paquets qui arrivent sur la machine

1. Comment ça marche ? comment on peut sniffer via un rawsocket? pourquoi il n'est pas obligé d'utiliser libpcap ?
2. Si on attrape un paquet via cette méthode, est ce que le programme qui était censé recevoir le paquet le recevra effectivement ? (ex : je suis un serveur web et je lance cette fonction, quand une requête arrive est ce qu'elle parviendra à apache ou mon programme l'aura "consommé" ? )

C'est la première fois que je vois cette méthode pour sniffer, c'est quoi le piège pour que tout le monde utilise libpcap habituellement ?

1. https://linux.die.net/man/7/raw
2. Oui
3. Aucun piège tu peux coder ton propre sniffer avec des raw socket et ensuite coder un export en format pcap.
la libpcap c'est juste pour éviter de réinventer la roue.

Si je me rappel bien, libpcap permet un accès de plus bas niveau vers la carte réseau que ne le permet les sockets bsd.
Il offre plus de possibilités pour le sniffing du flux réseau.