Lecture à partir d'un périphérique réseau à proximité

Question

Je souhaite créer un outil d'analyse en temps réel pour le trafic sans fil.

Est-ce que quelqu'un sait comment lire à partir d'un périphérique promiscuité (ou de détection) en C?

Je sais que vous devez avoir un accès root pour le faire. Je me demandais si quelqu'un savait quelles fonctions sont nécessaires pour le faire. Les prises normales ne semblent pas avoir de sens ici.

Answer 1

Sous Linux, vous utilisez un socket PF_PACKET pour lire les données d'un périphérique brut, tel qu'une interface Ethernet s'exécutant en mode proche:

s = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))

Ceci enverra des copies de chaque paquet reçu sur votre socket. Il est fort probable que vous ne souhaitiez pas vraiment tous les paquets, cependant. Le noyau peut effectuer un premier niveau de filtrage à l'aide de BPF, le Filtre Berkeley Packet . BPF est essentiellement une machine virtuelle basée sur une pile: elle gère un petit ensemble d'instructions telles que:

ldh = load halfword (from packet)  
jeq = jump if equal  
ret = return with exit code  

Le code de sortie de BPF indique au noyau de copier ou non le paquet dans le socket. Il est possible d'écrire directement des programmes BPF relativement petits, en utilisant setsockopt (s, SOL_SOCKET, SO_ATTACH_FILTER,). (ATTENTION: le noyau utilise une structure sock_fprog, et non une structure bpf_program, ne les mélangez pas sinon votre programme ne fonctionnera pas sur certaines plates-formes).

Pour tout ce qui est raisonnablement complexe, vous voulez vraiment utiliser libpcap. BPF est limité dans ce qu'il peut faire, en particulier dans le nombre d'instructions qu'il peut exécuter par paquet. libpcap se chargera de scinder un filtre complexe en deux parties, le noyau effectuant un premier niveau. du filtrage et du code d’espace utilisateur plus performant qui supprime les paquets qu’il ne souhaitait pas voir.

libpcap extrait également l'interface du noyau du code de votre application. Linux et BSD utilisent des API similaires, mais Solaris nécessite DLPI et Windows utilise autre chose.

Answer 2

Une fois, j’ai dû écouter sur des images Ethernet brutes et créer un wrapper pour cela. En appelant la fonction avec le nom de l’appareil, ex eth0 , j’ai eu une prise en retour qui était en mode promiscuous. Ce que vous devez faire est de créer une socket brute, puis de la mettre en mode promiscuous. Voici comment je l’ai fait.

int raw_init (const char *device)
{
    struct ifreq ifr;
    int raw_socket;

    memset (&ifr, 0, sizeof (struct ifreq));

    /* Open A Raw Socket */
    if ((raw_socket = socket (PF_PACKET, SOCK_RAW, htons (ETH_P_ALL))) < 1)
    {
        printf ("ERROR: Could not open socket, Got #?\n");
        exit (1);
    }

    /* Set the device to use */
    strcpy (ifr.ifr_name, device);

    /* Get the current flags that the device might have */
    if (ioctl (raw_socket, SIOCGIFFLAGS, &ifr) == -1)
    {
        perror ("Error: Could not retrive the flags from the device.\n");
        exit (1);
    }

    /* Set the old flags plus the IFF_PROMISC flag */
    ifr.ifr_flags |= IFF_PROMISC;
    if (ioctl (raw_socket, SIOCSIFFLAGS, &ifr) == -1)
    {
        perror ("Error: Could not set flag IFF_PROMISC");
        exit (1);
    }
    printf ("Entering promiscuous mode\n");

    /* Configure the device */

    if (ioctl (raw_socket, SIOCGIFINDEX, &ifr) < 0)
    {
        perror ("Error: Error getting the device index.\n");
        exit (1);
    }

    return raw_socket;
}

Ensuite, lorsque vous avez votre socket, vous pouvez simplement utiliser select pour gérer les paquets au fur et à mesure qu'ils arrivent.

Answer 3

Vous pouvez utiliser la bibliothèque pcap (voir http://www.tcpdump.org/pcap.htm ) qui est également utilisé par tcpdump et Wireshark.

Answer 4

Pourquoi n'utiliseriez-vous pas quelque chose comme WireShark ?

Il est open source, vous pouvez donc au moins en apprendre quelques choses si vous ne voulez pas simplement l'utiliser.

Answer 5

WireShark sur Linux a la capacité de capturer les informations d'en-tête PLCP (protocole de convergence de couche physique).