流量转发的应用与实现
在安全领域，流量转发有许多应用，本文简单举例一些使用场景，以及自己用代码实现高效转发流量
内网穿透端口转发代理跳板反向代理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代理的两种情况代码语言：javascript代码运行次数：0运行复制// 普通代理
GET http://null.com/ HTTP/1.1
Host: null.com代码语言：javascript代码运行次数：0运行复制// 隧道代理，往往用于HTTPS
// client
CONNECT null.com:443 HTTP/1.1
Host: null.com:443
// server
HTTP/1.1 200 Connection Established这两种代理的情况都很容易代码实现目标主机的解析，然后代理只需连接目标主机，接着转发两端流量即可
socks5代理自己实现一个极简socks5代理解析，Golang实现：
代码语言：javascript代码运行次数：0运行复制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
反向代理Nginx的服务器反代Tcp层面的流量过滤器etc.流量转发的其他用处：
很多大学抢课都是一大难题，我曾经写过抢课的脚本，但最终也无法做到在抢课开始的时间点进行秒杀（类似某东购物秒杀），原因是学校服务器扛不住过大的并发量，所以最后的抢课脚本只能起到监控抢课的作用
而后我想到新的思路：
在抢课开始时间点前与教务系统建立4-8个Tcp连接（HTTP 1.1长连接可复用Tcp通道，这里是为并发量考虑），维护一个连接池，当时间点来到时直接发送Http报文即可。但这样做有一个问题，我们需要发送原始的Tcp报文，也就是拿原始Tcp socket来完成我们的请求而不是requests这种好用的库，所以，我们需要一个流量转发的代理
假如我使用socks5代理：
首先我建立一个Tcp连接池当开始抢课时，依然使用requests发请求，但代理设置为socks5代理本地socks5代理解析客户端的socks5请求（其实不算解析，应答即可，最终目标主机都是教务系统），从连接池中选取一个连接，socks5过程结束后只需无脑转发两端流量即可流量转发的代码实现简单的流量转发代码实现其实并不难，但我们需要考虑一下因素
效率并发关闭socketsocket通信中，有以下几处操作会阻塞：
server acceptclient connectrecieve需要注意的是，send不会阻塞，它只负责将数据拷贝到Tcp协议栈就返回
在上述几处阻塞的地方，假如不加处理，那么写出来的转发代理一次只能处理一个连接，效率未免太低，所以我们可以选择：
select/poll/epoll I/O多路复用coroutinemulti-threadmulti-process后两种当然会排除，因为它们太重了
Python实现前两种选择的主体函数如下，思路是哪个socket可读就往另一个socket写，直到一方断开连接
代码语言：javascript代码运行次数：0运行复制# 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)代码语言：javascript代码运行次数：0运行复制# 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的流量转发实现就更简单了：
代码语言：javascript代码运行次数：0运行复制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则是断开连接）
End