def recvThread(client):
print("This is the thread for " + str(client.address))
while True:
client.socket.settimeout(0.01)
# Acquiring receive lock in thread
client.socketLock.acquire()
try:
#receive the data with the socket which previously forwarded
data, source_address = client.socket.recvfrom(65565)
except socket.timeout as exc:
# Timed out receive socket in thread
client.socketLock.release()
# Receive lock released in thread
continue
client.socketLock.release()
# Receive lock released in thread
if not data:
logger.error('an error ocurred')
break
# Fuzz returns the string is fuzzOutMode is None
data = fuzz(data, fuzzOutMode)
# Acquiring send lock in thread
sSocketLock.acquire()
printDataFrame(data, source_address, client.socket.getsockname(),
client.address,
s.getsockname()[1])
# send the data from the socket that formerly received th datagram from the gateway
s.sendto(data, client.address)
global collector_address
if collector_address:
s.sendto(data, collector_address)
sSocketLock.release()
def server(localPort, remoteHost, remotePort):
global collector_address
try:
localPort = int(localPort)
except:
fail('Invalid port number: ' + str(localPort))
try:
remotePort = int(remotePort)
except:
fail('Invalid port number: ' + str(remotePort))
try:
# This socket will be used by the server to receive data and by the threads to send the remote back to source
global s
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind(('', localPort))
except:
fail('Failed to bind on port ' + str(localPort))
destServer = (remoteHost, remotePort)
print('All set.\n')
while True:
s.settimeout(0.01)
# Acquiring receive lock in main thread
sSocketLock.acquire()
try:
# Receive data from source
data, source_address = s.recvfrom(65565)
except socket.timeout as exc:
# Timed out receive socket in main thread
sSocketLock.release()
# Receive lock released in main thread
continue
sSocketLock.release()
# Receive lock released in main thread
if not data:
logger.error('an error ocurred')
break
# Depending on the source address, a Client object is retrieved
knownClient = None
knownClient = getKnownClient(source_address)
# Fuzz returns the string is fuzzInMode is None
data = fuzz(data, fuzzInMode)
# Forward the data if the client is known, using a socket previously created
if knownClient is not None:
print("Client already registered in port: " +
str(knownClient.address[1]) + " Clients list lenght: " +
str(len(knownClients)))
# Acquiring send lock in main thread
knownClient.socketLock.acquire()
printDataFrame(data, source_address, s.getsockname(), destServer,
knownClient.socket.getsockname()[1])
knownClient.socket.sendto(data, destServer)
if collector_address:
knownClient.socket.sendto(data, collector_address)
knownClient.socketLock.release()
# Send lock released in main thread
# Else, create a new socket, save client+socket, forward the data and start a listening proxy
else:
newSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Choose a random socket, with param 0
newSocket.bind(('', 0))
print("Creating a new client")
newClient = Client(source_address, newSocket)
knownClients.append(newClient)
# Acquiring send lock in main thread
newClient.socketLock.acquire()
printDataFrame(data, source_address, s.getsockname(), destServer,
newSocket.getsockname()[1])
newSocket.sendto(data, destServer)
if collector_address:
newSocket.sendto(data, collector_address)
newClient.socketLock.release()
# Send lock released in main thread
#Create the proxy listener in a thread
listener = threading.Thread(target=recvThread, args=(newClient, ))
listener.daemon = True
listener.start()
def on_recv(self):
data = self.data
# here we can parse and/or modify the data before send forward
data = fuzz(data, fuzzInMode)
print('%r' % (data))
self.channel[self.s].send(data)