public ChassisID(PhysicalAddress MACAddress)
 {
     this.EmptyTLVDataInit();
     base.Type = TLVTypes.ChassisID;
     this.SubType = ChassisSubTypes.MACAddress;
     this.SubTypeValue = MACAddress;
 }

        internal NetworkList(NamedKey nk, byte[] bytes)
        {
            WriteTime = nk.WriteTime;

            foreach (ValueKey vk in nk.GetValues(bytes))
            {
                switch (vk.Name)
                {
                    case "ProfileGuid":
                        ProfileGuid = Encoding.Unicode.GetString(vk.GetData(bytes));
                        break;
                    case "Description":
                        Description = Encoding.Unicode.GetString(vk.GetData(bytes));
                        break;
                    case "Source":
                        Source = BitConverter.ToUInt32(vk.GetData(bytes), 0x00);
                        break;
                    case "DnsSuffix":
                        DnsSuffix = Encoding.Unicode.GetString(vk.GetData(bytes));
                        break;
                    case "FirstNetwork":
                        FirstNetwork = Encoding.Unicode.GetString(vk.GetData(bytes));
                        break;
                    case "DefaultGatewayMac":
                        DefaultGatewayMac = new PhysicalAddress(vk.GetData(bytes));
                        break;
                    default:
                        break;
                }
            }
        }

        private static void BroadcastMagicPacket(PhysicalAddress physicalAddress, IPAddress broadcastIPAddress)
        {
            if (physicalAddress == null) throw new ArgumentNullException(nameof(physicalAddress));

            var physicalAddressBytes = physicalAddress.GetAddressBytes();

            var packet = new byte[17 * 6];

            for (var i = 0; i < 6; i++)
            {
                packet[i] = 0xFF;
            }

            for (var i = 1; i <= 16; i++)
            {
                for (var j = 0; j < 6; j++)
                {
                    packet[i * 6 + j] = physicalAddressBytes[j];
                }
            }

            using (var client = new UdpClient())
            {
                client.Connect(broadcastIPAddress ?? IPAddress.Broadcast, 40000);
                client.Send(packet, packet.Length);
            }
        }

        public SlaacMITM(WinPcapDevice device, IList<Data.Attack> attacks)
        {
            this.device = device;
            this.attacks = attacks;

            invalidMac = PhysicalAddress.Parse("00-00-00-00-00-00");
        }

 public InvalidMacSpoofAttackIpv4Attack(Target t1, Target t2, AttackType attackType)
     : base(attackType)
 {
     invalidMac = PhysicalAddress.Parse("FA-BA-DA-FA-BA-DA".ToUpper());
     this.t1 = t1;
     this.t2 = t2;
 }

        private static void GetMacAddress(System.Net.IPAddress address, Action<PhysicalAddress> callback)
        {
            new Thread(() =>
            {
                try
                {
                    var destAddr = BitConverter.ToInt32(address.GetAddressBytes(), 0);

                    var srcAddr = BitConverter.ToInt32(System.Net.IPAddress.Any.GetAddressBytes(), 0);

                    var macAddress = new byte[6];

                    var macAddrLen = macAddress.Length;

                    var ret = SendArp(destAddr, srcAddr, macAddress, ref macAddrLen);

                    if (ret != 0)
                    {
                        throw new System.ComponentModel.Win32Exception(ret);
                    }

                    var mac = new PhysicalAddress(macAddress);

                    if (callback != null)
                        callback(mac);
                }
                catch
                {
                    //do nothing
                }
            })
            {
                IsBackground = true
            }.Start();
        }

        public static void LocalMacAndIPAddress( out byte[] ip, out PhysicalAddress mac )
        {
            ip = new byte[4];
            mac = PhysicalAddress.None;
            //get the interface
            NetworkInterface TrueNic = null;
            foreach ( NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces() )
            {
                if ( nic.OperationalStatus == OperationalStatus.Up )
                {
                    TrueNic = nic;
                    break;
                }
            }

            //get the interface ipv4
            foreach ( IPAddress ips in Dns.GetHostEntry( Environment.MachineName ).AddressList )
            {
                if ( ips.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork )
                {
                    ip = ips.GetAddressBytes();
                    break;
                }
            }
            //get the interface mac
            try
            {
                mac = PhysicalAddress.Parse(TrueNic.GetPhysicalAddress().ToString());
            }
            catch { }
        }

        /// <summary>
        /// Construct a new ethernet packet from source and destination mac addresses
        /// </summary>
        public EthernetPacket(PhysicalAddress SourceHwAddress,
                              PhysicalAddress DestinationHwAddress,
                              EthernetPacketType ethernetPacketType,
                              byte[] EthernetPayload)
        {
            int ethernetPayloadLength = 0;
            if (EthernetPayload != null)
            {
                ethernetPayloadLength = EthernetPayload.Length;
            }

            _bytes = new byte[EthernetFields_Fields.ETH_HEADER_LEN + ethernetPayloadLength];
            _ethernetHeaderLength = EthernetFields_Fields.ETH_HEADER_LEN;
            _ethPayloadOffset = _ethernetHeaderLength;

            // if we have a payload, copy it into the byte array
            if (EthernetPayload != null)
            {
                Array.Copy(EthernetPayload, 0, _bytes, EthernetFields_Fields.ETH_HEADER_LEN, EthernetPayload.Length);
            }

            // set the instance values
            this.SourceHwAddress = SourceHwAddress;
            this.DestinationHwAddress = DestinationHwAddress;
            this.EthernetProtocol = ethernetPacketType;
        }

        static void Main(string[] args)
        {
            try {
                dashMac = PhysicalAddress.Parse(Properties.Settings.Default.DashMac.Replace("-", "").Replace(":", "").ToUpper());
            } catch (Exception e) {
                if (!string.IsNullOrWhiteSpace(Properties.Settings.Default.DashMac)) {
                    Console.WriteLine("Error: Could not parse dash mac address: " + e.Message);
                    return;
                }
            }

            CaptureDeviceList devices = CaptureDeviceList.Instance;

            if (devices.Count < 1) {
                Console.WriteLine("No devices were found on this machine");
                return;
            }

            Console.WriteLine("The following devices are available on this machine:");
            for (int i = 0; i < devices.Count; i++) {
                ICaptureDevice dev = devices[i];
                Console.WriteLine($"{i}: {dev.Description}");
            }

            ICaptureDevice device = devices[Properties.Settings.Default.InterfaceIndex];
            device.OnPacketArrival += device_OnPacketArrival;
            device.Open(DeviceMode.Promiscuous, ReadTimeoutMilliseconds);
            device.StartCapture();
            Console.WriteLine($"-- Listening on {Properties.Settings.Default.InterfaceIndex}, hit 'Enter' to stop...");
            Console.ReadLine();
            device.StopCapture();
            device.Close();
        }

 public Connected(string name, string remarks, PhysicalAddress macAddress, IEnumerable<Command.Response.Device> roster)
 {
     Name = name;
     Remarks = remarks;
     MacAddress = macAddress;
     Roster = (roster ?? Enumerable.Empty<Command.Response.Device>()).ToArray();
 }

 public Router(WinPcapDevice dev, SynchronizedCollection<Data.Attack> attacks, SynchronizedCollection<string> slaacReqs)
 {
     this.device = dev;
     this.localPhysicalAddress = device.MacAddress;
     this.attacks = attacks;
     //this.slaacReqs = slaacReqs;
     this.dnsHijacking = new DNSHijacking(dev, attacks);
 }

        public BthDevice(IBthDevice device, PhysicalAddress master, byte lsb, byte msb)
            : base(new BthHandle(lsb, msb))
        {
            InitializeComponent();

            BluetoothDevice = device;
            HostAddress = master;
        }

 public MacRule(PacketStatus ps, PhysicalAddress mac, Direction direction, bool log, bool notify)
 {
     this.ps = ps;
     this.mac = mac.GetAddressBytes();
     this.direction = direction;
     this.log = log;
     this.notify = notify;
 }

        /// <summary>
        /// Sendet ein Wake-On-LAN-Signal an einen Client.
        /// </summary>
        /// <param name="target">Der Ziel-IPEndPoint.</param>
        /// <param name="macAddress">Die MAC-Adresse des Clients.</param>
        /// <exception cref="System.ArgumentNullException">macAddress ist null.</exception>
        /// <exception cref="System.Net.Sockets.SocketException">Fehler beim Zugriff auf den Socket. Weitere Informationen finden Sie im Abschnitt "Hinweise".</exception>
        public static void Send(IPEndPoint target, PhysicalAddress macAddress)
        {
            if (macAddress == null)
                throw new ArgumentNullException("macAddress");

            byte[] packet = GetWolPacket(macAddress.GetAddressBytes());
            SendPacket(target, packet);
        }

			/// <summary>
			/// Initializes a new instance of the <see cref="PacketDotNet.Ieee80211.CtsFrame"/> class.
			/// </summary>
			/// <param name='ReceiverAddress'>
			/// Receiver address.
			/// </param>
			public CtsFrame (PhysicalAddress ReceiverAddress)
			{
				this.FrameControl = new FrameControlField ();
                this.Duration = new DurationField ();
				this.ReceiverAddress = ReceiverAddress;
				
                this.FrameControl.SubType = FrameControlField.FrameSubTypes.ControlCTS;
			}

 public Registration(Command.Endpoint.IInstance commandEndpoint, Version version, string name, string remarks, PhysicalAddress macAddress)
 {
     CommandEndpoint = commandEndpoint;
     Version = version;
     Name = name;
     Remarks = remarks;
     MacAddress = macAddress;
 }

        public Host(PhysicalAddress mac, IPAddress ipAddress)
        {
            _mac = mac;
            _ipAddress = ipAddress;
            _hostname = _ipAddress.ToString();

            DnsRequests.Enqueue(Resolve);
        }

 internal NetworkDictionaryItem( IPAddress ipAddress, PingReply pingReply, PhysicalAddress macAddress, IPHostEntry hostEntry, IOS os )
 {
     _ipAddress = ipAddress;
     _pingReply = pingReply;
     _macAddress = macAddress;
     _hostEntry = hostEntry;
     _os = os;
     _ports = new ConcurrentDictionary<ushort,ushort>();
 }

		/// <summary>
		/// Creates a string from a Physical address in the format "xx:xx:xx:xx:xx:xx"
		/// </summary>
		/// <param name="address">
		/// A <see cref="PhysicalAddress"/>
		/// </param>
		/// <returns>
		/// A <see cref="System.String"/>
		/// </returns>
		public static string PrintMACAddress(PhysicalAddress address) {
			byte[] bytes = address.GetAddressBytes();
			string output = "";

			for (int i = 0; i < bytes.Length; i++) {
				output += bytes[i].ToString("x").PadLeft(2, '0') + ":";
			}
			return output.TrimEnd(':');
		}

        /// <summary>Sends a Wake On LAN signal (magic packet) to a client.</summary>
        /// <param name="target">Destination <see cref="IPEndPoint"/>.</param>
        /// <param name="macAddress">The MAC address of the designated client.</param>
        /// <param name="password">The SecureOn password of the client.</param>
        /// <exception cref="ArgumentNullException"><paramref name="macAddress"/> is null.</exception>
        /// <exception cref="SocketException">An error occurred when accessing the socket. See Remarks section of <see cref="UdpClient.Send(byte[], int, IPEndPoint)"/> for more information.</exception>
        public static void Send(IPEndPoint target, PhysicalAddress macAddress, SecureOnPassword password)
        {
            if (macAddress == null)
                throw new ArgumentNullException(nameof(macAddress));

            byte[] passwordBuffer = password?.GetPasswordBytes();
            byte[] packet = GetWolPacket(macAddress.GetAddressBytes(), passwordBuffer);
            SendPacket(target, packet);
        }