public DhcpPacket Deserialize(byte[] data) { int packetLength = data.Length; DhcpPacket result = new DhcpPacket(); using (MemoryStream stm = new MemoryStream(data)) using (BinaryReader rdr = new BinaryReader(stm)) { result.Op = rdr.ReadByte(); result.HType = rdr.ReadByte(); result.HLen = rdr.ReadByte(); result.Hops = rdr.ReadByte(); result.XID = rdr.ReadBytes(4); result.Secs = rdr.ReadBytes(2); result.Flags = rdr.ReadBytes(2); result.CIAddr = rdr.ReadBytes(4); result.YIAddr = rdr.ReadBytes(4); result.SIAddr = rdr.ReadBytes(4); result.GIAddr = rdr.ReadBytes(4); result.CHAddr = rdr.ReadBytes(16); result.SName = rdr.ReadBytes(64); result.File = rdr.ReadBytes(128); result.Cookie = rdr.ReadBytes(4); result.Options = rdr.ReadBytes(packetLength - OPTION_OFFSET); } return(result); }
public void DiscoveryOptions_Expect_MessageTypeOfDiscover() { DhcpPacket discoveryPacket = DhcpFakes.FakeDhcpDiscoverPacket(); var sut = _messagerSerializer.ToMessage(discoveryPacket); Assert.Equal(DhcpMessageType.Discover, sut.DhcpMessageType); }
private void SendNotification(DhcpPacket packet) { var factory = new ConnectionFactory() { HostName = string.IsNullOrEmpty(configuration.MessageQueueHost) ? "localhost" : configuration.MessageQueueHost, UserName = configuration.MessageQueueUserName, Password = configuration.MessageQueuePassword }; using (var connection = factory.CreateConnection()){ using (var channel = connection.CreateModel()) { channel.ExchangeDeclare(exchange: configuration.MessageQueueExchangeName, type: "fanout"); string message = BuildMessage(packet); var body = Encoding.UTF8.GetBytes(message); channel.BasicPublish(exchange: string.IsNullOrEmpty(configuration.MessageQueueExchangeName) ? "": configuration.MessageQueueExchangeName, routingKey: "", basicProperties: null, body: body); } } }
public void DiscoveryOptions_Expect_CorrectHostName() { DhcpPacket discoveryPacket = DhcpFakes.FakeDhcpDiscoverPacket(); var sut = _messagerSerializer.ToMessage(discoveryPacket); Assert.Equal("SpeedwayR-11-7A-3C", sut.HostName); }
public void ShouldParseDhcpDiscover() { using (var stream = new FileStream(pathToBinFiles + "dhcpdiscover.bin", FileMode.Open, FileAccess.Read)) using (var reader = new BinaryReader(stream)) { var bytes = reader.ReadBytes((int)stream.Length); DhcpPacket packet = new DhcpPacket(bytes); Assert.Equal(1, packet.BootPMessageType); Assert.Equal(HardwareType.Ethernet, packet.HType); Assert.Equal(6, packet.HLen); Assert.Equal(0, packet.Hops); Assert.Equal(0x9d2b3df6, packet.XId); Assert.Equal(0, packet.Secs); Assert.Equal(0x8000, packet.BootPFlags); Assert.Equal(IPAddress.Any, packet.CIAddr); Assert.Equal(IPAddress.Any, packet.YIAddr); Assert.Equal(IPAddress.Any, packet.GIAddr); Assert.Equal(IPAddress.Any, packet.SIAddr); var physAddressExpected = new byte[] { 0xf4, 0xf5, 0xa5, 0x83, 0x2d, 0x16 }; var physAddressActual = packet.CHAddrTruncated; Assert.Equal(new List <byte>(physAddressExpected), new List <byte>(physAddressActual.GetAddressBytes())); Assert.Equal(string.Empty, packet.ServerName); Assert.Equal(string.Empty, packet.BootFileName); Assert.True(packet.IsActualDhcp); Assert.Equal(5, packet.Options.Count); Assert.Equal(DhcpMessageType.Discover, packet.GetDhcpMessageType()); } }
private static byte[] buildDhcpPayload() { // Create optional payload bytes that can be added to the main payload. DhcpOption dhcpServerIdentifierOption = new DhcpOption() { optionId = dhcpOptionIds.DhcpMessageType, optionLength = new byte[] { 0x01 }, optionValue = new byte[] { 0x03 }, }; DhcpOption dhcpRequestedIpAddressOption = new DhcpOption() { optionId = dhcpOptionIds.RequestedIpAddress, optionLength = new byte[] { 0x04 }, optionValue = IPAddress.Parse("192.168.178.101").GetAddressBytes(), }; // Create the main payload of the dhcp-packet and add the options to it. DhcpPacket dhcpDiscoveryPacket = new DhcpPacket() { transactionID = new byte[] { 0x00, 0x00, 0x00, 0x00 }, dhcpOptions = dhcpServerIdentifierOption.buildDhcpOption().Concat(dhcpRequestedIpAddressOption.buildDhcpOption()).ToArray(), }; return(dhcpDiscoveryPacket.buildPacket()); }
public void Serialize(BinaryWriter writer, DhcpPacket packet) { writer.Write(packet.Op); writer.Write(packet.HType); writer.Write(packet.HLen); writer.Write(packet.Hops); writer.Write(packet.XID); byte[] secsBytes = new byte[2]; packet.Secs.CopyTo(secsBytes, 0); writer.Write(secsBytes); byte[] flagBytes = new byte[2]; packet.Flags.CopyTo(flagBytes, 0); writer.Write(flagBytes); writer.Write(packet.CIAddr); writer.Write(packet.YIAddr); writer.Write(packet.SIAddr); writer.Write(packet.GIAddr); writer.Write(packet.CHAddr); byte[] snameBytes = new byte[64]; writer.Write(snameBytes); byte[] fileBytes = new byte[128]; writer.Write(fileBytes); writer.Write(GetDhcpMagicNumber()); writer.Write(packet.Options); }
/// <summary>This is used to process a dhcp packet on the node side, that /// includes placing data such as the local Brunet Address, Ipop Namespace, /// and other optional parameters in our request to the dhcp server. When /// receiving the results, if it is successful, the results are written to /// the TAP device.</summary> /// <param name="ipp"> The IPPacket that contains the Dhcp Request</param> /// <param name="dhcp_params"> an object containing any extra parameters for /// the dhcp server</param> /// <returns> true on if dhcp is supported.</returns> protected virtual bool HandleDhcp(IPPacket ipp) { UdpPacket udpp = new UdpPacket(ipp.Payload); DhcpPacket dhcp_packet = new DhcpPacket(udpp.Payload); MemBlock ether_addr = dhcp_packet.chaddr; if (_dhcp_config == null) { return(true); } DhcpServer dhcp_server = CheckOutDhcpServer(ether_addr); if (dhcp_server == null) { return(true); } MemBlock last_ip = null; _ether_to_ip.TryGetValue(ether_addr, out last_ip); byte[] last_ipb = (last_ip == null) ? null : (byte[])last_ip; WaitCallback wcb = delegate(object o) { ProtocolLog.WriteIf(IpopLog.DhcpLog, String.Format( "Attempting Dhcp for: {0}", Utils.MemBlockToString(ether_addr, '.'))); DhcpPacket rpacket = null; try { rpacket = dhcp_server.ProcessPacket(dhcp_packet, AppNode.Node.Address.ToString(), last_ipb); } catch (Exception e) { ProtocolLog.WriteIf(IpopLog.DhcpLog, e.Message); CheckInDhcpServer(dhcp_server); return; } /* Check our allocation to see if we're getting a new address */ MemBlock new_addr = rpacket.yiaddr; UpdateMapping(ether_addr, new_addr); MemBlock destination_ip = ipp.SourceIP; if (destination_ip.Equals(IPPacket.ZeroAddress)) { destination_ip = IPPacket.BroadcastAddress; } UdpPacket res_udpp = new UdpPacket(_dhcp_server_port, _dhcp_client_port, rpacket.Packet); IPPacket res_ipp = new IPPacket(IPPacket.Protocols.Udp, rpacket.siaddr, destination_ip, res_udpp.ICPacket); EthernetPacket res_ep = new EthernetPacket(ether_addr, EthernetPacket.UnicastAddress, EthernetPacket.Types.IP, res_ipp.ICPacket); Ethernet.Send(res_ep.ICPacket); CheckInDhcpServer(dhcp_server); }; ThreadPool.QueueUserWorkItem(wcb); return(true); }
public void DiscoveryOptions_Expect_CorrectClientHAddr() { DhcpPacket discoveryPacket = DhcpFakes.FakeDhcpDiscoverPacket(); var sut = _messagerSerializer.ToMessage(discoveryPacket); PhysicalAddress expeced = new PhysicalAddress(new byte[] { 0, 22, 37, 17, 122, 60 }); Assert.Equal(expeced, sut.ClientHardwareAddress); }
public void DiscoveryCIAddr_Expect_CorrectClientIP() { DhcpPacket discoveryPacket = DhcpFakes.FakeDhcpDiscoverPacket(); discoveryPacket.CIAddr = new byte[] { 0, 0, 0, 0 }; var sut = _messagerSerializer.ToMessage(discoveryPacket); Assert.Equal("0.0.0.0", sut.ClientIPAddress.ToString()); }
public static byte[] GetBytes(this DhcpPacket packet, IDhcpPacketSerializer serializer) { using (MemoryStream ms = new MemoryStream()) using (BinaryWriter br = new BinaryWriter(ms)) { serializer.Serialize(br, packet); return(ms.ToArray()); } }
public void DiscoveryOptions_Expect_CorrectXID() { DhcpPacket discoveryPacket = DhcpFakes.FakeDhcpDiscoverPacket(); discoveryPacket.XID = new byte[] { 0x19, 0xe1, 0x79, 0x50 }; var sut = _messagerSerializer.ToMessage(discoveryPacket); var expectedHex = "19e17950"; Assert.Equal(expectedHex, sut.TransactionId.ToString("x4")); }
/// <summary></summary> public DhcpPacket ProcessPacket(DhcpPacket packet, string unique_id, byte[] last_ip, params object[] dhcp_params) { DhcpPacket.MessageTypes message_type = (DhcpPacket.MessageTypes) packet.Options[DhcpPacket.OptionTypes.MESSAGE_TYPE][0]; byte[] requested_ip = last_ip; bool renew = false; if (message_type == DhcpPacket.MessageTypes.DISCOVER) { message_type = DhcpPacket.MessageTypes.OFFER; } else if (message_type == DhcpPacket.MessageTypes.REQUEST) { if (packet.Options.ContainsKey(DhcpPacket.OptionTypes.REQUESTED_IP)) { requested_ip = packet.Options[DhcpPacket.OptionTypes.REQUESTED_IP]; } else if (!packet.ciaddr.Equals(IPPacket.ZeroAddress)) { requested_ip = packet.ciaddr; } renew = true; message_type = DhcpPacket.MessageTypes.ACK; } else { throw new Exception("Unsupported message type!"); } byte[] reply_ip = RequestLease(requested_ip, renew, unique_id, dhcp_params); Dictionary <DhcpPacket.OptionTypes, MemBlock> options = new Dictionary <DhcpPacket.OptionTypes, MemBlock>(); if (OSDependent.OSVersion == OSDependent.OS.Windows) { options[DhcpPacket.OptionTypes.DOMAIN_NAME] = Encoding.UTF8.GetBytes(Dns.DomainName); //The following option is needed for dhcp to "succeed" in Vista, but they break Linux //options[DhcpPacket.OptionTypes.ROUTER] = reply.ip; options[DhcpPacket.OptionTypes.DOMAIN_NAME_SERVER] = MemBlock.Reference(ServerIP); } options[DhcpPacket.OptionTypes.SUBNET_MASK] = MemBlock.Reference(Netmask); options[DhcpPacket.OptionTypes.LEASE_TIME] = _lease_time; options[DhcpPacket.OptionTypes.MTU] = _mtu; options[DhcpPacket.OptionTypes.SERVER_ID] = MemBlock.Reference(ServerIP); options[DhcpPacket.OptionTypes.MESSAGE_TYPE] = MemBlock.Reference(new byte[] { (byte)message_type }); DhcpPacket rpacket = new DhcpPacket(2, packet.xid, packet.ciaddr, reply_ip, ServerIP, packet.chaddr, options); return(rpacket); }
private DhcpPacket SetClientHardwareAddressFields(DhcpPacket packet, DhcpMessage message) { var addressBytes = message.ClientHardwareAddress.GetAddressBytes(); var addressLength = addressBytes.Length; byte[] chAddressArray = new byte[16]; addressBytes.CopyTo(chAddressArray, 0); packet.CHAddr = chAddressArray; packet.HLen = (byte)addressLength; return(packet); }
public static DhcpPacket FakeDhcpDiscoverPacket() { DhcpPacket packet = new DhcpPacket { CHAddr = new byte[] { 0, 22, 37, 17, 122, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, Op = 0x01, HType = 0x01, HLen = 0x06, Hops = 0x00, XID = new byte[] { 137, 168, 215, 101 }, Secs = new byte[] { 0, 0 }, Flags = new byte[] { 0, 0 }, CIAddr = new byte[] { 0, 0, 0, 0 }, YIAddr = new byte[] { 0, 0, 0, 0 }, SIAddr = new byte[] { 0, 0, 0, 0 }, GIAddr = new byte[] { 0, 0, 0, 0 }, File = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, Cookie = new byte[] { 99, 130, 83, 99 }, Options = new byte[] { 53, 1, 1, 12, 18, 83, 112, 101, 101, 100, 119, 97, 121, 82, 45, 49, 49, 45, 55, 65, 45, 51, 67, 55, 8, 12, 1, 28, 3, 15, 6, 42, 2, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }; return(packet); }
private DhcpMessage ParseRequest(DhcpData dhcpData, IDhcpPacketSerializer pSerializer, IDhcpMessageSerializer mSerializer) { DhcpPacket packet = pSerializer.Deserialize(dhcpData.MessageBuffer); DhcpMessage message; try { message = mSerializer.ToMessage(packet); } catch (Exception ex) { Log.Error($"Error Parsing Dhcp Message {ex.Message}"); throw; } return(message); }
private string BuildMessage(DhcpPacket packet) { var deviceName = packet.GetHostName(); var ip = packet.GetClientIp(); var mac = packet.GetClientMac(); var message = new { DeviceName = deviceName, DeviceIpAddress = ip == null ? string.Empty: ip.ToString(), DeviceMacAddress = mac == null ? string.Empty : mac.ToString(), TimeStamp = DateTime.UtcNow, DetectedBy = configuration.SensorName }; return(JsonConvert.SerializeObject(message)); }
private static byte[] buildDhcpPayload() { // Create optional payload bytes that can be added to the main payload. DhcpOption dhcpMessageTypeOption = new DhcpOption() { optionId = dhcpOptionIds.DhcpMessageType, optionLength = new byte[] { 0x01 }, optionValue = new byte[] { 0x01 }, }; // Create the main payload of the dhcp-packet and add the options to it. DhcpPacket dhcpDiscoveryPacket = new DhcpPacket() { transactionID = new byte[] { 0x00, 0x00, 0x00, 0x00 }, dhcpOptions = dhcpServerIdentifierOption.buildDhcpOption().ToArray(), }; return(dhcpDiscoveryPacket.buildPacket()); }
public DhcpPacket ToPacket(DhcpMessage message, byte[] options) { DhcpPacket packet = new DhcpPacket { Op = (byte)message.OperationCode, HType = (byte)message.HardwareType, Hops = (byte)message.Hops, XID = BitConverter.GetBytes(message.TransactionId).ReverseArray(), Secs = BitConverter.GetBytes(message.SecondsElapsed), Flags = BitConverter.GetBytes(message.Flags), CIAddr = message.ClientIPAddress.GetAddressBytes(), YIAddr = message.YourIPAddress.GetAddressBytes(), SIAddr = message.ServerIPAddress.GetAddressBytes(), GIAddr = message.GatewayIPAddress.GetAddressBytes(), Options = options }; packet = SetClientHardwareAddressFields(packet, message); return(packet); }
private static byte[] buildDhcpReleasePacket(IPAddress pClientIpAddress, PhysicalAddress pClientHwAddress, IPAddress pDestinationIpAddress) { Random rand = new Random(); byte[] _transactionID = new byte[4]; rand.NextBytes(_transactionID); DhcpOption dhcpMessageTypeOption = new DhcpOption() { optionId = dhcpOptionIds.DhcpMessageType, optionLength = new byte[] { 0x01 }, optionValue = new byte[] { 0x07 }, }; DhcpOption dhcpServerIdOption = new DhcpOption() { optionId = dhcpOptionIds.ServerIdentifier, optionLength = new byte[] { 0x04 }, optionValue = pDestinationIpAddress.GetAddressBytes(), }; DhcpOption clientIdOption = new DhcpOption() { optionId = dhcpOptionIds.ClientIdentifier, optionLength = new byte[] { 0x04 }, optionValue = pClientIpAddress.GetAddressBytes(), }; byte[] options = dhcpMessageTypeOption.buildDhcpOption().Concat(dhcpServerIdOption.buildDhcpOption()).Concat(clientIdOption.buildDhcpOption()).ToArray(); DhcpPacket dhcpReleasePacket = new DhcpPacket() { transactionID = _transactionID, clientIP = pClientIpAddress.GetAddressBytes(), clientMac = pClientHwAddress.GetAddressBytes(), dhcpOptions = options, }; return(dhcpReleasePacket.buildPacket()); }
private async Task SendReply(DhcpPacket packet) { try { var response = packet.GetBytes(PacketSerializer); using (UdpClient client = new UdpClient()) { IPEndPoint endPoint = new IPEndPoint(IPAddress.Broadcast, DHCP_CLIENT_PORT); client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1); client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontRoute, 1); await client.SendAsync(response, response.Length, endPoint) .ConfigureAwait(false); } } catch (Exception ex) { Log.Error($"Error sending Dhcp reply: {ex.Message}"); throw; } }
public DhcpMessage ToMessage(DhcpPacket packet) { DhcpOptionParser parser = new DhcpOptionParser(); DhcpMessage result = new DhcpMessage { OperationCode = (DhcpOperation)packet.Op, HardwareType = (HardwareType)packet.HType, HardwareAddressLength = packet.HLen, Hops = packet.Hops, TransactionId = BitConverter.ToInt32(packet.XID.Reverse().ToArray(), 0), SecondsElapsed = BitConverter.ToUInt16(packet.Secs, 0), Flags = BitConverter.ToUInt16(packet.Flags, 0), ClientIPAddress = new IPAddress(packet.CIAddr), YourIPAddress = new IPAddress(packet.YIAddr), ServerIPAddress = new IPAddress(packet.SIAddr), GatewayIPAddress = new IPAddress(packet.GIAddr), ClientHardwareAddress = new PhysicalAddress(packet.CHAddr.Take(packet.HLen).ToArray()), File = packet.File, Cookie = packet.Cookie, Options = parser.GetOptions(packet.Options) }; return(result); }
public async Task StartAsyncReadData(CancellationToken cancellationToken) { logger.Info("TAP started"); while (!cancellationToken.IsCancellationRequested) { try { var buffer = new byte[4096]; var readBytes = await tapStream.ReadAsync(buffer, 0, 4096, cancellationToken); if (readBytes <= 0) { continue; } var p = EthernetPacket.Parse(buffer.Take(readBytes).ToArray()); if (p.DestinationAddress.GetAddressBytes().Take(3).SequenceEqual(new byte[] { 0x01, 0x00, 0x5E })) { continue; } // ReSharper disable once SwitchStatementMissingSomeCases switch (p.Type) { case EthernetPacket.PacketType.IpV4: { var intId = GetIdFromPhysicalAddress(p.DestinationAddress); if (intId >= 0) { if (HostExists((ushort)intId) || intId == selfId) { await Send(p.Payload, (ushort)intId); } continue; } var ipPacket = (IPv4Packet)p.PayloadPacket; switch (intId) { case -ipMacPoolShift: { if (ipPacket.PayloadPacket is UdpPacket udpPacket && udpPacket.PayloadPacket is DhcpPacket dhcpPacket) { if (dhcpPacket.Op != 1) { continue; } var dhcpMessageType = dhcpPacket.Options.ContainsKey(53) && dhcpPacket.Options[53].Length > 0 ? dhcpPacket.Options[53][0] : -1; DhcpPacket answerDhcpPacket; switch (dhcpMessageType) { case 1: // DHCPDISCOVER answerDhcpPacket = new DhcpPacket { Xid = dhcpPacket.Xid, YourIpAddress = GetIpFromId(selfId), ServerIpAddress = GetIpFromId(-1), ClientHardwareAddress = dhcpPacket.ClientHardwareAddress, Options = new Dictionary <byte, byte[]> { { 53, new byte[] { 2 } }, { 1, new byte[] { 255, 255, 0, 0 } }, { 51, BitConverter.GetBytes(30 * 60).Reverse().ToArray() }, { 54, GetIpFromId(-1).GetAddressBytes() }, { 6, GetIpFromId(-1).GetAddressBytes() } } }; break; case 3: // DHCPREQUEST answerDhcpPacket = new DhcpPacket { Xid = dhcpPacket.Xid, YourIpAddress = GetIpFromId(selfId), ServerIpAddress = GetIpFromId(-1), ClientHardwareAddress = dhcpPacket.ClientHardwareAddress, Options = new Dictionary <byte, byte[]> { { 53, new byte[] { 5 } }, { 1, new byte[] { 255, 255, 0, 0 } }, { 51, BitConverter.GetBytes(30 * 60).Reverse().ToArray() }, { 54, GetIpFromId(-1).GetAddressBytes() }, { 6, GetIpFromId(-1).GetAddressBytes() } } }; break; default: continue; } var answerIpV4Packet = new IPv4Packet(GetIpFromId(-1), IPAddress.Broadcast); answerIpV4Packet.SetPayloadPacket(new UdpPacket(67, 68, answerDhcpPacket, answerIpV4Packet)); var answerEthernetPacket = new EthernetPacket( GetPhysicalAddressFromId(-1), p.SourceAddress, answerIpV4Packet, EthernetPacket.PacketType.IpV4); var answerData = answerEthernetPacket.ToBytes(); await tapStream.WriteAsync(answerData, 0, answerData.Length, cancellationToken); continue; } await Broadcast(p.Payload); } continue; case -1: { if (ipPacket.PayloadPacket is UdpPacket udpPacket && udpPacket.PayloadPacket is DnsPacket dnsPacket) { if (dnsPacket.Queries.Count == 1 && dnsPacket.Queries[0].Type == 1 && dnsPacket.Queries[0].Class == 1 && DomainNameUtil.GetName(string.Join(".", dnsPacket.Queries[0].Labels), dnsFormat) != null) { var name = DomainNameUtil.GetName(string.Join(".", dnsPacket.Queries[0].Labels), dnsFormat); if (string.IsNullOrEmpty(name)) { continue; } if (name == selfName) { await DnsReply(dnsPacket.TransactionId, dnsPacket.Queries[0].Labels, selfId, udpPacket.SourcePort); } else { var clientId = GetNodes().FirstOrDefault(x => x.GetDnmpNodeData().DomainName == name)?.Id; if (clientId != null) { await DnsReply(dnsPacket.TransactionId, dnsPacket.Queries[0].Labels, clientId.Value, udpPacket.SourcePort); } } } } } continue; } } break; case EthernetPacket.PacketType.Arp: { var arpPacket = (ArpPacket)p.PayloadPacket; var targetIp = new IPAddress(arpPacket.TargetProtocolAddress); if (!targetIp.GetAddressBytes().Take(2).SequenceEqual(tapIpPrefix)) { continue; } var targetId = GetIdFromPhysicalAddress(GetPhysicalAddressFromIp(targetIp)); if (targetId == -ipMacPoolShift) { continue; } if (!HostExists((ushort)targetId) && targetId != -1) { break; } var answerArpPacket = new ArpPacket { TargetHardwareAddress = arpPacket.SenderHardwareAddress, TargetProtocolAddress = arpPacket.SenderProtocolAddress, SenderHardwareAddress = GetPhysicalAddressFromIp(targetIp).GetAddressBytes(), SenderProtocolAddress = arpPacket.TargetProtocolAddress, Operation = ArpPacket.OperationType.Response, HardwareType = 0x0001, ProtocolType = 0x0800 }; var answerEthernetPacket = new EthernetPacket(GetPhysicalAddressFromIp(targetIp), new PhysicalAddress(arpPacket.SenderHardwareAddress), answerArpPacket, EthernetPacket.PacketType.Arp); var answerData = answerEthernetPacket.ToBytes(); await tapStream.WriteAsync(answerData, 0, answerData.Length, cancellationToken); } break; default: continue; } } catch (TaskCanceledException) { return; } catch (Exception e) { logger.Error(e, "Exception in processing packet from TAP-Windows"); } } }
public void ShouldLoadEmptyPacket() { var packet = new DhcpPacket(new byte[300]); Assert.Equal(DhcpMessageType.Unknown, packet.GetDhcpMessageType()); }
public byte[] Serialize(DhcpPacket packet) { throw new System.NotImplementedException(); }