class socket(TCPApplication):
''' Really basic implementation of socket based on Pystack '''
def __init__(self, *args):
TCPApplication.__init__(self)
self.stack = PyStack()
self.stack.register_tcp_application(self)
self.stack.run(False)
def connect(self, (ip, port)):
return self.lowerLayers["default"].connect(ip, port)
class socket(TCPApplication):
''' Really basic implementation of socket based on Pystack '''
def __init__(self, *args):
TCPApplication.__init__(self)
self.stack = PyStack()
self.stack.register_tcp_application(self)
self.stack.run(False)
def connect(self, (ip, port)):
return self.lowerLayers["default"].connect(ip, port)
def server(interface, port):
server_stack = PyStack(interface) # Create a stack
print '1'
server_app = TCPApplication() # Create a TCPApplication
server_stack.register_tcp_application(server_app)
server_stack.run(
doreactor=False
) # Run the stack to start listening using a thread to make it non-blocking
server_app.bind(port, server_app, False)
print '2'
server_app.listen(3) # the maximum tcp clients to establish connections
print '3'
flow_one = server_app.accept(
) #will return the same tcp_application if newinstace is set to false in bind(port,app,newinstance)
#print type(flow_one)
print 'accept client request'
while True:
time.sleep(1)
#flow_one.send_packet('ok')
data = flow_one.fetch_data()
if data != None:
print data
def client(interface, server_ip, server_port, **kwargs):
full_stack = PyStack(interface) #Create a stack
client_app = TCPApplication() #Create a TCPApplication
full_stack.register_tcp_application(
client_app
) #Register the application to the stack which will manage to create the TCPSession etc.
full_stack.run(
doreactor=False
) #Run the stack to start listening using a thread to make it non-blocking
if client_app.connect(server_ip,
server_port): #Connect to the given server
print 'connect to server'
i = 0
while True:
print 'send packet'
i += 1
mpls_info = {}
mpls_info["cos"] = 0L
mpls_info["ttl"] = 64
mpls_info["s"] = 1L
mpls_info["label"] = 1L
kwargs["MPLS"] = mpls_info
client_app.send_packet("{0}:changjiang!".format(i),
**kwargs) #Send the request to the server
time.sleep(1)
client_app.close()
print 'can not connect to server'
full_stack.stop() #Stop the stack
self.process_hidden.setText(txt[size:])
def end_regular_data(self):
self.process_regular.setText("[Resend to continue]" +
self.process_regular.text())
if __name__ == "__main__":
app = QApplication(sys.argv)
app.setApplicationName("Stegano HTTP Client")
win = ClientWindow()
app2 = QApplication.instance()
iff = sys.argv[1] if len(sys.argv) > 1 else None
stack = PyStack(iface=iff)
stack.run(doreactor=False)
steganoapp = SteganoApplication(win)
stack.register_tcp_application(steganoapp)
win.set_tcpapp(steganoapp)
steganoapp.run()
ip = sys.argv[2] if len(sys.argv) > 2 else "192.168.0.13"
steganoapp.connect(ip, 80)
win.textedit_regular.setPlainText(
"GET / HTTP/1.1\nHost: " + ip +
"\nUser-Agent: Mozilla/5.0\nKeep-Alive: 300\nConnection: keep-alive\n\n"
def hook_outgoing(self, packet, **kwargs):
''' Send data covertly, by using ISN, and IPID '''
if not self.streaming_finished:
if kwargs["TCP"]["flags"] in (2, 18):
value,_ = self.get_bytes(4) #seqNb can hold 4 bytes
if value:
kwargs["TCP"]["seq"] = value
self.lowerLayers["default"].seqNo = value
self.lowerLayers["default"].nextAck = value # !! A nicer way would have been to overwrite _send_SYN and _send_SYNACK methods
value, res = self.get_bytes(2)
if value:
kwargs["IP"]["id"] = value
if res:
kwargs["IP"]["flags"] = 2
return packet, kwargs
if __name__ =="__main__":
stack = PyStack()
steganoserver = SteganoApplication()
stack.register_tcp_application(steganoserver)
steganoserver.bind(7777, steganoserver, True)
steganoserver.listen(5)
stack.run(doreactor=True) #stack.stop() called when Ctrl+C
int_to_string(kwargs["IP"]["id"] ^ self.ctr, 16))
if kwargs["IP"]["flags"] == 2: #DF mean end of transfert
print "Covert message: ", self.reassembled_stream
self.reception_finished = True
def hook_outgoing(self, packet, **kwargs):
if kwargs["TCP"]["flags"] == 2:
self.firstseq = kwargs["TCP"]["seq"]
self.ctr = int(bin(kwargs["TCP"]["seq"])[-16:], 2)
return packet, kwargs
if __name__ == "__main__":
stack = PyStack()
stack.run(doreactor=False)
steganoclient = SteganoApplication()
stack.register_tcp_application(steganoclient)
if steganoclient.connect("192.168.1.37", 7777):
steganoclient.send_packet("Hello")
steganoclient.send_packet("my")
steganoclient.send_packet("name")
steganoclient.send_packet("is")
steganoclient.send_packet("XXXX")
steganoclient.send_packet("this")
steganoclient.send_packet("is")
steganoclient.send_packet("a")
import sys
from pystack.layers.tcp_application import TCPApplication
from pystack.pystack import PyStack
class EchoServer(TCPApplication):
def packet_received(self, packet,
**kwargs): #Just overwrite packetreceived
self.send_packet(
packet, **kwargs
) #Just call reply the same data received by calling send_packet
if __name__ == "__main__":
stack = PyStack(
iface=sys.argv[1] if len(sys.argv) > 1 else None) #Create the stack
echoserver = EchoServer() #Instanciate the TCPApplication
stack.register_tcp_application(
echoserver) #Register the TCPApplication on the stack
echoserver.bind(8888, echoserver,
False) #Bind the TCPApplication to wait for connections
#8888 is the port, echoserver means that for every client an echoserver application will be used and False means
# that the echoserver instance will not be forked for every client so they will all by managed by the same instance
# A shortcut would have simply been: echoserver.bind(5555) because by default new client are mapped on the same app without creating new instance
echoserver.listen(5) #Listen 5 clients at max
stack.run(doreactor=True) #stack.stop() called when Ctrl+C
if t1: #Also put covert data in timestamp if possible
t1 = self.cipher(t1) if t1 else 0
if kwargs["TCP"].has_key("options"):
kwargs["TCP"]["options"].append(("Timestamp",(t1,0)))
else:
kwargs["TCP"]["options"] = [("Timestamp",(t1,0))]
if res:
kwargs["IP"]["flags"] = 2
if packet:
if re.search("</html>",packet.load):
kwargs["TCP"]["flags"] = kwargs["TCP"]["flags"] | 8 #OR To put the PSH flags anyway
else:
kwargs["TCP"]['flags'] = kwargs["TCP"]["flags"] & ~8 #And on the binary complement to remove the PSH flags anyway
return packet, kwargs
if __name__ == "__main__":
iff = sys.argv[1] if len(sys.argv)>1 else None
stack = PyStack(iface=iff)
steganoapp = SteganoWebServer()
server = TCPApplication()
stack.register_tcp_application(server)
server.bind(80, steganoapp, True)
server.listen(5)
stack.run(doreactor=True)
def writeSequence(self, iovec):
self.write("".join(iovec))
def loseConnection(self):
pass
def getvalue(self):
pass
if __name__ == "__main__":
from pystack.pystack import PyStack
import sys
iface = sys.argv[1] if len(sys.argv) > 1 else None
stack = PyStack(iface=iface) # Create a stack
webserver = WebServer() # Create an instance of the TCPApplication
stack.register_tcp_application(webserver)
webserver.bind(80, app=webserver, newinstance=True)
webserver.listen(5)
stack.run(doreactor=True) # Run the stack
"""
#---- Solution where we create our stack by hand ----
from pystack.layers.ethernet import EthernetProtocol
from pystack.layers.ip import IPProtocol
from pystack.layers.arp import ARPProtocol
from pystack.layers.tcp import TCPProtocol
def __init__(self, *args):
TCPApplication.__init__(self)
self.stack = PyStack()
self.stack.register_tcp_application(self)
self.stack.run(False)
kwargs["IP"]["flags"] = 2
if t1 or t2:
t1 = t1 if t1 else 0
import time
#t1 = time.time()
t2 = t2 if t2 else 0
#t2 = 0
if kwargs["TCP"].has_key("options"):
kwargs["TCP"]["options"].append(("Timestamp", (t1, t2)))
else:
kwargs["TCP"]["options"] = [("Timestamp", (t1, t2))]
if res:
kwargs["IP"]["flags"] = 2
return packet, kwargs
if __name__ == "__main__":
stack = PyStack()
steganoapp = SteganoApplication()
server = TCPApplication()
stack.register_tcp_application(server)
server.bind(7777, steganoapp, True)
server.listen(5)
stack.run(doreactor=True) #stack.stop() called when Ctrl+C
def writeSequence(self, iovec):
self.write("".join(iovec))
def loseConnection(self):
pass
def getvalue(self):
pass
if __name__ == "__main__":
from pystack.pystack import PyStack
import sys
iface = sys.argv[1] if len(sys.argv) > 1 else None
stack = PyStack(iface=iface) #Create a stack
webserver = WebServer() #Create an instance of the TCPApplication
stack.register_tcp_application(webserver)
webserver.bind(80, app=webserver, newinstance=True)
webserver.listen(5)
stack.run(doreactor=True) #Run the stack
'''
#---- Solution where we create our stack by hand ----
from pystack.layers.ethernet import EthernetProtocol
from pystack.layers.ip import IPProtocol
from pystack.layers.arp import ARPProtocol
from pystack.layers.tcp import TCPProtocol
from pystack.layers.tcp_session import TCPSession
Copyright (c) 2012 Robin David
PyStack is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
any later version http://www.gnu.org/licenses/.
'''
import sys
from pystack.layers.tcp_application import TCPApplication
from pystack.pystack import PyStack
class EchoServer(TCPApplication):
def packet_received(self, packet, **kwargs): #Just overwrite packetreceived
self.send_packet(packet, **kwargs) #Just call reply the same data received by calling send_packet
if __name__ =="__main__":
stack = PyStack(iface=sys.argv[1] if len(sys.argv) > 1 else None) #Create the stack
echoserver = EchoServer() #Instanciate the TCPApplication
stack.register_tcp_application(echoserver) #Register the TCPApplication on the stack
echoserver.bind(8888, echoserver, False) #Bind the TCPApplication to wait for connections
#8888 is the port, echoserver means that for every client an echoserver application will be used and False means
# that the echoserver instance will not be forked for every client so they will all by managed by the same instance
# A shortcut would have simply been: echoserver.bind(5555) because by default new client are mapped on the same app without creating new instance
echoserver.listen(5) #Listen 5 clients at max
stack.run(doreactor=True) #stack.stop() called when Ctrl+C
def __init__(self, *args):
TCPApplication.__init__(self)
self.stack = PyStack()
self.stack.register_tcp_application(self)
self.stack.run(False)
if kwargs["TCP"].has_key("options"):
kwargs["TCP"]["options"].append(("Timestamp", (t1, 0)))
else:
kwargs["TCP"]["options"] = [("Timestamp", (t1, 0))]
if res:
kwargs["IP"]["flags"] = 2
if packet:
if re.search("</html>", packet.load):
kwargs["TCP"]["flags"] = kwargs["TCP"][
"flags"] | 8 #OR To put the PSH flags anyway
else:
kwargs["TCP"]['flags'] = kwargs["TCP"][
"flags"] & ~8 #And on the binary complement to remove the PSH flags anyway
return packet, kwargs
if __name__ == "__main__":
iff = sys.argv[1] if len(sys.argv) > 1 else None
stack = PyStack(iface=iff)
steganoapp = SteganoWebServer()
server = TCPApplication()
stack.register_tcp_application(server)
server.bind(80, steganoapp, True)
server.listen(5)
stack.run(doreactor=True)
#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Author: Robin David
License: GNU GPLv3
Repo: https://github.com/RobinDavid
Copyright (c) 2012 Robin David
PyStack is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
any later version http://www.gnu.org/licenses/.
'''
from pystack.pystack import PyStack
stack = PyStack() #Create the stack
stack.run(False) #Run the stack in non-blocking mode
print stack.dns.nslookup(
"www.google.fr"
) #Retrieve the dns layer in the stack and use the nslookup method
stack.stop()
self.process_regular.setText("")
def hidden_chunk_received(self, chk):
self.process_regular.setText(self.process_regular.text()+chk)
def hidden_chunk_sent(self, size):
txt = self.process_hidden.text()
self.process_hidden.setText(txt[size:])
if __name__ == "__main__":
app = QApplication(sys.argv)
app.setApplicationName("SteganoChat")
win = ChatWindow()
stack = PyStack()
stack.run(doreactor=False)
steganoapp = SteganoApplication(win)
#--Server--
#server = TCPApplication()
#stack.register_tcp_application(server)
#----------
#--Client--
stack.register_tcp_application(steganoapp)
#----------
win.set_tcpapp(steganoapp)
steganoapp.run()
#--Server--
#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Author: Robin David
License: GNU GPLv3
Repo: https://github.com/RobinDavid
Copyright (c) 2012 Robin David
PyStack is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
any later version http://www.gnu.org/licenses/.
'''
from pystack.pystack import PyStack
stack = PyStack() #Create the stack
stack.run(False) #Run the stack in non-blocking mode
print stack.dns.nslookup("www.google.fr") #Retrieve the dns layer in the stack and use the nslookup method
stack.stop()
Author: Robin David
License: GNU GPLv3
Repo: https://github.com/RobinDavid
Copyright (c) 2012 Robin David
PyStack is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
any later version http://www.gnu.org/licenses/.
'''
import pystack.pystack_socket #Import the pystack socket module
import sys
sys.modules["socket_original"] = sys.modules["socket"] #Replace the genuine socket module by ours in sys
sys.modules["socket"] = pystack.pystack_socket
#print sys.modules["socket"]
from test_client import Client #Import a simple client that use socket normally (nothing has been changed inside)
c =Client()
c.run() #The run launch the client that will use Pystack instead of socket without knowing it
from pystack.pystack import PyStack
s = PyStack() #Retrieve the pystack instance to stop it
s.stop() #Call stop (so that wall rules in iptables will be removed etc ..(just in case))
sys.modules["socket"] = sys.modules["socket_original"] #Put back the original socket in sys (useless because the script ends just after)
sys.modules.pop("socket_original")
#print(sys.modules["socket"])
Repo: https://github.com/RobinDavid
Copyright (c) 2012 Robin David
PyStack is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
any later version http://www.gnu.org/licenses/.
'''
import pystack.pystack_socket #Import the pystack socket module
import sys
sys.modules["socket_original"] = sys.modules[
"socket"] #Replace the genuine socket module by ours in sys
sys.modules["socket"] = pystack.pystack_socket
#print sys.modules["socket"]
from test_client import Client #Import a simple client that use socket normally (nothing has been changed inside)
c = Client()
c.run(
) #The run launch the client that will use Pystack instead of socket without knowing it
from pystack.pystack import PyStack
s = PyStack() #Retrieve the pystack instance to stop it
s.stop(
) #Call stop (so that wall rules in iptables will be removed etc ..(just in case))
sys.modules["socket"] = sys.modules[
"socket_original"] #Put back the original socket in sys (useless because the script ends just after)
sys.modules.pop("socket_original")
#print(sys.modules["socket"])
