public static Packet BuildProfinetFramePacket()
{
EthernetLayer ethernetLayer =
new EthernetLayer
{
Source = new MacAddress("28:63:36:88:02:52"),
Destination = new MacAddress("00:1b:1b:6b:6b:0e"),
EtherType = EthernetType.None, // Will be filled automatically.
};
VLanTaggedFrameLayer vLanTaggedFrameLayer =
new VLanTaggedFrameLayer
{
PriorityCodePoint = ClassOfService.NetworkControl,
CanonicalFormatIndicator = false,
VLanIdentifier = 50,
EtherType = (EthernetType)34962,
};
PayloadLayer payloadLayer =
new PayloadLayer
{
Data = new Datagram(new byte[] { 0x80, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0x40, 0x35, 0x00 })
};
PacketBuilder builder = new PacketBuilder(ethernetLayer, vLanTaggedFrameLayer, payloadLayer);
return(builder.Build(DateTime.Now));
}
private void BtnRegister_OnClick(object sender, ClickedEventArgs e)
{
//making sure that passwords match and the email has been successfully validated
if (txtPassword.Text == txtRepeat.Text && eValidator.Validate(txtEmail.Text))
{
if (!GameClient.NetClient.Connected)
{
GameClient.NetClient.Connect();
}
if (!GameClient.NetClient.Connected)
{
DisplayMessage("Connection to game server could not be found!");
}
else
{
//if we have connected to the game server and everything checks out, we're going to register to the server
PacketBuilder pb = new PacketBuilder(PacketFamily.REGISTER, PacketAction.REQUEST);
pb = pb.AddByte((byte)txtUsername.Text.Length)
.AddString(txtUsername.Text)
.AddByte((byte)txtPassword.Text.Length)
.AddString(txtPassword.Text)
.AddByte((byte)txtEmail.Text.Length)
.AddString(txtEmail.Text)
.AddByte((byte)txtFullname.Text.Length)
.AddString(txtFullname.Text);
GameClient.NetClient.Send(pb.Build());
}
}
}
public void SpawnPickup()
{
GameObject pickup = _pickupPool.Get();
if (pickup == null)
{
_spawnTimer.StopUntil(() => _pickupPool.HasObjectAvailable, true);
}
else
{
Vector2 randomPos = Random.insideUnitCircle * _radius;
pickup.transform.position = _center.position + new Vector3(randomPos.x, 0f, randomPos.y);
pickup.GetComponent <IManaged>().SetCallbacks(DeactivateManagedObject);
byte id;
if (_availableIds.Count > 0)
{
id = _availableIds.Dequeue();
}
else
{
id = (byte)_pickups.Count;
}
EntityData data = new EntityData(id, pickup);
pickup.GetComponent <IEntity>().Data = data;
_pickups.Add(id, data);
using (PacketBuilder pb = new PacketBuilder(_packets.PickupSpawnedID)){
pb.Write(id);
Vector3 v = pickup.transform.position;
pb.Write(new Vector2(v.x, v.z));
_server.SendTCPAll(pb.Build());
}
}
}
/// <summary>
/// This function build an IPv6 over Ethernet with payload packet.
/// </summary>
private static Packet BuildIpV6Packet()
{
EthernetLayer ethernetLayer =
new EthernetLayer
{
Source = new MacAddress("01:01:01:01:01:01"),
Destination = new MacAddress("02:02:02:02:02:02"),
EtherType = EthernetType.None,
};
IpV6Layer ipV6Layer =
new IpV6Layer
{
Source = new IpV6Address("0123:4567:89AB:CDEF:0123:4567:89AB:CDEF"),
CurrentDestination = new IpV6Address("FEDC:BA98:7654:3210:FEDC:BA98:7654:3210"),
FlowLabel = 123,
HopLimit = 100,
NextHeader = IpV4Protocol.Udp,
};
PayloadLayer payloadLayer =
new PayloadLayer
{
Data = new Datagram(Encoding.ASCII.GetBytes("hello world")),
};
PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV6Layer, payloadLayer);
return(builder.Build(DateTime.Now));
}
/// <summary>
/// This function build an IGMP over IPv4 over Ethernet packet.
/// </summary>
private static Packet BuildIgmpPacket()
{
EthernetLayer ethernetLayer =
new EthernetLayer
{
Source = new MacAddress("01:01:01:01:01:01"),
Destination = new MacAddress("02:02:02:02:02:02"),
EtherType = EthernetType.None, // Will be filled automatically.
};
IpV4Layer ipV4Layer =
new IpV4Layer
{
Source = new IpV4Address("1.2.3.4"),
CurrentDestination = new IpV4Address("11.22.33.44"),
Fragmentation = IpV4Fragmentation.None,
HeaderChecksum = null, // Will be filled automatically.
Identification = 123,
Options = IpV4Options.None,
Protocol = null, // Will be filled automatically.
Ttl = 100,
TypeOfService = 0,
};
IgmpQueryVersion1Layer igmpLayer =
new IgmpQueryVersion1Layer
{
GroupAddress = new IpV4Address("1.2.3.4"),
};
PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV4Layer, igmpLayer);
return(builder.Build(DateTime.Now));
}
/// <summary>
/// This function build a VLanTaggedFrame over Ethernet with payload packet.
/// </summary>
private static Packet BuildVLanTaggedFramePacket()
{
EthernetLayer ethernetLayer =
new EthernetLayer
{
Source = new MacAddress("01:01:01:01:01:01"),
Destination = new MacAddress("02:02:02:02:02:02"),
EtherType = EthernetType.None, // Will be filled automatically.
};
VLanTaggedFrameLayer vLanTaggedFrameLayer =
new VLanTaggedFrameLayer
{
PriorityCodePoint = ClassOfService.Background,
CanonicalFormatIndicator = false,
VLanIdentifier = 50,
EtherType = EthernetType.IpV4,
};
PayloadLayer payloadLayer =
new PayloadLayer
{
Data = new Datagram(Encoding.ASCII.GetBytes("hello world")),
};
PacketBuilder builder = new PacketBuilder(ethernetLayer, vLanTaggedFrameLayer, payloadLayer);
return(builder.Build(DateTime.Now));
}
/// <summary>
/// This function build an IPv4 over Ethernet with payload packet.
/// </summary>
private static Packet BuildIpV4Packet()
{
EthernetLayer ethernetLayer =
new EthernetLayer
{
Source = new MacAddress("01:01:01:01:01:01"),
Destination = new MacAddress("02:02:02:02:02:02"),
EtherType = EthernetType.None,
};
IpV4Layer ipV4Layer =
new IpV4Layer
{
Source = new IpV4Address("1.2.3.4"),
CurrentDestination = new IpV4Address("11.22.33.44"),
Fragmentation = IpV4Fragmentation.None,
HeaderChecksum = null, // Will be filled automatically.
Identification = 123,
Options = IpV4Options.None,
Protocol = IpV4Protocol.Udp,
Ttl = 100,
TypeOfService = 0,
};
PayloadLayer payloadLayer =
new PayloadLayer
{
Data = new Datagram(Encoding.ASCII.GetBytes("hello world")),
};
PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV4Layer, payloadLayer);
return(builder.Build(DateTime.Now));
}
private void requestARP()
{
String senderMAC = PcapDotNet.Core.Extensions.LivePacketDeviceExtensions.GetMacAddress(allDevices[DEV0]).ToString();
String senderIP = textboxIP1.Text.ToString();
String targetIP = textboxARPtarget.Text.ToString();
byte[] senderMACbyte = senderMAC.Split(':').Select(x => Convert.ToByte(x, 16)).ToArray();
byte[] senderIPbyte = senderIP.Split('.').Select(x => Convert.ToByte(x, 10)).ToArray();
byte[] targetIPbyte = targetIP.Split('.').Select(x => Convert.ToByte(x, 10)).ToArray();
Packet packet = PacketBuilder.Build(
DateTime.Now,
new EthernetLayer
{
Source = new MacAddress(senderMAC),
Destination = new MacAddress("FF:FF:FF:FF:FF:FF"),
EtherType = EthernetType.Arp
},
new ArpLayer
{
ProtocolType = EthernetType.IpV4,
Operation = ArpOperation.Request,
SenderHardwareAddress = senderMACbyte.AsReadOnly(),
SenderProtocolAddress = senderIPbyte.AsReadOnly(),
TargetHardwareAddress = new byte[] { 0, 0, 0, 0, 0, 0 }.AsReadOnly(),
TargetProtocolAddress = targetIPbyte.AsReadOnly(),
});
dev0.SendPacket(packet);
}
/// <summary>
/// This function build an ARP over Ethernet packet.
/// </summary>
private static Packet BuildArpPacket()
{
EthernetLayer ethernetLayer =
new EthernetLayer
{
Source = new MacAddress("01:01:01:01:01:01"),
Destination = new MacAddress("02:02:02:02:02:02"),
EtherType = EthernetType.None, // Will be filled automatically.
};
ArpLayer arpLayer =
new ArpLayer
{
ProtocolType = EthernetType.IpV4,
Operation = ArpOperation.Request,
SenderHardwareAddress = new byte[] { 3, 3, 3, 3, 3, 3 }.AsReadOnly(), // 03:03:03:03:03:03.
SenderProtocolAddress = new byte[] { 1, 2, 3, 4 }.AsReadOnly(), // 1.2.3.4.
TargetHardwareAddress = new byte[] { 4, 4, 4, 4, 4, 4 }.AsReadOnly(), // 04:04:04:04:04:04.
TargetProtocolAddress = new byte[] { 11, 22, 33, 44 }.AsReadOnly(), // 11.22.33.44.
};
PacketBuilder builder = new PacketBuilder(ethernetLayer, arpLayer);
return(builder.Build(DateTime.Now));
}
public void IpV4DatagramInvalidShortTest()
{
Packet packet = PacketBuilder.Build(DateTime.Now,
new EthernetLayer
{
Source = new MacAddress(1),
Destination = new MacAddress(2),
},
new IpV4Layer
{
Identification = 1,
Fragmentation = new IpV4Fragmentation(IpV4FragmentationOptions.MoreFragments, 8),
Ttl = 1,
Protocol = IpV4Protocol.WidebandExpak,
Source = new IpV4Address(1),
CurrentDestination = new IpV4Address(2),
});
Assert.IsTrue(packet.IsValid);
byte[] badPacketBuffer = new byte[packet.Length - 5];
packet.Buffer.BlockCopy(0, badPacketBuffer, 0, badPacketBuffer.Length);
Packet badPacket = new Packet(badPacketBuffer, DateTime.Now, packet.DataLink);
Assert.IsFalse(badPacket.IsValid, "badPacket.IsValid");
}
//adding ARP log
private void handlerARP(Packet packet)
{
byte[] senderMACbyte = packet.Ethernet.Arp.SenderHardwareAddress.ToArray();
String senderMAC = (BitConverter.ToString(senderMACbyte)).Replace("-", ":");
byte[] senderIPbyte = packet.Ethernet.Arp.SenderProtocolAddress.ToArray();
String senderIP = "" + senderIPbyte[0] + "." + senderIPbyte[1] + "." + senderIPbyte[2] + "." + senderIPbyte[3];
logARP log = new logARP(senderIP, senderMAC, timeARP);
int key = log.accessMAC.GetHashCode();
if (hashARP[key] == null)
{
addARPline(log);
hashARP.Add(key, log);
listMAC.Add(log.accessMAC);
}
else
{
logARP actual = (logARP)hashARP[key];
actual.accessIP = senderIP;
actual.accessMAC = senderMAC;
actual.accessTTL = timeARP;
}
String targetMAC = PcapDotNet.Core.Extensions.LivePacketDeviceExtensions.GetMacAddress(allDevices[DEV0]).ToString();
byte[] targetMACbyte = targetMAC.Split(':').Select(x => Convert.ToByte(x, 16)).ToArray();
String targetIP = textboxIP1.Text.ToString();
byte[] targetIPbyte = targetIP.Split('.').Select(x => Convert.ToByte(x, 10)).ToArray();
byte[] tempIPbyte = packet.Ethernet.Arp.TargetProtocolAddress.ToArray();
String tempIP = "" + tempIPbyte[0] + "." + tempIPbyte[1] + "." + tempIPbyte[2] + "." + tempIPbyte[3];
if (textboxIP1.Text.Equals(tempIP.ToString()))
{
if (packet.Ethernet.Arp.Operation.ToString().Equals("Request"))
{
Packet replyPacket = PacketBuilder.Build(
DateTime.Now,
new EthernetLayer
{
Source = new MacAddress(targetMAC),
Destination = new MacAddress(senderMAC),
EtherType = EthernetType.Arp
},
new ArpLayer
{
ProtocolType = EthernetType.IpV4,
Operation = ArpOperation.Reply,
SenderHardwareAddress = targetMACbyte.AsReadOnly(),
SenderProtocolAddress = targetIPbyte.AsReadOnly(),
TargetHardwareAddress = senderMACbyte.AsReadOnly(),
TargetProtocolAddress = senderIPbyte.AsReadOnly(),
});
dev0.SendPacket(replyPacket);
}
}
}
public void IpV4NullOptionsTest()
{
Packet packet = PacketBuilder.Build(DateTime.Now,
new IpV4Layer
{
CurrentDestination = new IpV4Address("2.3.4.5"),
Options = new IpV4Options(new IpV4OptionStrictSourceRouting(new[] { new IpV4Address("1.2.3.4") }, 0)),
Protocol = IpV4Protocol.Emcon,
});
Assert.IsTrue(packet.IsValid);
Assert.IsNotNull(packet.IpV4.Options);
Assert.AreEqual(new IpV4Address("1.2.3.4"), packet.IpV4.Destination);
const int newPacketLength = IpV4Datagram.HeaderMinimumLength - 1;
byte[] newPacketBuffer = new byte[newPacketLength];
packet.Take(newPacketLength).ToArray().CopyTo(newPacketBuffer, 0);
Packet newPacket = new Packet(newPacketBuffer, DateTime.Now, DataLinkKind.IpV4);
Assert.IsFalse(newPacket.IsValid);
Assert.IsNull(newPacket.IpV4.Options);
Assert.AreNotEqual(new IpV4Address("1.2.3.4"), newPacket.IpV4.Destination);
}
public void BuildWithoutCrcReturnPacket()
{
for (int index = 0; index < HeartbeatPacketBytes.Length - 2; index++)
{
byte packetByte = HeartbeatPacketBytes[index];
PacketBuilder.AddByte(packetByte);
}
// Checksum
PacketBuilder.AddByte(0x00);
PacketBuilder.AddByte(0x00);
MessageId expectedMessageId = MessageId.Heartbeat;
byte expectedPayloadLegth = 9;
byte expectedSequenceNumber = 78;
byte expectedSystemId = 1;
byte expectedHeader = Packet.HeaderValue;
byte[] expectedChecksum = { 0x1C, 0x7F };
byte[] expectedPayload = { 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x51, 0x04, 0x03 };
Packet packet = PacketBuilder.Build(BuildType.WithoutCrc);
Assert.AreNotEqual(null, packet);
Assert.AreEqual(expectedMessageId, packet.MessageId);
Assert.AreEqual(expectedPayloadLegth, packet.PayloadLength);
Assert.AreEqual(expectedSequenceNumber, packet.SequenceNumber);
Assert.AreEqual(expectedSystemId, packet.SystemId);
Assert.AreEqual(expectedHeader, packet.Header);
Assert.AreEqual(expectedChecksum, packet.Checksum);
Assert.AreEqual(expectedPayload, packet.Payload);
}
public void BuildWithCrcReturnPacket()
{
foreach (byte packetByte in HeartbeatPacketBytes)
{
PacketBuilder.AddByte(packetByte);
}
MessageId expectedMessageId = MessageId.Heartbeat;
byte expectedPayloadLegth = 9;
byte expectedSequenceNumber = 78;
byte expectedSystemId = 1;
byte expectedHeader = Packet.HeaderValue;
byte[] expectedChecksum = { 0x1C, 0x7F };
byte[] expectedPayload = { 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x51, 0x04, 0x03 };
Packet packet = PacketBuilder.Build();
Assert.AreNotEqual(null, packet);
Assert.AreEqual(expectedMessageId, packet.MessageId);
Assert.AreEqual(expectedPayloadLegth, packet.PayloadLength);
Assert.AreEqual(expectedSequenceNumber, packet.SequenceNumber);
Assert.AreEqual(expectedSystemId, packet.SystemId);
Assert.AreEqual(expectedHeader, packet.Header);
Assert.AreEqual(expectedChecksum, packet.Checksum);
Assert.AreEqual(expectedPayload, packet.Payload);
}
/// <summary>
/// This function build an IPv4 over Ethernet with payload packet.
/// </summary>
public static Packet BuildIpV4Packet()
{
EthernetLayer ethernetLayer =
new EthernetLayer
{
Source = new MacAddress("68:05:CA:1E:94:1C"),
Destination = new MacAddress("90:A2:DA:0D:F7:CD"),
EtherType = EthernetType.None,
};
IpV4Layer ipV4Layer =
new IpV4Layer
{
Source = new IpV4Address("10.128.24.154"),
CurrentDestination = new IpV4Address("10.128.24.165"),
Fragmentation = IpV4Fragmentation.None,
HeaderChecksum = null, // Will be filled automatically.
Identification = 123,
Options = IpV4Options.None,
Protocol = IpV4Protocol.Udp,
Ttl = 100,
TypeOfService = 0,
};
PayloadLayer payloadLayer =
new PayloadLayer
{
Data = new Datagram(Encoding.ASCII.GetBytes("hello world")),
};
PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV4Layer, payloadLayer);
return(builder.Build(DateTime.Now));
}
public override byte[] Write()
{
var builder = new PacketBuilder();
builder.Write(this.PlayerSource.HasValue);
if (this.PlayerSource.HasValue)
{
builder.WriteElementId(this.PlayerSource.Value);
builder.WriteCompressed(this.Latency ?? 0);
}
builder.Write(this.OriginId.HasValue);
if (this.OriginId.HasValue)
{
builder.WriteElementId(this.OriginId.Value);
builder.Write(this.IsVehicleResponsible);
if (this.IsVehicleResponsible)
{
builder.Write(this.BlowVehicleWithoutExplosion);
}
}
builder.WriteVector3WithZAsFloat(this.Position);
builder.WriteCapped(this.ExplosionType, 4);
return(builder.Build());
}
/// <summary>
/// This function build an IPv4 over GRE over IPv4 over Ethernet packet.
/// </summary>
public static Packet BuildGrePacket()
{
EthernetLayer ethernetLayer =
new EthernetLayer
{
Source = new MacAddress(macAddressSource),
Destination = new MacAddress(macAddressDest),
EtherType = EthernetType.None, // Will be filled automatically.
};
IpV4Layer ipV4Layer =
new IpV4Layer
{
Source = new IpV4Address(ipSource),
CurrentDestination = new IpV4Address(ipDest),
Fragmentation = IpV4Fragmentation.None,
HeaderChecksum = null, // Will be filled automatically.
Identification = 123,
Options = IpV4Options.None,
Protocol = null, // Will be filled automatically.
Ttl = 100,
TypeOfService = 0,
};
GreLayer greLayer =
new GreLayer
{
Version = GreVersion.Gre,
ProtocolType = EthernetType.None, // Will be filled automatically.
RecursionControl = 0,
FutureUseBits = 0,
ChecksumPresent = true,
Checksum = null, // Will be filled automatically.
Key = null,
SequenceNumber = 123,
AcknowledgmentSequenceNumber = null,
RoutingOffset = null,
Routing = null,
StrictSourceRoute = false,
};
IpV4Layer innerIpV4Layer =
new IpV4Layer
{
Source = new IpV4Address("100.200.201.202"),
CurrentDestination = new IpV4Address("123.254.132.40"),
Fragmentation = IpV4Fragmentation.None,
HeaderChecksum = null, // Will be filled automatically.
Identification = 123,
Options = IpV4Options.None,
Protocol = IpV4Protocol.Udp,
Ttl = 120,
TypeOfService = 0,
};
PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV4Layer, greLayer, innerIpV4Layer);
return(builder.Build(DateTime.Now));
}
public override byte[] Write()
{
var builder = new PacketBuilder();
builder.Write(NetId);
return(builder.Build());
}
public override byte[] Write()
{
PacketBuilder builder = new PacketBuilder();
builder.Write((byte)ElementRPCFunction.RESET_RAIN_LEVEL);
return(builder.Build());
}
public override byte[] Write()
{
PacketBuilder builder = new PacketBuilder();
builder.Write((byte)ElementRPCFunction.RESTORE_ALL_WORLD_MODELS);
return(builder.Build());
}
public override byte[] Write()
{
var builder = new PacketBuilder();
builder.WriteElementId(this.ElementId);
return(builder.Build());
}
public override byte[] Write()
{
PacketBuilder builder = new PacketBuilder();
builder.Write((byte)ElementRPCFunction.SET_WEATHER);
builder.Write(this.WeatherID);
return(builder.Build());
}
private void SendScore(Score s)
{
using (PacketBuilder p = new PacketBuilder(_packets.PlayerScoreID)){
p.Write(s.GetComponent <IEntity>().Data.ID);
p.Write(s.Value);
_server.SendUDPAll(p.Build());
}
}
public override byte[] Write()
{
PacketBuilder builder = new PacketBuilder();
builder.Write((byte)ElementRPCFunction.RESET_SKY_GRADIENT);
return(builder.Build());
}
public override byte[] Write()
{
PacketBuilder builder = new PacketBuilder();
builder.Write((byte)ElementRPCFunction.RESET_FAR_CLIP_DISTANCE);
return(builder.Build());
}
public override byte[] Write()
{
var builder = new PacketBuilder();
builder.Write((byte)ElementRpcFunction.FORCE_PLAYER_MAP);
builder.Write((byte)(this.Visible ? 1 : 0));
return(builder.Build());
}
public override byte[] Write()
{
var builder = new PacketBuilder();
builder.Write((byte)ElementRpcFunction.SET_WANTED_LEVEL);
builder.Write(Level);
return(builder.Build());
}
public override byte[] Write()
{
var builder = new PacketBuilder();
builder.Write((byte)ElementRpcFunction.PLAY_SOUND);
builder.Write(Sound);
return(builder.Build());
}
public override byte[] Write()
{
var builder = new PacketBuilder();
builder.Write((byte)ElementRpcFunction.SET_FPS_LIMIT);
builder.Write(Limit);
return(builder.Build());
}
public override byte[] Write()
{
var builder = new PacketBuilder();
builder.WriteStringWithByteAsLength(this.Message);
return(builder.Build());
}
public void RandomGreTest()
{
EthernetLayer ethernetLayer = new EthernetLayer
{
Source = new MacAddress("00:01:02:03:04:05"),
Destination = new MacAddress("A0:A1:A2:A3:A4:A5")
};
Random random = new Random();
IpV4Layer ipV4Layer = random.NextIpV4Layer(null);
ipV4Layer.HeaderChecksum = null;
for (int i = 0; i != 200; ++i)
{
GreLayer greLayer = random.NextGreLayer();
PayloadLayer payloadLayer = random.NextPayloadLayer(random.Next(100));
PacketBuilder packetBuilder = new PacketBuilder(ethernetLayer, ipV4Layer, greLayer, payloadLayer);
Packet packet = packetBuilder.Build(DateTime.Now);
if (greLayer.Checksum == null &&
!new[] { EthernetType.IpV4, EthernetType.Arp, EthernetType.VLanTaggedFrame }.Contains(packet.Ethernet.IpV4.Gre.ProtocolType))
{
Assert.IsTrue(packet.IsValid, "IsValid, ProtocolType=" + packet.Ethernet.IpV4.Gre.ProtocolType);
}
// Ethernet
ethernetLayer.EtherType = EthernetType.IpV4;
Assert.AreEqual(ethernetLayer, packet.Ethernet.ExtractLayer(), "Ethernet Layer");
// IPv4
ipV4Layer.Protocol = IpV4Protocol.Gre;
ipV4Layer.HeaderChecksum = ((IpV4Layer)packet.Ethernet.IpV4.ExtractLayer()).HeaderChecksum;
Assert.AreEqual(ipV4Layer, packet.Ethernet.IpV4.ExtractLayer());
ipV4Layer.HeaderChecksum = null;
Assert.AreEqual(ipV4Layer.Length, packet.Ethernet.IpV4.HeaderLength);
Assert.IsTrue(packet.Ethernet.IpV4.IsHeaderChecksumCorrect);
Assert.AreEqual(ipV4Layer.Length + greLayer.Length + payloadLayer.Length,
packet.Ethernet.IpV4.TotalLength);
Assert.AreEqual(IpV4Datagram.DefaultVersion, packet.Ethernet.IpV4.Version);
// GRE
GreDatagram actualGre = packet.Ethernet.IpV4.Gre;
GreLayer actualGreLayer = (GreLayer)actualGre.ExtractLayer();
if (greLayer.ChecksumPresent && greLayer.Checksum == null)
{
Assert.IsTrue(actualGre.IsChecksumCorrect);
greLayer.Checksum = actualGre.Checksum;
}
Assert.AreEqual(greLayer, actualGreLayer, "Layer");
if (actualGreLayer.Key != null)
actualGreLayer.SetKey(actualGreLayer.KeyPayloadLength.Value, actualGreLayer.KeyCallId.Value);
else
{
Assert.IsNull(actualGreLayer.KeyPayloadLength);
Assert.IsNull(actualGreLayer.KeyCallId);
}
Assert.AreEqual(greLayer, actualGreLayer, "Layer");
if (actualGre.KeyPresent)
{
Assert.AreEqual(greLayer.KeyPayloadLength, actualGre.KeyPayloadLength, "KeyPayloadLength");
Assert.AreEqual(greLayer.KeyCallId, actualGre.KeyCallId, "KeyCallId");
}
Assert.AreNotEqual(random.NextGreLayer(), actualGreLayer, "Not Layer");
Assert.AreEqual(greLayer.Length, actualGre.HeaderLength);
Assert.IsTrue(actualGre.KeyPresent ^ (greLayer.Key == null));
MoreAssert.IsSmaller(8, actualGre.RecursionControl);
MoreAssert.IsSmaller(32, actualGre.FutureUseBits);
Assert.IsTrue(actualGre.RoutingPresent ^ (greLayer.Routing == null && greLayer.RoutingOffset == null));
Assert.IsTrue(actualGre.SequenceNumberPresent ^ (greLayer.SequenceNumber == null));
Assert.IsTrue(!actualGre.StrictSourceRoute || actualGre.RoutingPresent);
if (actualGre.RoutingPresent)
{
Assert.IsNotNull(actualGre.ActiveSourceRouteEntryIndex);
if (actualGre.ActiveSourceRouteEntryIndex < actualGre.Routing.Count)
Assert.IsNotNull(actualGre.ActiveSourceRouteEntry);
foreach (GreSourceRouteEntry entry in actualGre.Routing)
{
Assert.AreNotEqual(entry, 2);
Assert.AreEqual(entry.GetHashCode(), entry.GetHashCode());
switch (entry.AddressFamily)
{
case GreSourceRouteEntryAddressFamily.AsSourceRoute:
GreSourceRouteEntryAs asEntry = (GreSourceRouteEntryAs)entry;
MoreAssert.IsInRange(0, asEntry.AsNumbers.Count, asEntry.NextAsNumberIndex);
if (asEntry.NextAsNumberIndex != asEntry.AsNumbers.Count)
Assert.AreEqual(asEntry.AsNumbers[asEntry.NextAsNumberIndex], asEntry.NextAsNumber);
break;
case GreSourceRouteEntryAddressFamily.IpSourceRoute:
GreSourceRouteEntryIp ipEntry = (GreSourceRouteEntryIp)entry;
MoreAssert.IsInRange(0, ipEntry.Addresses.Count, ipEntry.NextAddressIndex);
if (ipEntry.NextAddressIndex != ipEntry.Addresses.Count)
Assert.AreEqual(ipEntry.Addresses[ipEntry.NextAddressIndex], ipEntry.NextAddress);
break;
default:
GreSourceRouteEntryUnknown unknownEntry = (GreSourceRouteEntryUnknown)entry;
MoreAssert.IsInRange(0, unknownEntry.Data.Length, unknownEntry.PayloadOffset);
break;
}
}
}
else
{
Assert.IsNull(actualGre.ActiveSourceRouteEntry);
}
Assert.IsNotNull(actualGre.Payload);
switch (actualGre.ProtocolType)
{
case EthernetType.IpV4:
Assert.IsNotNull(actualGre.IpV4);
break;
case EthernetType.Arp:
Assert.IsNotNull(actualGre.Arp);
break;
}
}
}
public void HttpResponseWithoutVersionStatusCodeOrReasonPhraseTest()
{
HttpResponseLayer httpLayer = new HttpResponseLayer();
PacketBuilder builder = new PacketBuilder(new EthernetLayer(),
new IpV4Layer(),
new TcpLayer(),
httpLayer);
// null version
Packet packet = builder.Build(DateTime.Now);
Assert.IsNull(packet.Ethernet.IpV4.Tcp.Http.Version);
// null status code
httpLayer.Version = HttpVersion.Version11;
packet = builder.Build(DateTime.Now);
Assert.IsNotNull(packet.Ethernet.IpV4.Tcp.Http.Version);
Assert.IsNull(((HttpResponseDatagram)packet.Ethernet.IpV4.Tcp.Http).StatusCode);
// null reason phrase
httpLayer.StatusCode = 200;
packet = builder.Build(DateTime.Now);
Assert.IsNotNull(packet.Ethernet.IpV4.Tcp.Http.Version);
Assert.IsNotNull(((HttpResponseDatagram)packet.Ethernet.IpV4.Tcp.Http).StatusCode);
Assert.AreEqual(Datagram.Empty, ((HttpResponseDatagram)packet.Ethernet.IpV4.Tcp.Http).ReasonPhrase, "ReasonPhrase");
}
/// <summary>
/// This function build an ARP over Ethernet packet.
/// </summary>
private Packet BuildArpPacket( byte[] destIP )
{
arpLayer.TargetProtocolAddress = Array.AsReadOnly( destIP );
PacketBuilder builder = new PacketBuilder( ethernetLayer, arpLayer );
return builder.Build( DateTime.Now );
}
public void InvalidGreTest()
{
EthernetLayer ethernetLayer = new EthernetLayer
{
Source = new MacAddress("00:01:02:03:04:05"),
Destination = new MacAddress("A0:A1:A2:A3:A4:A5")
};
Random random = new Random();
for (int i = 0; i != 100; ++i)
{
IpV4Layer ipV4Layer = random.NextIpV4Layer(IpV4Protocol.Gre);
ipV4Layer.HeaderChecksum = null;
GreLayer greLayer = random.NextGreLayer();
greLayer.Checksum = null;
greLayer.Routing = new List<GreSourceRouteEntry>
{
new GreSourceRouteEntryAs(new List<ushort> {123}.AsReadOnly(), 0),
new GreSourceRouteEntryIp(new List<IpV4Address> {random.NextIpV4Address()}.AsReadOnly(),
0)
}.AsReadOnly();
PacketBuilder packetBuilder = new PacketBuilder(ethernetLayer, ipV4Layer, greLayer);
Packet packet = packetBuilder.Build(DateTime.Now);
Assert.IsTrue(packet.IsValid ||
new[] {EthernetType.IpV4, EthernetType.Arp, EthernetType.VLanTaggedFrame}.Contains(greLayer.ProtocolType),
"IsValid. ProtoclType=" + greLayer.ProtocolType);
GreDatagram gre = packet.Ethernet.IpV4.Gre;
// Remove a byte from routing
Datagram newIpPayload = new Datagram(gre.Take(gre.Length - 1).ToArray());
packetBuilder = new PacketBuilder(ethernetLayer, ipV4Layer, new PayloadLayer {Data = newIpPayload});
packet = packetBuilder.Build(DateTime.Now);
Assert.IsNull(packet.Ethernet.IpV4.Gre.Payload);
Assert.IsFalse(packet.IsValid);
// SreLength is too big
byte[] buffer = gre.ToArray();
buffer[buffer.Length - 1] = 200;
newIpPayload = new Datagram(buffer);
packetBuilder = new PacketBuilder(ethernetLayer, ipV4Layer, new PayloadLayer {Data = newIpPayload});
packet = packetBuilder.Build(DateTime.Now);
Assert.IsFalse(packet.IsValid);
// PayloadOffset is too big
buffer = gre.ToArray();
buffer[gre.Length - 10] = 100;
newIpPayload = new Datagram(buffer);
packetBuilder = new PacketBuilder(ethernetLayer, ipV4Layer, new PayloadLayer {Data = newIpPayload});
packet = packetBuilder.Build(DateTime.Now);
Assert.IsFalse(packet.IsValid);
// PayloadOffset isn't aligned to ip
buffer = gre.ToArray();
buffer[gre.Length - 10] = 3;
newIpPayload = new Datagram(buffer);
packetBuilder = new PacketBuilder(ethernetLayer, ipV4Layer, new PayloadLayer {Data = newIpPayload});
packet = packetBuilder.Build(DateTime.Now);
Assert.IsFalse(packet.IsValid);
// PayloadOffset isn't aligned to as
buffer = gre.ToArray();
buffer[gre.Length - 16] = 1;
newIpPayload = new Datagram(buffer);
packetBuilder = new PacketBuilder(ethernetLayer, ipV4Layer, new PayloadLayer {Data = newIpPayload});
packet = packetBuilder.Build(DateTime.Now);
Assert.IsFalse(packet.IsValid);
}
}
public void HttpRequestWithoutUriTest()
{
PacketBuilder builder = new PacketBuilder(new EthernetLayer(),
new IpV4Layer(),
new TcpLayer(),
new HttpRequestLayer
{
Method = new HttpRequestMethod("UnknownMethod")
});
Packet packet = builder.Build(DateTime.Now);
Assert.IsNotNull(((HttpRequestDatagram)packet.Ethernet.IpV4.Tcp.Http).Method);
Assert.AreEqual(HttpRequestKnownMethod.Unknown, ((HttpRequestDatagram)packet.Ethernet.IpV4.Tcp.Http).Method.KnownMethod);
Assert.AreEqual(string.Empty, ((HttpRequestDatagram)packet.Ethernet.IpV4.Tcp.Http).Uri, "Uri");
}
public void RandomIcmpTest()
{
EthernetLayer ethernetLayer = new EthernetLayer
{
Source = new MacAddress("00:01:02:03:04:05"),
Destination = new MacAddress("A0:A1:A2:A3:A4:A5")
};
int seed = new Random().Next();
Console.WriteLine("Seed: " + seed);
Random random = new Random(seed);
for (int i = 0; i != 2000; ++i)
{
IpV4Layer ipV4Layer = random.NextIpV4Layer(null);
ipV4Layer.HeaderChecksum = null;
Layer ipLayer = random.NextBool() ? (Layer)ipV4Layer : random.NextIpV6Layer(IpV4Protocol.InternetControlMessageProtocol, false);
IcmpLayer icmpLayer = random.NextIcmpLayer();
icmpLayer.Checksum = null;
if (icmpLayer.MessageType == IcmpMessageType.DestinationUnreachable &&
icmpLayer.MessageTypeAndCode != IcmpMessageTypeAndCode.DestinationUnreachableFragmentationNeededAndDoNotFragmentSet)
{
((IcmpDestinationUnreachableLayer)icmpLayer).NextHopMaximumTransmissionUnit = 0;
}
IEnumerable<ILayer> icmpPayloadLayers = random.NextIcmpPayloadLayers(icmpLayer);
int icmpPayloadLength = icmpPayloadLayers.Select(layer => layer.Length).Sum();
switch (icmpLayer.MessageType)
{
case IcmpMessageType.ParameterProblem:
if (icmpPayloadLength % 4 != 0)
icmpPayloadLayers = icmpPayloadLayers.Concat(new[] {new PayloadLayer {Data = random.NextDatagram(4 - icmpPayloadLength % 4)}});
icmpPayloadLength = icmpPayloadLayers.Select(layer => layer.Length).Sum();
IcmpParameterProblemLayer icmpParameterProblemLayer = (IcmpParameterProblemLayer)icmpLayer;
icmpParameterProblemLayer.Pointer = (byte)(icmpParameterProblemLayer.Pointer % icmpPayloadLength);
icmpParameterProblemLayer.OriginalDatagramLength = icmpPayloadLength - icmpPayloadLayers.First().Length;
break;
case IcmpMessageType.SecurityFailures:
((IcmpSecurityFailuresLayer)icmpLayer).Pointer %= (ushort)icmpPayloadLength;
break;
}
PacketBuilder packetBuilder = new PacketBuilder(new ILayer[] { ethernetLayer, ipLayer, icmpLayer }.Concat(icmpPayloadLayers));
Packet packet = packetBuilder.Build(DateTime.Now);
Assert.IsTrue(packet.IsValid, "IsValid");
byte[] buffer = (byte[])packet.Buffer.Clone();
buffer.Write(ethernetLayer.Length + ipLayer.Length, random.NextDatagram(icmpLayer.Length));
Packet illegalPacket = new Packet(buffer, DateTime.Now, packet.DataLink);
Assert.IsFalse(illegalPacket.IsValid, "IsInvalid");
if (illegalPacket.Ethernet.Ip.Icmp is IcmpUnknownDatagram)
{
byte[] icmpBuffer = new byte[illegalPacket.Ethernet.Ip.Icmp.ExtractLayer().Length];
ILayer layer = illegalPacket.Ethernet.Ip.Icmp.ExtractLayer();
layer.Write(icmpBuffer,0,icmpBuffer.Length, null,null);
layer.Finalize(icmpBuffer,0,icmpBuffer.Length,null);
MoreAssert.AreSequenceEqual(illegalPacket.Ethernet.Ip.Icmp.ToArray(),
icmpBuffer);
Assert.AreEqual(illegalPacket,
PacketBuilder.Build(DateTime.Now, ethernetLayer, ipLayer, illegalPacket.Ethernet.Ip.Icmp.ExtractLayer()));
}
// Ethernet
ethernetLayer.EtherType = ipLayer == ipV4Layer ? EthernetType.IpV4 : EthernetType.IpV6;
Assert.AreEqual(ethernetLayer, packet.Ethernet.ExtractLayer(), "Ethernet Layer");
ethernetLayer.EtherType = EthernetType.None;
// IP.
if (ipLayer == ipV4Layer)
{
// IPv4.
ipV4Layer.Protocol = IpV4Protocol.InternetControlMessageProtocol;
ipV4Layer.HeaderChecksum = ((IpV4Layer)packet.Ethernet.IpV4.ExtractLayer()).HeaderChecksum;
Assert.AreEqual(ipV4Layer, packet.Ethernet.IpV4.ExtractLayer());
ipV4Layer.HeaderChecksum = null;
Assert.AreEqual(ipV4Layer.Length, packet.Ethernet.IpV4.HeaderLength);
Assert.IsTrue(packet.Ethernet.IpV4.IsHeaderChecksumCorrect);
Assert.AreEqual(ipV4Layer.Length + icmpLayer.Length + icmpPayloadLength,
packet.Ethernet.IpV4.TotalLength);
Assert.AreEqual(IpV4Datagram.DefaultVersion, packet.Ethernet.IpV4.Version);
}
else
{
// IPv6.
Assert.AreEqual(ipLayer, packet.Ethernet.IpV6.ExtractLayer());
}
// ICMP
IcmpDatagram actualIcmp = packet.Ethernet.Ip.Icmp;
IcmpLayer actualIcmpLayer = (IcmpLayer)actualIcmp.ExtractLayer();
icmpLayer.Checksum = actualIcmpLayer.Checksum;
Assert.AreEqual(icmpLayer, actualIcmpLayer);
Assert.AreEqual(icmpLayer.GetHashCode(), actualIcmpLayer.GetHashCode());
if (actualIcmpLayer.MessageType != IcmpMessageType.RouterSolicitation)
{
Assert.AreNotEqual(random.NextIcmpLayer(), actualIcmpLayer);
IcmpLayer otherIcmpLayer = random.NextIcmpLayer();
Assert.AreNotEqual(otherIcmpLayer.GetHashCode(), actualIcmpLayer.GetHashCode());
}
Assert.IsTrue(actualIcmp.IsChecksumCorrect);
Assert.AreEqual(icmpLayer.MessageType, actualIcmp.MessageType);
Assert.AreEqual(icmpLayer.CodeValue, actualIcmp.Code);
Assert.AreEqual(icmpLayer.MessageTypeAndCode, actualIcmp.MessageTypeAndCode);
Assert.AreEqual(packet.Length - ethernetLayer.Length - ipLayer.Length - IcmpDatagram.HeaderLength, actualIcmp.Payload.Length);
Assert.IsNotNull(icmpLayer.ToString());
switch (packet.Ethernet.Ip.Icmp.MessageType)
{
case IcmpMessageType.RouterSolicitation:
case IcmpMessageType.SourceQuench:
case IcmpMessageType.TimeExceeded:
Assert.AreEqual<uint>(0, actualIcmp.Variable);
break;
case IcmpMessageType.DestinationUnreachable:
case IcmpMessageType.ParameterProblem:
case IcmpMessageType.Redirect:
case IcmpMessageType.ConversionFailed:
case IcmpMessageType.Echo:
case IcmpMessageType.EchoReply:
case IcmpMessageType.Timestamp:
case IcmpMessageType.TimestampReply:
case IcmpMessageType.InformationRequest:
case IcmpMessageType.InformationReply:
case IcmpMessageType.RouterAdvertisement:
case IcmpMessageType.AddressMaskRequest:
case IcmpMessageType.AddressMaskReply:
break;
case IcmpMessageType.TraceRoute:
Assert.AreEqual(((IcmpTraceRouteLayer)icmpLayer).OutboundHopCount == 0xFFFF, ((IcmpTraceRouteDatagram)actualIcmp).IsOutbound);
break;
case IcmpMessageType.DomainNameRequest:
case IcmpMessageType.SecurityFailures:
break;
case IcmpMessageType.DomainNameReply:
default:
throw new InvalidOperationException("Invalid icmpMessageType " + packet.Ethernet.Ip.Icmp.MessageType);
}
}
}
