utilisation du mode promiscuité

Question

J'ai connecté 3 ordinateurs portables dans le même réseau local.

lap-1: 192.168.1.2
lap-2: 192.168.1.3
lap-3: 192.168.1.4

I fait lap-1 en tant que serveur et écouter sur le port 9333. lap-2 agit en tant que client. En utilisant netcat j'ai envoyé des données de lap2 à lap1. Je suis capable de capturer des paquets en utilisant pcap dans lap1. J'ai activé le mode promiscuous en utilisant sudo ifconfig eth0 promisc. Toujours dans la méthode pcap_live_open, j'ai défini un indicateur de mode de promiscuité. Puis j'ai désactivé le mode promiscuous et également la fonction pcap_live_open. Je suis toujours capable de capturer des paquets. J'ai recherché sur le mode de promiscuité et ce que je pourrais déduire était si le périphérique ouvre une interface en mode promiscuous il serait capable de capturer tous les paquets attachés à ce réseau. Donc, compte tenu de cela, j'ai fait le tour intérimaire 3 en tant que serveur et le tour 2 reste en tant que client. J'ai suivi la même procédure que ci-dessus. Je lance le pcap exécutable en lap-1 en espérant que je serais capable de capturer les paquets transférés entre lap-3 et lap-2 mais pcap en lap-1 n'est pas capable de le faire en mode promiscuous. Les 3 tours sont connectés au même réseau.

Quelqu'un peut-il m'éclairer l'utilisation du mode promiscuous avec scénario simple?

Ceci est mon code pcap: 29988 est inverse (échange) de 9333, je suis juste à la recherche de cela.

#include <pcap/pcap.h> 
#include <stdint.h> 

const u_char *packet; 

int main() 
{ 
    char *dev = "eth0"; 
    pcap_t *handle;   
    int j=0; 
    char errbuf[PCAP_ERRBUF_SIZE]; 
    struct bpf_program fp;  
    bpf_u_int32 mask;  
    bpf_u_int32 net;  
    struct pcap_pkthdr header; 
    uint8_t *ip_header_len; 
    uint16_t ip_header_len_val; 
    uint16_t *port; 

    /* Find the properties for the device */ 
    while (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) { 
     printf("Couldn't get netmask for device %s: %s\n", dev, errbuf); 
     net = 0; 
     mask = 0; 
    } 
    printf("lookedup pcap device: %s\n", dev); 

    /* Open the session in promiscuous mode */ 
    handle = pcap_open_live(dev, BUFSIZ,1,0, errbuf); 
    if (handle == NULL) { 
     printf("Couldn't open device %s: %s\n", dev, errbuf); 
    } 
    /* Compile and apply the filter */ 
    if (pcap_compile(handle, &fp, filter_exp, 0, net) == -1) { 
     printf("Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle)); 
     pcap_close(handle); 
    } 
    /*  if (pcap_setfilter(handle, &fp) == -1) { 

     printf("Couldn't install filter %s: %s", filter_exp, pcap_geterr(handle)); 
     return(-1); 
    } 
    */ 

    /* Grab a packet */ 
    while ((packet = pcap_next(handle, &header)) != NULL) 
    { 
     uint16_t *data_size; 
     uint16_t size,total_len_val,tcp_header_len_val; 
     char tdata[128];  
     uint8_t *data,*tcp_header_len; 
     uint16_t *total_len; 

     //ip_proto = (uint8_t *)&packet[9]; 
     ip_header_len = (uint8_t *)&packet[14]; 

     ip_header_len_val = (*ip_header_len) & 0x0F; 
     ip_header_len_val = ip_header_len_val*4; 
     // printf("IP header len val:%d\n",ip_header_len_val); 

     port = (uint16_t *)&packet[14+ip_header_len_val+2]; 
     //printf("port:%d\n",*port); 

     total_len = (uint16_t *)&packet[14+2]; 
     total_len_val = ((*total_len) >> 8) & 0x00FF; 
     total_len_val = total_len_val + (((*total_len) << 8) & 0xFF00); 
     //total_len_val=*total_len; 
     // printf("tot len val:%d\n",total_len_val); 
     tcp_header_len = (uint8_t *)&packet[14+ip_header_len_val+12]; 
     tcp_header_len_val = (*tcp_header_len) & 0xF0; 
     tcp_header_len_val = tcp_header_len_val>>4; 
     tcp_header_len_val = tcp_header_len_val * 4; 
     // printf("tcp header len val:%d\n",tcp_header_len_val); 
     size = (total_len_val- ip_header_len_val) - tcp_header_len_val; 


     data = (uint8_t *)&packet[14+ip_header_len_val+tcp_header_len_val]; 

     memset(tdata,0,128); 
     mempcpy(tdata,data,size); 
     tdata[size]='\0'; 
     if((*port)==29988) 
     {  
     printf("Data Packet:%s\n",tdata); 
     } 
    } 
} 

Answer 1

Je pense que quand vous dites qu'ils sont tous sur le même réseau, que ce que vous voulez dire qu'ils sont connectés au même commutateur Ethernet. Ce commutateur enverra uniquement des données à laptop1 qui est destiné à laptop1. Autrefois, quand il était courant d'utiliser un concentrateur Ethernet, tout le trafic allait à tous les appareils connectés, mais maintenant, un commutateur est très bon marché et les concentrateurs ne sont plus communs. Si vous pouvez trouver un concentrateur, vous pouvez l'essayer, mais dans le cas contraire, vous ne pourrez voir que le trafic destiné à votre appareil.

Answer 2

Comme Brad l'a mentionné, le routeur sait à quel port le périphérique destiné est connecté, de sorte qu'il n'envoie que les paquets. Si vous voulez essayer cela, vous pouvez utiliser VirtualBox ou VMware, et connecter les machines dans un réseau virtuel.