Winpcap simples pergunta - como enviar pacotes para uma ip / porta especificada?

Question

Eu li os tutoriais e assim, mas não estou conseguindo. Ele deixa você enviar pacotes, mas como você pode dizer Winpcap para onde enviar os pacotes? Há qualquer cabeçalho que eu deveria colocar nos pacotes assim ele vai saber para onde ip / porta de enviá-lo? Quero dizer. Vamos imaginar que eu quero para enviar alguns dados para o meu MSN, como se eu tivesse escreveu algo a alguém na minha lista. Eu posso usar o SendPacket (), mas ela só vai levar a matriz de pacotes / bytes como argumento, não especificando a que app / ip / porta então enviá-lo.

Graças

Answer 1

Você não diga Winpcap para onde enviar pacotes. Você diga a ele para colocar um pacote no fio. O switch de rede irá enviar o pacote para o destino certo. A pilha TCP no fim de recepção irá enviar o pacote para a aplicação / serviço certo. Obviamente, isso significa que o encaminhamento informação tem que ser no próprio pacote.

Para tomar o seu exemplo, você precisa colocar o endereço IP e porta TCP do servidor MSN apropriada no pacote. Se não o fizer, o seu hardware de rede irá descartar ou misroute esse pacote.

Answer 2

Isto é como eu enviou um pedido ARP sobre o fio. 1. Definir estruturas de protocolos ou seja, se você quiser enviar pacotes ARP você vai precisar de uma estrutura que irá conter a camada de enlace de dados (Ethernet cabeçalho) e camada de rede (ARP cabeçalho). Correspondentemente, se você quiser enviar um pacote TCP sobre IP que você vai precisar de uma estrutura de dados para o ethernet cabeçalho, cabeçalho IP e cabeçalho TCP.

1. Uma vez que você definiu as estruturas, inicializar uma instância da estrutura com os valores que você quer ou seja, se você quiser o pacote para ir para todas as máquinas na rede de definir o valor de destino MAC do Ethernet cabeçalho para ff: ff: ff: ff: ff: ff se você quiser enviar o pacote para máquina de X com (endereço IP 192.168.0.88) em seguida, definir o endereço de destino na camada IP para esse valor.

2. Uma vez feito você terá que declarar um char * array e copiar todas as estruturas para o char * array para criar uma seqüência de bytes e enviá-lo ao longo do fio.

// Só para mostrar o que eu quero dizer, definindo estruturas não // relacionam com o resto do trecho de código

typedef struct IP_header 
{
    u_char      VersionNInternetHeaderLength;       // Version (4 bits) + Internet header length (4 bits)
    /*u_char        version:4;
    u_char      HeaderLength:4;*/
    u_char      Type;                               // Type of service 
    u_short     TotalLength;                        // Total length 
    u_short     Identification;                     // Identification

    u_char      rsv     : 1;
    u_char      df      : 1;
    u_char      mf      : 1;

    u_char      FragmentOffset1 : 5;
    u_char      FragmentOffset2;
    //u_short       Flags_fo;                           // Flags (3 bits) + Fragment offset (13 bits)

    u_char      TimeToLive;                         // Time to live
    u_char      Protocol;                           // Next level Protocol of the encapsulated payload
    u_short     Checksum;                           // Header checksum
    IP_address  SourceAddress;                      // Source address
    IP_address  DestinationAddress;                 // Destination address
    u_int       OptionNPadding;                     // Option + Padding

    IP_header()
    {
        mf = 0;
        rsv = 0;
        df = 0;
        FragmentOffset1 = 0;
        FragmentOffset2 = 0;

        TimeToLive = 128;

        TotalLength = sizeof(IP_header);
        Identification = 0xABCD;
        Checksum = 0xABCD;
        OptionNPadding = 0;
    }
}IP_header;


Ethernet_header EthernetHeader;// = (Ethernet_header*)malloc(sizeof(Ethernet_header));
        ARP_header ARPHeader ;//= (ARP_header*)malloc(sizeof(ARP_header));

        ARPHeader.HardwareType = htons(1);
        ARPHeader.ProtocolType = htons(0x800);
        ARPHeader.OPCODE = htons(1);

        ARPHeader.HeaderLength = 6;
        ARPHeader.ProtocolLength = 4;

        ARPHeader.SenderMAC = MY_FAKE_MAC;
        ARPHeader.SenderIP = MY_IP;

        ARPHeader.TargetMAC = MAC_address();
        ARPHeader.TargetIP = Whose;

        EthernetHeader.DestinationMAC = BROADCASTMAC;
        EthernetHeader.SourceMAC = MY_FAKE_MAC;
        EthernetHeader.EtherType = htons(0x806);

        u_char* packet = (u_char*)malloc(sizeof(EthernetHeader) + sizeof(ARPHeader));

        memcpy(packet, &EthernetHeader, sizeof(EthernetHeader));
        memcpy(packet + sizeof(EthernetHeader), &ARPHeader, sizeof(ARPHeader));

        SendPacket(packet);