Python端口转发/多路复用服务器

我想让服务器侦听UDP端口162（SNMP陷阱），然后将此流量转发给多个客户端。同样重要的是源端口和地址保持不变（地址欺骗）

我想最好的工具是香草插座， 只是我在文档中找不到关于源地址欺骗/伪造的任何东西

有什么解决办法吗

---

编辑：添加了bounty，mybe，有没有使用iptables的解决方案？

我对twisted或scapy不太满意，但使用vanilla python套接字很简单。这样做的另一个好处是它将更加便携。此代码适用于我的有限测试：

#!/usr/bin/python
from socket import *
bufsize = 1024 # Modify to suit your needs
targetHost = "somehost.yourdomain.com"
listenPort = 1123

def forward(data, port):
    print "Forwarding: '%s' from port %s" % (data, port)
    sock = socket(AF_INET, SOCK_DGRAM)
    sock.bind(("localhost", port)) # Bind to the port data came in on
    sock.sendto(data, (targetHost, listenPort))

def listen(host, port):
    listenSocket = socket(AF_INET, SOCK_DGRAM)
    listenSocket.bind((host, port))
    while True:
        data, addr = listenSocket.recvfrom(bufsize)
        forward(data, addr[1]) # data and port

listen("localhost", listenPort)

---

一种不同但相关的转发端口解决方案，而不是多路复用（不回答具体问题，但希望匹配相关端口-这是我一直在寻找的）：

---

接受的答案对我不起作用，我最终使用了：

#/usr/bin/env python
导入套接字
导入线程
导入选择
导入系统
terminateAll=False
类ClientThread（threading.Thread）：
定义初始化（self、clientSocket、targetHost、targetPort）：
threading.Thread.\uuuuu init\uuuuuu（自）
self.\uu clientSocket=clientSocket
self.\uu targetHost=targetHost
self.\uuu targetPort=targetPort
def运行（自）：
打印“客户端线程已启动”
self.\u clientSocket.setblocking（0）
targetHostSocket=socket.socket（socket.AF\u INET，socket.SOCK\u流）
targetHostSocket.connect（（self.\u targetHost，self.\u targetPort））
targetHostSocket.setblocking（0）
clientData=“”
targetHostData=“”
终止=错误
当不终止和不终止时：
输入=[self.\u clientSocket，targetHostSocket]
输出=[]
如果len（clientData）>0：
outputs.append（self.\u clientSocket）
如果len（targetHostData）>0：
outputs.append（targetHostSocket）
尝试：
inputsReady，outputsReady，errorsReady=select.select（输入，输出，[]，1.0）
除例外情况外，e：
打印e
打破
对于inputsReady中的输入：
如果inp==self.\u客户端套接字：
尝试：
数据=self.\u clientSocket.recv（4096）
除例外情况外，e：
打印e
如果是数据！=无：
如果len（数据）>0：
targetHostData+=数据
其他：
终止=真
elif inp==targetHostSocket:
尝试：
数据=targetHostSocket.recv（4096）
除例外情况外，e：
打印e
如果是数据！=无：
如果len（数据）>0：
clientData+=数据
其他：
终止=真
对于输入输出重复：
如果out==self.\u clientSocket和len（clientData）>0：
BytesWrite=self.\uuuu clientSocket.send（clientData）
如果字节写入>0：
clientData=clientData[BytesWrited:]
elif out==targetHostSocket和len（targetHostData）>0:
BytesWrite=targetHostSocket.send（targetHostData）
如果字节写入>0：
targetHostData=targetHostData[BytesWrited:]
self.\u clientSocket.close（）
targetHostSocket.close（）
打印“ClienThread终止”
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
如果len（sys.argv）！=5:
打印“用法：\n\tpython SimpleTCPRedirector”
打印“示例：\n\tpython SimpleTCPRedirector localhost 8080 www.google.com 80”
系统出口（0）
localHost=sys.argv[1]
localPort=int（sys.argv[2]）
targetHost=sys.argv[3]
targetPort=int（sys.argv[4]）
serverSocket=socket.socket（socket.AF\u INET，socket.SOCK\u流）
绑定（（本地主机，本地端口））
serverSocket.listen（5）
打印“等待客户端…”
尽管如此：
尝试：
clientSocket，地址=serverSocket.accept（）
除键盘中断外：
打印“\n正在删除…”
terminateAll=True
打破
ClientThread（clientSocket、targetHost、targetPort）.start（）
serverSocket.close（）

