在安全领域,流量转发有许多应用,本文简单举例一些使用场景,以及自己用代码实现高效转发流量
当使用MSF生成诸如reverse_tcp等payload时,往往自己的主机处于NAT中,有以下三种方法接收到返回的shell:
第一种方法很简单,可服务器需要安装一系列利用工具,不如自己主机方便
第二种方法在简单的网络环境中是可行的,比如家庭的网络(假设家庭有一个公网IP),只需设置网关的端口映射,比如将公网IP的12345端口转发到内网主机的2333端口。但假如主机处于不止一层的NAT下(比如很多大学寝室),端口映射就行不通了
第三种内网穿透的方法就是要介绍的,frp/ngrok等工具便是相关的工具
内网穿透的原理:
有公网IP的服务器将流量通过Tcp长连接转发到处于内网的某个主机中
内网穿透的实现:
假设公网IP为222.x.x.x,监听客户端连接的port为2333,监听shell连接的port为12345
客户端将shell转发至本机的4444端口
端口转发在内网渗透中经常被使用,假设以下场景:
这时,假如我们已经获得受害主机的控制权,就可以利用端口转发,将无法访问的主机端口抓发到公网服务器。或将内网中无法访问的主机端口转发到已控制主机的某些端口,具体的实现与内网穿透转发Tcp流量类似
lcx工具、ssh、netsh等都有转发的功能,都可在此场景下利用
这个最容易理解,利用某些主机作代理,转发我们的流量,达到隐藏自身的目的
场景:
当然,在转发的过程中需要解析请求,假设是转发http流量的话,可以使用http代理协议/socks代理协议来解析
// 普通代理
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代理解析,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的目的
一个简单的实现可以参考我的项目https://github.com/EddieIvan01/iox
流量转发的其他用处:
很多大学抢课都是一大难题,我曾经写过抢课的脚本,但最终也无法做到在抢课开始的时间点进行秒杀(类似某东购物秒杀),原因是学校服务器扛不住过大的并发量,所以最后的抢课脚本只能起到监控抢课的作用
而后我想到新的思路:
在抢课开始时间点前与教务系统建立4-8个Tcp连接(HTTP 1.1长连接可复用Tcp通道,这里是为并发量考虑),维护一个连接池,当时间点来到时直接发送Http报文即可。但这样做有一个问题,我们需要发送原始的Tcp报文,也就是拿原始Tcp socket来完成我们的请求而不是requests这种好用的库,所以,我们需要一个流量转发的代理
假如我使用socks5代理:
简单的流量转发代码实现其实并不难,但我们需要考虑一下因素
socket通信中,有以下几处操作会阻塞:
需要注意的是,send不会阻塞,它只负责将数据拷贝到Tcp协议栈就返回
在上述几处阻塞的地方,假如不加处理,那么写出来的转发代理一次只能处理一个连接,效率未免太低,所以我们可以选择:
后两种当然会排除,因为它们太重了
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则是断开连接)