public static void PacketHandler(Packet packet)
{
Console.WriteLine(packet.Timestamp.ToString("yyyy-MM-dd hh:mm:ss.fff") + " Length: " + packet.Length);
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
Datagram payload = udp.Payload;
byte[] data = payload.ToArray();
NAE nae = NAEHandler.parseNAEFromPacket(data);
String msg = nae.Name + " reported online.";
NAEHandler.listenFrm.Invoke(NAEHandler.listenFrm.AddNAEDelegate, new object[] { nae });
if (NAEHandler.mainFrm.notifyIcon.Visible == true)
{
NAEHandler.mainFrm.notifyIcon.BalloonTipText = msg;
NAEHandler.mainFrm.notifyIcon.ShowBalloonTip(500);
}
else
{
NAEHandler.mainFrm.notifyIcon.Visible = true;
NAEHandler.mainFrm.notifyIcon.BalloonTipText = msg;
NAEHandler.mainFrm.notifyIcon.ShowBalloonTip(500);
System.Threading.Thread.Sleep(3000);
NAEHandler.mainFrm.notifyIcon.Visible = false;
}
}
public void Send(byte[] buffer, int length)
{
// make sure that a default destination IPEndpoint has been configured.
if ((destinationIpAddress == IPv6Any) || (destinationPort == IPPortAny))
{
throw new SocketsException("Socket is not connected.");
}
UdpDatagram udpDatagram = new UdpDatagram();
udpDatagram.DestinationPort = destinationPort;
udpDatagram.SourcePort = sourcePort;
udpDatagram.AddPayload(buffer);
udpDatagram.Checksum = 0;
IPv6Packet packetUDP = new IPv6Packet();
packetUDP.SourceAddress = sourceIpAddress;
packetUDP.DestinationAddress = destinationIpAddress;
packetUDP.NextHeader = IPv6Protocol.Udp;
packetUDP.Payload = udpDatagram;
packetUDP.PayloadLength = udpDatagram.Length;
IPv6PseudoHeader ipv6PseudoHeader = new IPv6PseudoHeader(packetUDP.SourceAddress, packetUDP.DestinationAddress, packetUDP.PayloadLength, (byte)packetUDP.NextHeader);
ushort checkSum = ipv6PseudoHeader.GetCheckSum();
checkSum = NetUtilities.ComputeChecksum(checkSum, udpDatagram.ToBytes(), true);
udpDatagram.Checksum = checkSum;
NetworkingInterface.Send(packetUDP.ToBytes());
}
private void PacketHandler(Packet packet)
{
if (!trackingFlag)
{
return;
}
this.udpscr = "";
this.udpdes = "";
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
udpscr = udp.SourcePort.ToString();
udpdes = udp.DestinationPort.ToString();
int portSRC = int.Parse(udpscr);
int portDES = int.Parse(udpdes);
if (portSRC > 6999 && portSRC < 7999)
{
server = ip.Source.ToString();
downloadTraf += udp.TotalLength;
ticks++;
}
if (portDES > 6999 && portDES < 7999)
{
uploadTraf += udp.TotalLength;
}
}
// Callback function invoked by Pcap.Net for every incoming packet
private static void PacketHandler(Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
Form1 myForm = new Form1();
myForm.updateList(Convert.ToString(ip.Source));
if (Convert.ToString(ip.Source) == "192.168.178.44" || Convert.ToString(ip.Source) == "192.168.178.1")
{
if (Convert.ToString(packet.Ethernet.IpV4.Protocol) == "Tcp")
{
TcpPacket tcp = new ducap.TcpPacket();
communicator2.SendPacket(tcp.BuildTcpPacket(packet));
}
if (Convert.ToString(packet.Ethernet.IpV4.Protocol) == "Udp")
{
UdpPacket ufo = new UdpPacket();
communicator2.SendPacket(ufo.BuildUdpPacket(packet));
}
if (Convert.ToString(packet.Ethernet.IpV4.Protocol) == "Dns")
{
DnsPacket dns = new DnsPacket();
communicator2.SendPacket(dns.BuildDnsPacket(packet));
}
if (Convert.ToString(packet.Ethernet.IpV4.Protocol) == "Icmp")
{
IcmpPacket dns = new IcmpPacket();
communicator2.SendPacket(dns.BuildIcmpPacket(packet));
}
}
}
// Callback function invoked by Pcap.Net for every incoming packet
private static void PacketHandler(Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
// print ip addresses and udp ports
Console.WriteLine("Form -> Where " + ip.Source + ":" + udp.SourcePort + " -> " + ip.Destination + ":" + udp.DestinationPort);
Console.WriteLine("Data capture: " + packet.Timestamp.ToString("yyyy-MM-dd HH:mm:ss.fff"));
Console.WriteLine("Type: " + packet.Ethernet.EtherType);
if (packet.Ethernet.EtherType.ToString() == "Arp")
{
Console.WriteLine("Protocol type:" + packet.Ethernet.Arp.ProtocolType);
}
else if (packet.Ethernet.EtherType.ToString() == "IpV6")
{
Console.WriteLine("Protocol: " + packet.Ethernet.IpV6.NextHeader);
}
else
{
Console.WriteLine("Protocol: " + packet.Ethernet.IpV4.Protocol);
}
Console.WriteLine("Length: " + packet.Length);
Console.WriteLine("Data: " + packet.Ethernet.Payload);
Console.WriteLine();
}
private void PacketHandler(Packet packet)
{
// print timestamp and length of the packet
// Console.WriteLine(packet.Timestamp.ToString("yyyy-MM-dd hh:mm:ss.fff") + " length:" + packet.Length);
ip = packet.Ethernet.IpV4;
udp = ip.Udp;
tcp = ip.Tcp;
if (ip != null)
{
// System.Windows.Forms.Form.CheckForIllegalCrossThreadCalls = false;
Thread.Sleep(300);
ListViewItem item = new ListViewItem(ip.Source.ToString());
item.SubItems.Add(ip.Destination.ToString());
item.SubItems.Add(packet.Timestamp.ToString("yyyy-MM-dd hh:mm:ss.fff"));
item.SubItems.Add(packet.Length.ToString());
item.SubItems.Add(ip.Protocol.ToString());
listView1.Items.Add(item);
paketler.Add(k, packet);
k++;
}
// print ip addresses and udp ports
// Console.WriteLine(ip.Source + ":" + udp.SourcePort + " -> " + ip.Destination + ":" + udp.DestinationPort);
}
private void receiveCallback(Packet packet)
{
try
{
IpV4Datagram ipPacket = packet.Ethernet.IpV4;
UdpDatagram udpDatagram = ipPacket.Udp;
Datagram datagram = udpDatagram.Payload;
if (udpDatagram.SourcePort.Equals(68) & udpDatagram.DestinationPort.Equals(67))
{
DHCPv4Packet dhcpv4Packet = new DHCPv4Packet();
if (dhcpv4Packet.parsePacket(datagram.ToArray()))
{
List <DHCPv4Option> list = new DHCPv4Option().parseDhcpOptions(dhcpv4Packet.dhcpOptions);
foreach (DHCPv4Option dhcpMessageTypeOption in list)
{
if (dhcpMessageTypeOption.optionIdBytes.Equals(0x35))
{
switch (dhcpMessageTypeOption.optionValue[0])
{
//--Packet is a Discover
case 0x01:
Console.WriteLine("Service received:\t" + packet.Ethernet.Destination + "\tDISCOVER\txid: " + BitConverter.ToString(dhcpv4Packet.xid));
sendDhcpOffer(new MacAddress(inter.getMacAddress()), packet.Ethernet.Source, dhcpv4Packet.xid, dhcpv4Packet.secs);
break;
//--Packet is an Request
case 0x03:
foreach (DHCPv4Option dhcpServerIdentifierOption in list)
{
//--DHCP contains Server-Identifier-Option.
if (dhcpServerIdentifierOption.optionIdBytes.Equals(0x36))
{
//--DHCP-Server-Identifier equals IP-Address of DHCP-Server.
if (BitConverter.ToInt32(dhcpServerIdentifierOption.optionValue, 0).Equals(BitConverter.ToInt32(inter.getIPAddress().GetAddressBytes(), 0)))
{
Console.WriteLine("Service received:\t" + packet.Ethernet.Destination + "\tREQUEST\t\txid: " + BitConverter.ToString(dhcpv4Packet.xid) + "\tSID: " + BitConverter.ToString(dhcpServerIdentifierOption.optionValue, 0));
sendDhcpAck(new MacAddress(inter.getMacAddress()), packet.Ethernet.Source, dhcpv4Packet.xid, dhcpv4Packet.secs);
}
else
{
Console.WriteLine("Client preferes other DHCP-Server!");
}
}
}
break;
}
}
}
}
else
{
Console.WriteLine("The DHCP-Message could not be parsed...");
}
}
}
catch (Exception) { }
}
// Callback function invoked by libpcap for every incoming packet
private static void PacketHandler(Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
// print ip addresses and udp ports
Console.WriteLine(packet.Timestamp.ToString("yyyy-MM-dd hh:mm:ss.fff") + " " + ip.Source + ":" + udp.SourcePort + " -> " + ip.Destination + ":" + udp.DestinationPort);
Console.WriteLine(udp.Payload);
}
/// <summary>
/// Gets the key for Ethernet frame.
/// </summary>
/// <param name="frameBytes">Bytes that contains Ethernet frame.</param>
/// <returns><see cref="FlowKey"/> for the provided Ethernet frame.</returns>
public static FlowKey GetKeyForEthernetFrame(byte[] frameBytes)
{
var etherType = EthernetFrame.GetEtherType(frameBytes);
var etherPayload = EthernetFrame.GetPayloadBytes(frameBytes);
Span <Byte> ipPayload = stackalloc byte[0];
var protocol = 0;
Span <Byte> sourceAddress = stackalloc byte[4];
Span <Byte> destinAddress = stackalloc byte[4];
UInt16 sourcePort = 0;
UInt16 destinPort = 0;
switch (etherType)
{
case (ushort)EthernetFrame.EtherTypeEnum.Ipv4:
{
sourceAddress = Ipv4Packet.GetSourceAddress(etherPayload);
destinAddress = Ipv4Packet.GetDestinationAddress(etherPayload);
ipPayload = Ipv4Packet.GetPayloadBytes(etherPayload);
protocol = Ipv4Packet.GetProtocol(etherPayload);
break;
}
case (ushort)EthernetFrame.EtherTypeEnum.Ipv6:
{
sourceAddress = Ipv6Packet.GetSourceAddress(etherPayload);
destinAddress = Ipv6Packet.GetDestinationAddress(etherPayload);
ipPayload = Ipv6Packet.GetPayloadBytes(etherPayload);
protocol = Ipv6Packet.GetProtocol(etherPayload);
break;
}
default:
break;
}
switch (protocol)
{
case 6: // TCP
{
sourcePort = TcpSegment.GetSourcePort(ipPayload);
destinPort = TcpSegment.GetDestinationPort(ipPayload);
break;
}
case 17: // UDP
{
sourcePort = UdpDatagram.GetSourcePort(ipPayload);
destinPort = UdpDatagram.GetDestinationPort(ipPayload);
break;
}
default:
break;
}
// ok we have enough information for creating packet's flow key
return(FlowKey.Create((byte)protocol, sourceAddress, sourcePort, destinAddress, destinPort));
}
// Callback function invoked by libpcap for every incoming packet
private static void PacketHandler(Packet packet)
{
String scriptName = "";
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
String directory = "";
// print ip addresses and udp ports
if (ip.Source.ToString() == myIp && servers.ContainsKey(ip.Destination.ToString()) && packet.Length > 100)
{
directory = repoTarget + servers[ip.Destination.ToString()] + @"\";
String pay = "";
foreach (char paychar in ip.Payload)
{
if ((paychar > 31 && paychar < 177) || paychar == 10 || paychar == 13 || paychar == 9)
{
pay = pay + paychar;
}
}
if (pay != "")
{
Regex rgx = new Regex("(?=\\<\\?xml).*<\\/.*>", RegexOptions.Singleline);
if (rgx.Match(pay).Success)
{
pay = rgx.Matches(pay)[0].Value;
try{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(pay);
directory = directory + xmlDoc.LastChild.Name;
scriptName = xmlDoc.LastChild.Attributes[0].InnerText;
foreach (XmlNode child in xmlDoc.LastChild)
{
switch (child.Name)
{
case "CODE":
pay = child.InnerText;
break;
}
}
directory = directory + "\\" + scriptName + "\\";
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
Console.WriteLine(directory + "ver" + Directory.GetFiles(@directory, "*.*", SearchOption.AllDirectories).Length);
using (StreamWriter writter = new StreamWriter(directory + "ver" + Directory.GetFiles(directory, "*.*", SearchOption.AllDirectories).Length + ".txt")){
writter.Write(pay);
}
}
catch {
Console.Out.WriteLine("A bad thing happend when tring to parse XML. Your client may not have deployed the whole thing. Please save again.");
}
}
}
}
}
private void PrintPacketInfo(Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
string info = String.Format(
"[time:{0}] [length:{1}] [source:{2}] [destination:{3}]", packet.Timestamp.ToString("yyyy-MM-dd hh:mm:ss.fff"), packet.Length, ip.Source, ip.Destination);
Console.WriteLine(info);
}
public Syslog Parse(UdpDatagram receivedPacket)
{
if (receivedPacket.Protocol != ProtocolType.Udp)
{
throw new NotSupportedException("Datagrams other than UDP not supported to generate Syslogs.");
}
string logMessage = Encoding.ASCII.GetString(receivedPacket.UdpData);
if (string.IsNullOrWhiteSpace(logMessage))
{
throw new ArgumentException("Incoming UDP datagram contained no Syslog data.");
}
var defMatch = this.parser.Match(logMessage);
if (!defMatch.Success)
{
throw new ArgumentException("Cannot parse the incoming UDP datagram.");
}
if (defMatch.Groups.Count < 1)
{
throw new ArgumentException("Only no parsable fields in the incoming Syslog");
}
var privalMatch = defMatch.Groups["PRIVAL"].Value.Trim();
if (string.IsNullOrWhiteSpace(privalMatch))
{
throw new ArgumentException(
"Datagram does not contain the correct string indicating the PRIVAL of the Syslog");
}
var prival = int.Parse(privalMatch);
var severity = (Severity)Enum.ToObject(typeof(Severity), prival & 0x7);
var facility = (Facility)Enum.ToObject(typeof(Facility), prival >> 3);
var message = defMatch.Groups["MESSAGE"].Value.Trim();
var matches = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var groupName in this.groupNames)
{
var group = defMatch.Groups[groupName];
if (group.Success && !string.IsNullOrEmpty(group.Value))
{
matches[groupName] = group.Value;
}
}
return(new Syslog(receivedPacket.ReceivedTime, receivedPacket.SourceIpAddress.ToString(), severity, facility, message, matches));
}
private static void PacketHandler2(Packet packet)
{
Console.WriteLine("***************************************************************");
// print timestamp and length of the packet
Console.WriteLine(packet.Timestamp.ToString("yyyy-MM-dd hh:mm:ss.fff") + " length:" + packet.Length);
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
// print ip addresses and udp ports
Console.WriteLine(ip.Source + ":" + udp.SourcePort + " -> " + ip.Destination + ":" + udp.DestinationPort);
}
private void PacketHandler(Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
if (udp == null || (udp.SourcePort != 5056 && udp.DestinationPort != 5056))
{
return;
}
photonParser.ReceivePacket(udp.Payload.ToArray());
}
private void PacketHandler(Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
if (udp == null || (udp.SourcePort != GameServerClientPort && udp.DestinationPort != GameServerClientPort))
{
return;
}
System.Threading.Thread.Sleep(10);
_photonPackageParser.DeserializeMessageAndCallback(udp);
}
// Callback function invoked by libpcap for every incoming packet
private static void InterpretingPacketHandler(Packet packet)
{
// print timestamp and length of the packet
_tr.WriteLine(packet.Timestamp.ToString("yyyy-MM-dd hh:mm:ss.fff") + " length:" + packet.Length);
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
// print ip addresses and udp ports
_tr.WriteLine(ip.Source + ":" + udp.SourcePort + " -> " + ip.Destination + ":" + udp.DestinationPort);
//if (_wr.IsExecutionAborted())
// __communicator.Break();
}
public static void TestDecoratorDesign()
{
AppDatagram appDatagram = new AppDatagram();
appDatagram.SendData();
TcpDatagram tcpDatagram = new TcpDatagram(appDatagram);
tcpDatagram.SendData();
UdpDatagram udpDatagram = new UdpDatagram(appDatagram);
udpDatagram.SendData();
}
private void GetIpProtocol(Packet packet, PacketInfo info)
{
switch (packet.Ethernet.IpV4.Protocol)
{
case IpV4Protocol.InternetControlMessageProtocol:
IcmpDatagram icmp = packet.Ethernet.IpV4.Icmp;
if (icmp != null)
{
info.Protocol = "ICMP";
info.Info = "Echo (ping)";
info.Layers.ICMPInfo = $"Checksum: {icmp.Checksum}";
}
break;
case IpV4Protocol.Tcp:
var tcp = packet.Ethernet.IpV4.Tcp;
info.Protocol = "TCP";
info.Info = $"{tcp.SourcePort} → {tcp.DestinationPort} [{GetFlags(tcp)}] " +
$"Seq={tcp.SequenceNumber} Win={tcp.Window} Len={tcp.Length}";
/////////////// HTTP Request//////////////////
var header = tcp.Http.Header;
if (header != null)
{
info.Protocol = "HTTP";
info.Layers.HTTPInfo = "Header: " + header;
}
/////////////// TCP Layer//////////////////
info.Layers.TCPInfo = $"Source Port: {tcp.SourcePort}\nDestination Port: {tcp.DestinationPort}" +
$"\nSequence number: {tcp.SequenceNumber}\nNext sequence number: {tcp.NextSequenceNumber}" +
$"\nAcknowledgement number: {tcp.AcknowledgmentNumber}\nHeader Length: {tcp.HeaderLength}" +
$"\nWindow size value: {tcp.Window}\nChecksum: {tcp.Checksum}";
break;
case IpV4Protocol.Udp:
UdpDatagram udp = packet.Ethernet.IpV4.Udp;
info.Protocol = "UDP";
info.Info = $"{udp.SourcePort} → {udp.DestinationPort} Len={udp.Length}";
info.Layers.UDPInfo = $"Source Port: {udp.SourcePort}\nDestination Port: {udp.DestinationPort}" +
$"\nLength: {udp.TotalLength}\nChecksum: {udp.Checksum}";
break;
case IpV4Protocol.InternetControlMessageProtocolForIpV6:
info.Protocol = "ICMPv6";
break;
default:
break;
}
}
//[DataMember]
//public int http_header_bytes { get; set; }
public CustomPacket(Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
TcpDatagram tcp = ip.Tcp;
ip_lenght = ip.Length;
ip_header_lenght = ip.RealHeaderLength;
ip_total_lenght = ip.TotalLength;
ip_ttl = ip.Ttl;
ip_service_type = ip.TypeOfService;
ip_header_version = ip.Version;
udp_check_sum = udp.Checksum;
udp_dst_port = udp.DestinationPort;
udp_cs_is_optional = udp.IsChecksumOptional;
udp_is_valid = udp.IsValid;
udp_scr_port = udp.SourcePort;
udp_total_length = udp.TotalLength;
tcp_check_sum = tcp.Checksum;
tcp_dst_port = tcp.DestinationPort;
tcp_header_lenght = tcp.HeaderLength;
tcp_is_ack = tcp.IsAcknowledgment;
tcp_cs_is_optional = tcp.IsChecksumOptional;
tcp_is_cw_reduced = tcp.IsCongestionWindowReduced;
tcp_is_ecne = tcp.IsExplicitCongestionNotificationEcho;
tcp_is_nonce_sum = tcp.IsNonceSum;
tcp_is_fin = tcp.IsFin;
tcp_is_push = tcp.IsPush;
tcp_is_reset = tcp.IsReset;
tcp_is_syn = tcp.IsSynchronize;
tcp_is_urgent = tcp.IsUrgent;
tcp_is_valid = tcp.IsValid;
tcp_lenght = tcp.Length;
tcp_upointer = tcp.UrgentPointer;
tcp_window = tcp.Window;
if (tcp.Http != null)
{
http_is_request = tcp.Http.IsRequest;
http_is_response = tcp.Http.IsResponse;
}
else
{
http_is_request = false;
http_is_response = false;
}
}
public static SnmpDatagram TryParseSnmpDatagram(this UdpDatagram udpDatagram)
{
try
{
var transportObject = udpDatagram.TransportObject;
var datagram = udpDatagram.UdpData.ToSnmpDatagram();
udpDatagram.TransportObject = datagram;
return(datagram);
}
catch
{
return(default(SnmpDatagram));
}
}
/// <summary>
/// Receives packet's datagram
/// </summary>
/// <returns>Tcp or Udp</returns>
public static TransportDatagram GetDatagram(this Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
if (ip.Protocol == IpV4Protocol.Tcp)
{
TcpDatagram tcp = ip.Tcp;
return(tcp);
}
else
{
UdpDatagram udp = ip.Udp;
return(udp);
}
}
public void TestInitialize()
{
var integerVarBind = new VarBind(
new ObjectIdentifier("1.3.6.1.4.1.1.1.1"),
5L,
new Asn1TagInfo(Asn1Tag.Integer, ConstructType.Primitive, Asn1Class.Universal));
var sysUpTime = new VarBind(new ObjectIdentifier("1.3.6.1.2.1.1.3.0"),
506009u,
new Asn1TagInfo(Asn1SnmpTag.TimeTicks));
var trapVb = new VarBind(new ObjectIdentifier("1.3.6.1.6.3.1.1.4.1.0"),
new ObjectIdentifier("1.3.6.1.4.1.500.12"),
new Asn1TagInfo(Asn1Tag.ObjectIdentifier, ConstructType.Primitive, Asn1Class.Universal));
var extraneousVb = new VarBind(new ObjectIdentifier("1.3.6.1.6.3.1.1.42.42.42.0"),
8938ul,
new Asn1TagInfo(Asn1SnmpTag.Counter64));
var packet = new SnmpDatagram(
PduType.SNMPv2Trap,
SnmpVersion.V2C,
"Community",
50000,
SnmpErrorStatus.NoError,
0,
new[] { sysUpTime, trapVb, integerVarBind, extraneousVb });
var encoded = packet.ToSnmpEncodedByteArray();
var ipPacket = new IpPacket(
NetworkInterfaceComponent.IPv4,
Byte.MaxValue,
Byte.MaxValue,
Byte.MaxValue,
UInt16.MaxValue,
UInt16.MaxValue,
Byte.MaxValue,
UInt16.MaxValue,
Byte.MaxValue,
ProtocolType.Udp,
IPAddress.Parse("1.1.1.1"),
IPAddress.Parse("2.2.2.2"),
new byte[0],
new byte[0]);
this.fakeTrapUdp = new UdpDatagram(ipPacket, 10, 10, (ushort)(encoded.Length + 8), encoded);
}
private void PrintPacketInfo(Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
if (!ip.Destination.ToString().Contains("192"))
{
string server = ip.Destination + ":" + udp.DestinationPort;
ConsoleMsg.Write($"Connected to game server : {server}", ConsoleMsg.Type.Info, true);
if (!String.IsNullOrEmpty(Constants.DiscordWebHook))
{
Webhook.SendMessage(PlayerName, server);
}
pm.Break();
}
}
public void TestSyslogCustomParserParsing()
{
var testprival = "<140>";
var severity = (Severity)Enum.ToObject(typeof(Severity), 140 & 0x7);
var facility = (Facility)Enum.ToObject(typeof(Facility), 140 >> 3);
var testmessage = "A message with any pri-val";
var testString = testprival + testmessage;
var udData = new ArraySegment <byte>(Encoding.ASCII.GetBytes(testString));
var pHeader = new IpPacketHeader(
IPAddress.Parse("127.0.0.1"),
IPAddress.Parse("127.0.0.1"),
false,
4,
0,
0,
(ushort)(udData.Array.Length + 20 + 8),
0,
0,
0,
255,
0
);
var udHeader = new UdpDatagramHeader(16, 16, (ushort)udData.Array.Length, 0);
UdpDatagram ud = new UdpDatagram()
{
UdpDatagramHeader = udHeader,
UdpData = udData,
PacketHeader = pHeader,
ReceivedTime = DateTimeOffset.UtcNow
};
var customParser = new Regex(@"(?<WithAny>with\sany)", RegexOptions.ExplicitCapture);
var sysparser = new SyslogParser(customParser);
var sys = sysparser.Parse(ud);
Assert.IsNotNull(sys);
Assert.AreEqual(testmessage, sys.Message);
Assert.AreEqual(severity, sys.LogSeverity);
Assert.AreEqual(facility, sys.LogFacility);
Assert.AreEqual("with any", sys.NamedCollectedMatches["WithAny"]);
}
/// <summary>
/// asynchronous execution of an RPC request
/// </summary>
public IRpcRequest <TResp> Request <TReq, TResp>(call_body callBody, TReq reqArgs)
{
RpcRequest <TResp> handler = null;
try
{
handler = NewHandler <TResp>();
rpc_msg reqHeader = new rpc_msg()
{
xid = handler.Xid,
body = new body()
{
mtype = msg_type.CALL,
cbody = callBody
}
};
UdpDatagram dtg = new UdpDatagram();
Writer w = Toolkit.CreateWriter(dtg);
w.Write(reqHeader);
w.Write(reqArgs);
byte[] outBuff = dtg.ToArray();
//Log.Trace(() => "sending byte dump: " + outBuff.ToDisplay());
handler.OutBuff = outBuff;
EqueueSend(handler);
//lock (_sync)
// _sendingHandlers.Enqueue(handler);
//_client.BeginSend(outBuff, outBuff.Length, _ep, handler.DatagramSended, null);
}
catch (Exception ex)
{
if (handler == null)
{
handler = new RpcRequest <TResp>(null, 0);
}
ThreadPool.QueueUserWorkItem((o) => handler.Except(ex));
}
return(handler);
}
public void HandleUdpDatagram(IPv4Datagram datagram)
{
UdpDatagram packet = datagram.HandleUdpDatagram();
ListViewItem item = new ListViewItem(count.ToString());
item.SubItems.Add(datagram.SourceName);
item.SubItems.Add(packet.SourcePort.ToString() + " " + consts.GetTcpPorts(packet.SourcePort));
item.SubItems.Add(datagram.DestinationName);
item.SubItems.Add(packet.DestinationPort.ToString() + " " + consts.GetTcpPorts(packet.DestinationPort));
item.SubItems.Add(datagram.Identification.ToString());
lstwUdp.Items.Add(item);
packets.Add(GetHashString(), datagram);
count++;
lblCount.Text = count.ToString();
this.Update();
}
public PDU(UdpDatagram datagram)
{
_udp = datagram;
MemoryStream stream = new MemoryStream(datagram.UdpData);
BasicEncodingReader _reader = new BasicEncodingReader(stream);
Asn1Type seqType = _reader.ReadType();
int seqLength = _reader.ReadLength();
Version = _reader.ReadInteger();
Community = _reader.ReadOctetString();
Asn1Type t = _reader.ReadType();
PduType = (PduType)(t.Byte & 0x1F);
if (PduType == Snmp.PduType.Trap)
{
throw new NotImplementedException("SNMP v1 traps are not yet implemented");
}
int len = _reader.ReadLength();
RequestId = _reader.ReadInteger();
ErrorStatus = _reader.ReadInteger();
ErrorIndex = _reader.ReadInteger();
Asn1Type type = _reader.ReadType();
if (type.Class != Asn1Class.Universal && type.Tag != Asn1Tag.Sequence)
{
throw new Exception("Sequence expected");
}
int length = _reader.ReadLength();
VarBinds = new SortedDictionary <string, object>();
var list = _reader.ReadConstructedType(length);
foreach (List <object> seq in list)
{
string oid = (string)seq[0];
VarBinds.Add(oid, seq[1]);
}
}
public void TestMethod1()
{
//bytes are in Network Order
byte[] sampleUdpBytes = { 0x45, 0x00, 0x00, 0x4e, 0x70, 0x3a, 0x00, 0x00, 0x80, 0x11, 0xaa, 0x2a, 0x0a, 0x78, 0x85, 0x4b, 0x0a, 0x78, 0x85, 0xff, 0x00, 0x89, 0x00, 0x89, 0x00, 0x3a, 0x12, 0x55, 0x8a, 0x6a, 0x01, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x46, 0x48, 0x46, 0x41, 0x45, 0x42, 0x45, 0x45, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x41, 0x41, 0x00, 0x00, 0x20, 0x00, 0x01 };
byte[] sampleIpHeaderBytes = { 0x45, 0x00, 0x00, 0x4e, 0x70, 0x3a, 0x00, 0x00, 0x80, 0x11, 0xaa, 0x2a, 0x0a, 0x78, 0x85, 0x4b, 0x0a, 0x78, 0x85, 0xff };
//byte[] sampleIpHeaderBytesNoCkSum = { 0x45, 0x00, 0x00, 0x4e, 0x70, 0x3a, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x0a, 0x78, 0x85, 0x4b, 0x0a, 0x78, 0x85, 0xff };
byte[] sampleIpCksumBytes = { 0xaa, 0x2a };
byte[] sampleUdpCksumBytes = { 0x12, 0x55 };
var testDatagram = new UdpDatagram(sampleUdpBytes);
//Preserved the ip checksum correctly in the object
var IpVerify = (ushort)IPAddress.NetworkToHostOrder((short)BitConverter.ToUInt16(sampleIpCksumBytes, 0));
Assert.AreEqual(testDatagram.PacketHeaderChecksum, IpVerify);
//Preserved the udp checksum correctly in the object
var UdpVerify = (ushort)IPAddress.NetworkToHostOrder((short)BitConverter.ToUInt16(sampleUdpCksumBytes, 0));
Assert.AreEqual(testDatagram.UdpCheckSum, UdpVerify);
//Ip header in transform from object to wire-bytes is correct
var IpHeaderVerify = testDatagram.PacketHeaderToWireBytes();
Assert.IsTrue(IpHeaderVerify.SequenceEqual(sampleIpHeaderBytes));
//checksum on header should be zero if header has the correct checksum in it.
var IpHeaderCk = NetworkTransformExtentions.GetInternetChecksum(IpHeaderVerify);
Assert.AreEqual(0, IpHeaderCk);
//Udp check is correct
var UdpCk = (ushort)IPAddress.NetworkToHostOrder((short)testDatagram.GetUdpCheckSum());
Assert.AreEqual(UdpVerify, UdpCk);
//the whole datagram is right
var datagramCheck = testDatagram.ToWirebytes();
Assert.IsTrue(datagramCheck.SequenceEqual(sampleUdpBytes));
}
private void PacketHandler(Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
if (udp == null || (udp.SourcePort != 5056 && udp.DestinationPort != 5056 &&
udp.SourcePort != 5055 && udp.DestinationPort != 5055))
{
return;
}
try
{
photonParser.ReceivePacket(udp.Payload.ToArray());
}
catch (Exception e)
{
// Don't crash when we can't parse the packet
Console.WriteLine(e);
}
}
private void _read()
{
switch (Protocol)
{
case ProtocolEnum.Ipv6Nonxt: {
_body = new NoNextHeader(m_io, this, m_root);
break;
}
case ProtocolEnum.Ipv4: {
_body = new Ipv4Packet(m_io);
break;
}
case ProtocolEnum.Udp: {
_body = new UdpDatagram(m_io);
break;
}
case ProtocolEnum.Icmp: {
_body = new IcmpPacket(m_io);
break;
}
case ProtocolEnum.Hopopt: {
_body = new OptionHopByHop(m_io, this, m_root);
break;
}
case ProtocolEnum.Ipv6: {
_body = new Ipv6Packet(m_io);
break;
}
case ProtocolEnum.Tcp: {
_body = new TcpSegment(m_io);
break;
}
}
}
public void TestSyslogCustomParserParsing()
{
var testprival = "<140>";
var severity = (Severity)Enum.ToObject(typeof(Severity), 140 & 0x7);
var facility = (Facility)Enum.ToObject(typeof(Facility), 140 >> 3);
var testmessage = "A message with any pri-val";
var testString = testprival + testmessage;
var udData = new ArraySegment<byte>(Encoding.ASCII.GetBytes(testString));
var pHeader = new IpPacketHeader(
IPAddress.Parse("127.0.0.1"),
IPAddress.Parse("127.0.0.1"),
false,
4,
0,
0,
(ushort)(udData.Array.Length + 20 + 8),
0,
0,
0,
255,
0
);
var udHeader = new UdpDatagramHeader(16, 16, (ushort)udData.Array.Length, 0);
UdpDatagram ud = new UdpDatagram()
{
@UdpDatagramHeader = udHeader,
UdpData = udData,
PacketHeader = pHeader,
ReceivedTime = DateTimeOffset.UtcNow
};
var customParser = new Regex(@"(?<WithAny>with\sany)", RegexOptions.ExplicitCapture);
var sysparser = new SyslogParser(customParser);
var sys = sysparser.Parse(ud);
Assert.IsNotNull(sys);
Assert.AreEqual(testmessage, sys.Message);
Assert.AreEqual(severity, sys.LogSeverity);
Assert.AreEqual(facility, sys.LogFacility);
Assert.AreEqual("with any", sys.NamedCollectedMatches["WithAny"]);
}
public void TestInitialize()
{
var integerVarBind = new VarBind(
new ObjectIdentifier("1.3.6.1.4.1.1.1.1"),
5L,
new Asn1TagInfo(Asn1Tag.Integer, ConstructType.Primitive, Asn1Class.Universal));
var sysUpTime = new VarBind(new ObjectIdentifier("1.3.6.1.2.1.1.3.0"),
506009u,
new Asn1TagInfo(Asn1SnmpTag.TimeTicks));
var trapVb = new VarBind(new ObjectIdentifier("1.3.6.1.6.3.1.1.4.1.0"),
new ObjectIdentifier("1.3.6.1.4.1.500.12"),
new Asn1TagInfo(Asn1Tag.ObjectIdentifier, ConstructType.Primitive, Asn1Class.Universal));
var extraneousVb = new VarBind(new ObjectIdentifier("1.3.6.1.6.3.1.1.42.42.42.0"),
8938ul,
new Asn1TagInfo(Asn1SnmpTag.Counter64));
this.snmpDatagram = new SnmpDatagramV2C(
DateTimeOffset.MinValue,
"1.1.1.1",
new SnmpHeader(SnmpVersion.V2C, "Community"),
new[] { sysUpTime, trapVb, integerVarBind, extraneousVb },
PduType.SNMPv2Trap,
50000,
SnmpErrorStatus.NoError,
0);
var encoded = this.snmpDatagram.ToSnmpEncodedByteArray();
this.fakeTrapUdp = new UdpDatagram
{
UdpData = encoded.AsByteArraySegment(),
PacketHeader = new IpPacketHeader(IPAddress.Parse("1.1.1.1"), IPAddress.Parse("2.2.2.2"), false, 1, 1, 1, 1, 1, 1, 1, 1, 1)
};
}