有一件事我忘了在问题陈述的第一部分，我需要源服务器的源地址和端口（所以实际上服务器需要伪造源地址），socket能做到吗？不，不能。我认为您试图解决的问题可以通过一些iptables规则得到更好的解决。确切地说，为什么要使用python呢？顺便说一句，如果你能用twisted伪造数据包头，我会非常惊讶；斯卡皮可能是你最好的选择。我来看看有多困难好吧，斯帕皮来做。如果可以的话，我今晚会尝试写一个例子。iptables事实上我对iptables不太熟悉，所以我需要学习在iptables中实现这一点的新技能，因为我对python更感兴趣，所以我决定学习如何在python中实现这一点，目前我做得并不好；）

#!/usr/bin/env python

import socket
import threading
import select
import sys

terminateAll = False

class ClientThread(threading.Thread):
    def __init__(self, clientSocket, targetHost, targetPort):
        threading.Thread.__init__(self)
        self.__clientSocket = clientSocket
        self.__targetHost = targetHost
        self.__targetPort = targetPort

    def run(self):
        print "Client Thread started"

        self.__clientSocket.setblocking(0)

        targetHostSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        targetHostSocket.connect((self.__targetHost, self.__targetPort))
        targetHostSocket.setblocking(0)

        clientData = ""
        targetHostData = ""
        terminate = False
        while not terminate and not terminateAll:
            inputs = [self.__clientSocket, targetHostSocket]
            outputs = []

            if len(clientData) > 0:
                outputs.append(self.__clientSocket)

            if len(targetHostData) > 0:
                outputs.append(targetHostSocket)

            try:
                inputsReady, outputsReady, errorsReady = select.select(inputs, outputs, [], 1.0)
            except Exception, e:
                print e
                break

            for inp in inputsReady:
                if inp == self.__clientSocket:
                    try:
                        data = self.__clientSocket.recv(4096)
                    except Exception, e:
                        print e

                    if data != None:
                        if len(data) > 0:
                            targetHostData += data
                        else:
                            terminate = True
                elif inp == targetHostSocket:
                    try:
                        data = targetHostSocket.recv(4096)
                    except Exception, e:
                        print e

                    if data != None:
                        if len(data) > 0:
                            clientData += data
                        else:
                            terminate = True

            for out in outputsReady:
                if out == self.__clientSocket and len(clientData) > 0:
                    bytesWritten = self.__clientSocket.send(clientData)
                    if bytesWritten > 0:
                        clientData = clientData[bytesWritten:]
                elif out == targetHostSocket and len(targetHostData) > 0:
                    bytesWritten = targetHostSocket.send(targetHostData)
                    if bytesWritten > 0:
                        targetHostData = targetHostData[bytesWritten:]

        self.__clientSocket.close()
        targetHostSocket.close()
        print "ClienThread terminating"

if __name__ == '__main__':
    if len(sys.argv) != 5:
        print 'Usage:\n\tpython SimpleTCPRedirector <host> <port> <remote host> <remote port>'
        print 'Example:\n\tpython SimpleTCPRedirector localhost 8080 www.google.com 80'
        sys.exit(0)     

    localHost = sys.argv[1]
    localPort = int(sys.argv[2])
    targetHost = sys.argv[3]
    targetPort = int(sys.argv[4])

    serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    serverSocket.bind((localHost, localPort))
    serverSocket.listen(5)
    print "Waiting for client..."
    while True:
        try:
            clientSocket, address = serverSocket.accept()
        except KeyboardInterrupt:
            print "\nTerminating..."
            terminateAll = True
            break
        ClientThread(clientSocket, targetHost, targetPort).start()

    serverSocket.close()