List [CTL]
首发于安恒公众号
- 内网穿透
- 端口转发
- 代理跳板
- 反向代理
- etc.
内网穿透
当使用MSF生成诸如reverse_tcp等payload时，往往自己的主机处于NAT中，有以下三种方法接收到返回的shell：
- 用有公网IP的服务器监听反弹的shell
- 设置网关的端口映射
- 内网穿透
第一种方法很简单，可服务器需要安装一系列利用工具，不如自己主机方便
第二种方法在简单的网络环境中是可行的，比如家庭的网络（假设家庭有一个公网IP），只需设置网关的端口映射，比如将公网IP的12345端口转发到内网主机的2333端口。但假如主机处于不止一层的NAT下（比如很多大学寝室），端口映射就行不通了
第三种内网穿透的方法就是要介绍的，使用frp/ngrok等工具
内网穿透的原理：
有公网IP的服务器将流量通过Tcp长连接转发到处于内网的某个主机中
内网穿透的实现：
假设公网IP为222.x.x.x，监听客户端连接的port为2333，监听shell连接的port为12345
客户端将shell转发至本机的4444端口
- 公网服务器listen 222.x.x.x:2333等待客户端连接
- 公网服务器listen 222.x.x.x:12345等待受害者连接
- 客户端connect->222.x.x.x:2333
- 客户端connect->127.0.0.1:4444
- 公网服务器和客户端现在都handle两个socket
- 当shell反弹至公网服务器12345端口时，公网服务器转发Tcp流量到:2333的socket，内网主机此时接收到222.x.x.x:2333的tcp流量，将其转发至127.0.0.1:4444端口
- 一直双向转发流量直到某一方reset connection
端口转发
端口转发在内网渗透中经常被使用，假设以下场景：
- 受害者主机开启了Redis/MySQL/RDP等服务，但只监听了127.0.0.1
- 受害者主机所在内网存在主机群，但无法连接公网
这时，假如我们已经获得受害主机的控制权，就可以利用端口转发，将无法访问的主机端口抓发到公网服务器。或将内网中无法访问的主机端口转发到已控制主机的某些端口，具体的实现与内网穿透转发Tcp流量类似
lcx工具、ssh、netsh等都有转发的功能，都可在此场景下利用
代理跳板
这个最容易理解，利用某些主机作代理，转发我们的流量，达到隐藏自身/漫游内网的目的
场景：
- 获得某些主机控制权后，将其作为跳板来转发我们的流量
- t0r(0ni0n)的socks4代理
- $$r(小飞机)的socks5代理
当然，在转发的过程中需要解析请求，假设是转发http流量的话，可以使用http代理协议/socks代理协议来解析
- http代理的两种情况
// 普通代理
GET http://null.com/ HTTP/1.1
Host: null.com
// 隧道代理，往往用于HTTPS
// client
CONNECT null.com:443 HTTP/1.1
Host: null.com:443
// server
HTTP/1.1 200 Connection Established
这两种代理的情况都很容易代码实现目标主机的解析，然后代理只需连接目标主机，接着转发两端流量即可
socks5代理
自己实现一个极简socks5代理解析，Golang实现：
func parseSocks5(conn net.Conn) { buf := make([]byte, 256) n, err := conn.Read(buf) handleErr(err) if buf[0] != 0x05 || n < 3 { conn.Close() return } n, err = conn.Write([]byte{0x05, 0x00}) handleErr(err) n, err = conn.Read(buf) handleErr(err) if buf[0] != 0x05 || buf[1] != 0x01 { conn.Close() return } var host []byte var port int switch buf[3] { // IPv4 case 0x01: host = buf[4 : n-2] // domain case 0x03: length := buf[4] addr, err := net.ResolveIPAddr("ip", string(buf[5:5+length])) handleErr(err) host = addr.IP // IPv6 case 0x04: host = buf[4 : n-2] } port = (int(buf[n-2]) << 8) + int(buf[n-1]) tAddr := &net.TCPAddr{ IP: host, Port: port, } dstConn, err := net.DialTCP("tcp", nil, tAddr) if err != nil { conn.Close() return } conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}) forward(conn, dstConn) }完整的socks5代理细节请参考RFC1928
除了简单直白的代理转发，我们还可以加上一些加密混淆，这便是$$r的原理了，在client/server端各建立一个proxy，这两个proxy的职责就是对两端socket的流量进行加密与解密，以此达到绕过G*W的目的
反向代理
- Nginx的服务器反代
- Tcp层面的流量过滤器
etc.
流量转发的其他用处：
很多大学抢课都是一大难题，我曾经写过抢课的脚本，但最终也无法做到在抢课开始的时间点进行秒杀（类似某东购物秒杀），原因是学校服务器扛不住过大的并发量，所以最后的抢课脚本只能起到监控抢课的作用
而后我想到新的思路：
在抢课开始时间点前与教务系统建立4-8个Tcp连接（HTTP 1.1长连接可复用Tcp通道，这里是为并发量考虑），维护一个连接池，当时间点来到时直接发送Http报文即可。但这样做有一个问题，我们需要发送原始的Tcp报文，也就是拿原始Tcp socket来完成我们的请求而不是requests这种好用的库，所以，我们需要一个流量转发的代理
假如我使用socks5代理：
- 首先我建立一个Tcp连接池
- 当开始抢课时，依然使用requests发请求，但代理设置为本地的socks5代理
- 本地socks5代理解析客户端的socks5请求（其实不算解析，正常应答完成握手过程即可，反正最终目标主机都是教务系统），然后从连接池中选取一个连接，socks5握手结束后只需无脑转发两端流量即可
流量转发的代码实现
简单的流量转发代码实现其实并不难，但我们需要考虑一下因素
- 效率
- 并发
- 关闭socket
socket通信中，有以下几处操作会阻塞：
- server accept
- client connect
- recieve
需要注意的是，send不会阻塞，它只负责将数据拷贝到Tcp协议栈就返回
在上述几处阻塞的地方，假如不加处理，那么写出来的转发代理一次只能处理一个连接，效率未免太低，所以我们可以选择：
- select/poll/epoll I/O多路复用
- coroutine
- multi-thread
- multi-process
后两种当然会排除，因为它们太重了
Python实现前两种选择的主体函数如下，思路是哪个socket可读就往另一个socket写，直到一方断开连接
# I/O多路复用
def proxy_pass(server):
client_conn, addr = server.accept()
print(f'[+]get client {addr[0]}:{addr[1]}')
client_conn.setblocking(False)
# set socket SO_LINGER, to make sure closing socket
client_conn.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
struct.pack('ii', 1, 0))
socks5_conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socks5_conn.setblocking(False)
socks5_conn.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
struct.pack('ii', 1, 0))
try:
socks5_conn.connect(('127.0.0.1', 1080))
except BlockingIOError:
pass
done = False
def on_socks_connected():
s.unregister(socks5_conn)
s.register(client_conn, selectors.EVENT_READ, client_2_socks5)
s.register(socks5_conn, selectors.EVENT_READ, socks5_2_client)
def client_2_socks5():
nonlocal done
if done:
s.unregister(client_conn)
client_conn.close()
return
try:
data = client_conn.recv(4096)
if data:
socks5_conn.sendall(data)
else:
done = True
except (BlockingIOError, ConnectionResetError):
done = True
def socks5_2_client():
nonlocal done
if done:
s.unregister(socks5_conn)
socks5_conn.close()
return
try:
data = socks5_conn.recv(4096)
if data:
client_conn.sendall(data)
else:
done = True
except (BlockingIOError, ConnectionResetError):
done = True
s.register(socks5_conn, selectors.EVENT_WRITE, on_socks_connected)
# coroutine
async def proxy_pass(reader, writer):
socks_r, socks_w = await asyncio.open_connection('127.0.0.1', 1080)
async def a_2_b(reader, writer):
data = await reader.read(4096)
while 1:
try:
if data:
writer.write(data)
await writer.drain()
data = await reader.read(4096)
else:
writer.close()
break
except ConnectionResetError:
writer.close()
break
asyncio.run_coroutine_threadsafe(a_2_b(reader, socks_w), loop)
asyncio.run_coroutine_threadsafe(a_2_b(socks_r, writer), loop)
完整的代码见https://gist.github.com/EddieIvan01/24e54513ab416f6025a575bd8fa1673e
还有Golang的流量转发实现就更简单了：
func forward(conn1 net.Conn, conn2 net.Conn) {
defer conn1.Close()
defer conn2.Close()
var wg sync.WaitGroup
wg.Add(2)
go func(src net.Conn, dst net.Conn) {
defer wg.Done()
io.Copy(dst, src)
}(conn1, conn2)
go func(src net.Conn, dst net.Conn) {
defer wg.Done()
io.Copy(dst, src)
}(conn2, conn1)
wg.Wait()
}
io.Copy是标准库中文件拷贝函数，正常它会一直循环读取8*1024的字节块直到EOF（针对socket则是断开连接）