Comment envoyer un paquet WOL (ou quoi que ce soit) à travers un nic qui n'a pas d'adresse IP?

StackOverflow https://stackoverflow.com/questions/445411

Question

J'essaie d'envoyer un package WOL sur toutes les interfaces afin de réactiver la passerelle (qui est le serveur DHCP, de sorte que la machine n'aura pas encore d'adresse IP).

Et il semble que je ne peux lier que des sockets à des paires IP et port ...

La question est donc la suivante: comment créer un socket (ou autre chose) lié à une carte réseau sans adresse IP? (Toute langue est ok. C # est préférable)

@ctacke: Je sais que WOL est défini par l'adresse MAC ... Mon problème est que Windows n'envoie que les émissions UDP sur la carte réseau que Windows considère comme la carte principale (qui n'est même pas la carte réseau avec la route par défaut). ma machine Vista). Et je ne peux pas sembler trouver un moyen de lier un socket à une interface qui n'a pas d'adresse IP. (comme le font les clients DHCP)

@Arnout: Pourquoi pas? Les clients connaissent l'adresse MAC de la passerelle. Je veux juste envoyer un paquet WOL comme un client DHCP le fait initialement ... (Les paquets découverts par DHCP prétendent provenir de 0.0.0.0) Cela ne me dérange pas si je dois construire le paquet entier octet par octet ...

Était-ce utile?

La solution

Il semble que j'ai trouvé une solution. Winpcap peut être utilisé pour injecter des paquets sur n’importe quelle interface. Et il existe un bon wrapper pour .net: http://www.tamirgal.com /home/dev.aspx?Item=SharpPcap

(J'aurais préféré une solution ne nécessitant aucune bibliothèque supplémentaire à installer ...)

UPDATE: Voici ce que j'ai proposé d'envoyer un paquet WOL sur toutes les interfaces: 

//You need SharpPcap for this to work

private void WakeFunction(string MAC_ADDRESS)
{
    /* Retrieve the device list */
    Tamir.IPLib.PcapDeviceList devices = Tamir.IPLib.SharpPcap.GetAllDevices();

    /*If no device exists, print error */
    if (devices.Count < 1)
    {
        Console.WriteLine("No device found on this machine");
        return;
    }

    foreach (NetworkDevice device in devices)
    {
        //Open the device
        device.PcapOpen();

        //A magic packet is a broadcast frame containing anywhere within its payload: 6 bytes of ones
        //(resulting in hexadecimal FF FF FF FF FF FF), followed by sixteen repetitions 

        byte[] bytes = new byte[120];
        int counter = 0;
        for (int y = 0; y < 6; y++)
            bytes[counter++] = 0xFF;
        //now repeat MAC 16 times
        for (int y = 0; y < 16; y++)
        {
            int i = 0;
            for (int z = 0; z < 6; z++)
            {
                bytes[counter++] =
                    byte.Parse(MAC_ADDRESS.Substring(i, 2),
                    NumberStyles.HexNumber);
                i += 2;
            }
        }

        byte[] etherheader = new byte[54];//If you say so...
        var myPacket = new Tamir.IPLib.Packets.UDPPacket(EthernetFields_Fields.ETH_HEADER_LEN, etherheader);

        //Ethernet
        myPacket.DestinationHwAddress = "FFFFFFFFFFFFF";//it's buggy if you don't have lots of "F"s... (I don't really understand it...)
        try { myPacket.SourceHwAddress = device.MacAddress; }
        catch { myPacket.SourceHwAddress = "0ABCDEF"; }//whatever
        myPacket.EthernetProtocol = EthernetProtocols_Fields.IP;

        //IP
        myPacket.DestinationAddress = "255.255.255.255";
        try { myPacket.SourceAddress = device.IpAddress; }
        catch { myPacket.SourceAddress = "0.0.0.0"; }
        myPacket.IPProtocol = IPProtocols_Fields.UDP;
        myPacket.TimeToLive = 50;
        myPacket.Id = 100;
        myPacket.Version = 4;
        myPacket.IPTotalLength = bytes.Length - EthernetFields_Fields.ETH_HEADER_LEN;           //Set the correct IP length
        myPacket.IPHeaderLength = IPFields_Fields.IP_HEADER_LEN;

        //UDP
        myPacket.SourcePort = 9;                
        myPacket.DestinationPort = 9;           
        myPacket.UDPLength = UDPFields_Fields.UDP_HEADER_LEN;


        myPacket.UDPData = bytes;
        myPacket.ComputeIPChecksum();
        myPacket.ComputeUDPChecksum();

        try
        {
            //Send the packet out the network device
            device.PcapSendPacket(myPacket);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }

        device.PcapClose();
    }
}

Autres conseils

WOL se fait par MAC, pas par IP. Voici un exemple .

WOL est un protocole très flexible qui peut être mis en œuvre de différentes façons.

Les plus courantes sont les suivantes:

  • Envoi d'un fichier WOL en tant que charge utile d'un paquet Ethernet.
  • Envoi d'un fichier WOL en tant que charge utile d'un paquet UDP (pour le routage sur le réseau).

Une fois qu’il atterrit sur le réseau local, il est transmis à tous les hôtes du réseau à l’aide de l’adresse MAC de diffusion.

Pour un paquet Ethernet, la structure est la suivante:

  • MAC de destination: FF: FF: FF: FF: FF: FF (diffusion)
  • Une charge utile de paquet magique

Pour un paquet UDP, la structure est la suivante:

  • MAC de destination: FF: FF: FF: FF: FF: FF (diffusion)
  • Port UDP: 9
  • Une charge utile de paquet magique

La charge utile magique comprend:

  • Le flux de synchronisation: FFFFFFFFFFFF (c'est 6 paires ou 6 octets de FF)
  • 16 copies du MAC de l'ordinateur que vous signalez à WOL
  • Phrase secrète facultative de 0, 4 ou 6 octets.

Pour recevoir des paquets WOL d'Internet (via un pare-feu / routeur):

  • Configurez le port 9 du routeur pour qu’il soit transféré sur IP 255.255.255.255 (Broadcast IP)
  • Définir l'adresse IP de destination: adresse IP externe du routeur

Remarque: cela ne peut être réalisé qu'à l'aide de l'exemple UDP car les paquets Ethernet ne possèdent pas la couche IP nécessaire à leur routage via Internet. IE, les paquets Ethernet sont l’option réservée au réseau local. Le problème avec l'envoi de paquets WOL sur UDP est la sécurité, car vous devez configurer le routeur pour activer la diffusion IP (255.255.255.255). L'activation de la diffusion sur IP est généralement considérée comme une mauvaise idée en raison du risque accru d'attaque interne au sein du réseau (inondation Ping, usurpation de mémoire cache, etc.).

Pour plus d'informations sur le protocole, y compris un exemple de capture, voir ce site .

Si vous voulez un outil de ligne de commande rapide et sale qui génère des paquets WOL (et que vous utilisez une version de debian, linux mint ou Ubuntu), vous pouvez installer un outil qui le fait déjà.

Il suffit d'installer à l'aide de la ligne de commande avec: 

sudo apt-get install wakeonlan

Mise à jour:

Voici un exemple de travail qui génère un paquet WakeOnLan à l'aide de la version actuelle de SharpPcap. 

using System;
using System.Collections.Generic;
using System.Net.NetworkInformation;
using PacketDotNet;
using SharpPcap;

namespace SharpPcap.Test.Example9
{
    public class DumpTCP
    {
        public static void Main(string[] args)
        {
            // Print SharpPcap version
            string ver = SharpPcap.Version.VersionString;
            Console.WriteLine("SharpPcap {0}, Example9.SendPacket.cs\n", ver);

            // Retrieve the device list
            var devices = CaptureDeviceList.Instance;

            // If no devices were found print an error
            if(devices.Count < 1)
            {
                Console.WriteLine("No devices were found on this machine");
                return;
            }

            Console.WriteLine("The following devices are available on this machine:");
            Console.WriteLine("----------------------------------------------------");
            Console.WriteLine();

            int i = 0;

            // Print out the available devices
            foreach(var dev in devices)
            {
                Console.WriteLine("{0}) {1}",i,dev.Description);
                i++;
            }

            Console.WriteLine();
            Console.Write("-- Please choose a device to send a packet on: ");
            i = int.Parse( Console.ReadLine() );

            var device = devices[i];

            Console.Write("What MAC address are you sending the WOL packet to: ");
            string response = Console.ReadLine().ToLower().Replace(":", "-");

            //Open the device
            device.Open();

            EthernetPacket ethernet = new EthernetPacket(PhysicalAddress.Parse(
                "ff-ff-ff-ff-ff-ff"), PhysicalAddress.Parse("ff-ff-ff-ff-ff-ff"),
                EthernetPacketType.WakeOnLan);
            ethernet.PayloadPacket = new WakeOnLanPacket(
                PhysicalAddress.Parse(response));
            byte[] bytes = ethernet.BytesHighPerformance.Bytes;

            try
            {
                //Send the packet out the network device
                device.SendPacket(bytes);
                Console.WriteLine("-- Packet sent successfuly.");
            }
            catch(Exception e)
            {
                Console.WriteLine("-- "+ e.Message );
            }

            //Close the pcap device
            device.Close();
            Console.WriteLine("-- Device closed.");
            Console.Write("Hit 'Enter' to exit...");
            Console.ReadLine();
        }
    }
}

Remarque: Il s'agit d'une application de console d'envoi de paquets Wake-On-Lan entièrement fonctionnelle, construite sur Example09, disponible dans la source SharpPcap.

Les bibliothèques utilisées dans cet exemple qui ne peuvent pas être trouvées dans le framework .NET sont: 

using PacketDotNet;

Cette bibliothèque (.dll) est fournie avec SharpPcap. Il est responsable de l’ensemble de la construction et de l’analyse des paquets dans SharpPcap. C’est là que réside la classe WakeOnLan.

Remarque: le code de construction / analyse de paquet était initialement intégré à SharpPcap.dll. Il a été migré vers sa propre bibliothèque parce que SharpPcap est censé être un wrapper pour winpcap. Nombre de ses utilisateurs s’occupent de la conception de protocoles et / ou de la gestion de paquets réseau bruts. 

using SharpPcap;

SharpPcap contient tout le code wrapper winpcap (windows) / libpcap (* nix). Il est nécessaire de sélectionner l'interface et d'envoyer les paquets réels sur le fil.

.NET fonctionne comme une machine virtuelle (le CLR), il supprime donc une grande partie de la machine réelle sous-jacente. Par exemple, il fournit uniquement des interfaces pour les réseaux TCP et UDP, ce qui est beaucoup plus haut dans la pile de protocoles réseau que ce dont vous parlez. Vous pourrez peut-être trouver un composant tiers offrant un accès à une interface de niveau inférieur, mais je n’y compterais pas (j’ai déjà cherché .NET et Java).

Pour accéder à ce niveau bas de la pile de protocoles réseau, vous devrez probablement coder en C aux appels système correspondants du système d'exploitation. Vous pouvez trouver cela plus facile en Python et cette fonctionnalité peut-être déjà implémentée dans les bibliothèques Python ou tierces. Par exemple, je suggère de jeter un coup d'œil aux bibliothèques de réseaux Twisted. C’est l’une des raisons pour lesquelles je suis passé à Python pour une grande partie de mon travail.

Meilleurs voeux.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top