Lecture depuis un périphérique réseau

Je veux écrire en temps réel l'outil d'analyse de trafic sans fil.

Personne ne sait comment les lire à partir d'une promiscuité (ou sniffing) de l'appareil en C?

Je sais que vous avez besoin d'un accès root pour le faire. Je me demandais si quelqu'un sait quelles sont les fonctions nécessaires pour ce faire. Normal sockets ne font pas de sens ici.

source d'informationauteur jbleners

  1. 16

    Sur Linux que vous utilisez un PF_PACKET socket pour lire des données à partir d'un périphérique brut, comme une interface ethernet fonctionne en mode promiscuous: 

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

    Ce enverra une copie de chaque paquet reçu jusqu'à votre prise. Il est fort probable que vous n'avez pas vraiment envie de chaque paquet. Le noyau peut effectuer un premier niveau de filtrage à l'aide d'FPR, le Berkeley Packet Filter. BPF est essentiellement basée sur la pile de la machine virtuelle: il gère un petit ensemble d'instructions telles que: 

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

    FPR du code de sortie indique au noyau si vous voulez copier les paquets à la prise ou non. Il est possible d'écrire relativement petite FPR programmes directement, à l'aide de setsockopt(s, SOL_SOCKET, SO_ATTACH_FILTER, ). (AVERTISSEMENT: Le noyau prend une struct sock_fprog, pas une struct bpf_program, ne pas mélanger ceux-ci ou de votre programme de ne pas fonctionner sur certaines plates-formes).

    Pour quoi que ce soit assez 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 prendra soin de fractionnement d'un filtre complexe en deux parties, avec le noyau d'effectuer un premier niveau de filtrage et le plus capable de l'espace utilisateur code de déposer les paquets, il n'a pas vraiment envie de voir.

    libpcap également les résumés du noyau de l'interface de votre code d'application. Linux et BSD utilise la même Api, mais Solaris nécessite DLPI et Windows utilise autre chose.

  2. 7

    Une fois, j'ai eu à écouter sur les matières premières trames ethernet et a fini par créer un wrapper pour cela. Par l'appel de la fonction avec le nom de l'appareil, ex eth0 j'ai obtenu une prise en retour qui était en mode promiscuous.
    Ce que vous devez faire est de créer une socket raw et puis le 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;
}

    Puis, quand vous avez votre douille, vous pouvez simplement utiliser select pour gérer les paquets qu'ils arrivent.

  3. 2

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

  4. 0

    Pourquoi ne pas utiliser quelque chose comme WireShark?

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

  5. 0

    WireShark sur linux a la capacité de capturer le PLCP (physical layer convergence protocol) informations d'en-tête.