(adsbygoogle = window.adsbygoogle || []).push({}); This class was made to easily handle the sending and receiving of TCP and UDP packets, here ya go:

    using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Net.Sockets;

using System.Net;



namespace Packets

{

    public class Packet : IDisposable

    {

        private IPEndPoint ipe;



        private UdpClient udpClient;

        private TcpClient tcpClient;



        public Packet(IPAddress IP, int port)

        {

            ipe = new IPEndPoint(IP, port);



            udpClient = new UdpClient();

            tcpClient = new TcpClient();



            udpClient.Connect(IP, port);

            tcpClient.Connect(IP, port);

        }



        public Packet(String ip, int port) : 

            this(IPAddress.Parse(ip), port) {  }



        public void Close()

        {

            udpClient.Close();

            tcpClient.Close();

        }



        public void Dispose()

        {

            udpClient.Close();

            udpClient = null;



            tcpClient.Close();

            tcpClient = null;



            GC.SuppressFinalize(this);

        }



        public byte[] Receive(ReceivePacketType type)

        {

            byte[] buffer;

            List<ArraySegment<byte>> bytes = new List<ArraySegment<byte>>();



            if (type == ReceivePacketType.TCP)

            {

                tcpClient.Client.Receive(bytes);

                List<byte> bytez = new List<byte>();



                foreach (var asb in bytes)

                    for (int i = asb.Offset; i < (asb.Offset + asb.Count); i++)

                        bytez.Add(asb.Array[i]);



                buffer = bytez.ToArray();

                

            }



            else

                buffer = udpClient.Receive(ref ipe);



            return buffer;

        }



        public void SendUDPPacket(byte[] data, uint address)

        {

            List<byte> packet = new List<byte>();

            packet.AddRange(BitConverter.GetBytes((int)address));

            packet.AddRange(BitConverter.GetBytes(data.Length));

            packet.AddRange(data);

            udpClient.Send(packet.ToArray(), packet.Count);

        }



        public void SendUDPPacket(short data, uint address)

        {

            SendUDPPacket(

                BitConverter.GetBytes(data), address);

        }



        public void SendUDPPacket(int data, uint address)

        {

            SendUDPPacket(

                BitConverter.GetBytes(data), address);

        }



        public void SendUDPPacket(long data, uint address)

        {

            SendUDPPacket(

                BitConverter.GetBytes(data), address);

        }



        public void SendUDPPacket(ushort data, uint address)

        {

            SendUDPPacket(

                BitConverter.GetBytes(data), address);

        }



        public void SendUDPPacket(uint data, uint address)

        {

            SendUDPPacket(

                BitConverter.GetBytes(data), address);

        }



        public void SendUDPPacket(ulong data, uint address)

        {

            SendUDPPacket(

                BitConverter.GetBytes(data), address);

        }



        public void SendUDPPacket(char data, uint address)

        {

            SendUDPPacket(

                BitConverter.GetBytes(data), address);

        }



        public void SendUDPPacket(bool data, uint address)

        {

            SendUDPPacket(

                BitConverter.GetBytes(data), address);

        }



        public void SendUDPPacket(float data, uint address)

        {

            SendUDPPacket(

                BitConverter.GetBytes(data), address);

        }



        public void SendUDPPacket(double data, uint address)

        {

            SendUDPPacket(

                BitConverter.GetBytes(data), address);

        }



        public void SendTCPPacket(byte[] data)

        {

            Socket socket = tcpClient.Client;

            socket.Send(data);

            socket.Dispose();

        } 



        public void SendTCPPacket(short data)

        {

            SendTCPPacket(

                BitConverter.GetBytes(data));

        }



        public void SendTCPPacket(int data)

        {

            SendTCPPacket(

                BitConverter.GetBytes(data));

        }



        public void SendTCPPacket(long data)

        {

            SendTCPPacket(

                BitConverter.GetBytes(data));

        }



        public void SendTCPPacket(ushort data)

        {

            SendTCPPacket(

                BitConverter.GetBytes(data));

        }



        public void SendTCPPacket(uint data)

        {

            SendTCPPacket(

                BitConverter.GetBytes(data));

        }



        public void SendTCPPacket(ulong data)

        {

            SendTCPPacket(

                BitConverter.GetBytes(data));

        }



        public void SendTCPPacket(char data)

        {

            SendTCPPacket(

                BitConverter.GetBytes(data));

        }



        public void SendTCPPacket(bool data)

        {

            SendTCPPacket(

                BitConverter.GetBytes(data));

        }



        public void SendTCPPacket(float data)

        {

            SendTCPPacket(

                BitConverter.GetBytes(data));

        }



        public void SendTCPPacket(double data)

        {

            SendTCPPacket(

                BitConverter.GetBytes(data));

        }



        public override string ToString()

        {

            return udpClient.ToString() +

                "\n" +

                tcpClient.ToString();

        }

    }



    public enum ReceivePacketType

    {

        TCP,

        UDP

    }

}

Didn't windows drop support for RAW packets in 2004, since they where being abused? I thought you have to import some networking libraries other than windows ones to be able to manage it?

Nope, not at all, they just started managing how packets are handled more properly, when assembling and managing the packet, they check the data size and see if it matches the size within the second four byte of the header and if it's not matched then it drops the packet. There are more checks involved to prevent specific overflows and what not but that's essentially what they do, but no, you can still send raw packets.