def server_run(): f = StackingProtocolFactory(lambda: PassThrough1(), lambda: PassThrough2()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector("passthrough", ptConnector) loop = asyncio.get_event_loop() coro = playground.getConnector('passthrough').create_playground_server(lambda: ServerProtocol(), 101) server = loop.run_until_complete(coro) print("Echo Server Started at {}".format(server.sockets[0].gethostname())) loop.run_forever() loop.close()
def lab_1e_test(): loop = asyncio.get_event_loop() loop.set_debug(enabled=True) f = StackingProtocolFactory(lambda: higherProtocol1(), lambda: higherProtocol2()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector("passthrough", ptConnector) coro = playground.getConnector('passthrough').create_playground_server(lambda:MyServerProtocol(), 46427) server = loop.run_until_complete(coro) print('Serving on {}'.format(server.sockets[0].gethostname())) loop.run_forever() server.close() loop.close()
def lab_1e_test(): loop = asyncio.get_event_loop() loop.set_debug(enabled=True) f = StackingProtocolFactory(lambda: higherProtocol1(), lambda: higherProtocol2()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector("passthrough", ptConnector) #message = 'Hello World!' myconnect = playground.getConnector( 'passthrough').create_playground_connection(lambda: MyClientProtocol(), '20174.1.1.1', 46427) transport, client = loop.run_until_complete(myconnect) pktCR = ConnectionRequest() client.send(pktCR) loop.run_forever() loop.close()
def protocolController(): loop = asyncio.get_event_loop() loop.set_debug(enabled=True) client = Protocol.ForgotPasswordClientProtocol() server = Protocol.ForgotPasswordServerProtocol() f = StackingProtocolFactory(lambda: PassThrough1(), lambda: PassThrough2()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector("passthrough", ptConnector) serv = playground.getConnector('passthrough').create_playground_server( lambda: server, 8080) s = loop.run_until_complete(serv) print("Echo server running at {}".format(s.sockets[0].gethostname())) cli = playground.getConnector('passthrough').create_playground_connection( lambda: client, "20174.1.1.1", 8080) transport, protocol = loop.run_until_complete(cli) print("Echo client running with t:{}. p:{}".format(transport, protocol)) loop.run_forever() loop.close()
def client_run(): f = StackingProtocolFactory(lambda: PassThrough1(), lambda: PassThrough2()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector("passthrough", ptConnector) control = ClientProtocol() loop = asyncio.get_event_loop() coro = playground.getConnector().create_playground_connection( control.buildProtocol, '20174.1.1.1', 101) transport, protocol = loop.run_until_complete(coro) print("Client Connected. Starting UI t:{}. p:{}".format( transport, protocol)) #control.connection_made(transport) control.setTransport(transport) pkt1 = DB_connect() control.sendpacket(pkt1) loop.run_forever() loop.close()
messages_hash.update(self.m1) messages_hash.update(self.m2) messages_hash.update(self.m3) messages_hash.update(self.m4) self.validation_hash = messages_hash.digest() hsdone_packet.ValidationHash = self.validation_hash self.send_packet(hsdone_packet) def handle_hsdone(self, packet): super().handle_hsdone(packet) cli_cipher = Cipher(algorithms.AES(self.ekc), modes.CTR(self.ivc), backend=default_backend()) server_cipher = Cipher(algorithms.AES(self.eks), modes.CTR(self.ivs), backend=default_backend()) self.data_encryptor = server_cipher.encryptor() self.data_decryptor = cli_cipher.decryptor() self.mac_creator = hmac.HMAC(self.mks, hashes.SHA1(), backend=default_backend()) self.mac_verifier = hmac.HMAC(self.mkc, hashes.SHA1(), backend=default_backend()) self.higherProtocol().connection_made( PLS_Transport(self.transport, self)) clientFactory = StackingProtocolFactory(PEEP_Client, PLS_Client) serverFactory = StackingProtocolFactory(PEEP_Server, PLS_Server)
from labs.lab1.src.lab1_protocol.RIPPClientProtocol import RippClientProtocol from labs.lab1.src.lab1_protocol.RIPPServerProtocol import RippServerProtocol from playground.network.common import StackingProtocolFactory pt_client = StackingProtocolFactory(lambda: RippClientProtocol()) pt_server = StackingProtocolFactory(lambda: RippServerProtocol())
self.transport.write(packet4Bytes) print("SYN-ACK Packet Sent") else: connection_lost(self) elif pkt.Type == 2: print("ACK Packet Received") print( "Type= {} Acknowledgment = {} SequenceNumber = {} Checksum = {}" .format(pkt.Type, pkt.Acknowledgement, pkt.SequenceNumber, pkt.Checksum)) oldChecksum = pkt.Checksum pkt.Checksum = 0 bytes = pkt.__serialize__() self.Checksum = oldChecksum verify = zlib.adler32(bytes) & 0xffff if verify == oldChecksum: print("ACK Packet Verified") peeptransport = PeepServerTransport(self, self.transport) higherTransport = StackingTransport(peeptransport) self.higherProtocol().connection_made(higherTransport) else: connection_lost(self) else: connection_lost(self) def connection_lost(self, reason=None): print("Connection end") Serverfactory = StackingProtocolFactory(lambda: PEEPServerProtocol())
import playground from playground.network.common import StackingProtocolFactory, StackingProtocol, StackingTransport from .protocol import PoopClient, PoopServer PoopClientFactory = StackingProtocolFactory.CreateFactoryType(PoopClient) PoopServerFactory = StackingProtocolFactory.CreateFactoryType(PoopServer) connector = playground.Connector(protocolStack=(PoopClientFactory(), PoopServerFactory())) playground.setConnector('poop', connector)
from .PLSClientProtocol import PLSClientProtocol from .PLSServerProtocol import PLSServerProtocol from .PLSProtocol import PLSProtocol from .Engine import * from playground.network.common import StackingProtocolFactory import playground cf = StackingProtocolFactory(lambda: PLSClientProtocol()) sf = StackingProtocolFactory(lambda: PLSServerProtocol()) lab333_connector = playground.Connector(protocolStack=(cf, sf)) playground.setConnector('lab333_protocol', lab333_connector)
#print("!!!!!!!!!SENDING RST PACKET!!!!!!!!") self.Server_seqNum = pkt.seqNum + 1 self.send_rst(self.transport, self.seqNum, self.Server_seqNum) self.Client_state = self.CLI_INITIAL elif pkt.SYN == False and pkt.ACK == False and self.Client_state == self.CLI_ESTABLISHED and pkt.data != 0: self.seqNum = pkt.ackNum self.Server_seqNum = pkt.seqNum + len(pkt.data) RECV_BUFF = pkt.data print(RECV_BUFF) print( "\n!!!!!!!!!!!!!!!!!DATA PACKET RECIEVED!!!!!!!!!!!!!!!!!!!!\n" ) self.higherProtocol().data_received(pkt.data) #print("PAcket sent to higher layer") #Process the data packet recieved else: print("!!!!!SOMETHING!!!") else: #print("SOMETHING!!!") self.send_rtr(self.transport, self.seqNum, self.Server_seqNum) PIMPClientFactory = StackingProtocolFactory.CreateFactoryType( lambda: PIMPClientProtocol()) PIMPServerFactory = StackingProtocolFactory.CreateFactoryType( lambda: PIMPServerProtocol())
packet4.sid = p.sid packet4.cid = p.cid packet4Bytes = packet4.__serialize__() print('RegisterResultPacket(Packet4) Sent') self.transport.write(packet4Bytes) else: print('Cannot Find Course ID') print('Close the client socket') self.transport.close() def connection_lost(self, exc): print("ServerProtocol Connection lost") self.transport = None Stack = StackingProtocolFactory(lambda: PassThroughTwoProtocol(), lambda: PassThroughOneProtocol()) ptConnector = playground.Connector(protocolStack=Stack) playground.setConnector("passthrough", ptConnector) loop = asyncio.get_event_loop() loop.set_debug(enabled=True) # Each client connection will create a new protocol instance coro = playground.getConnector('passthrough').create_playground_server( ServerProtocol, 8888) server = loop.run_until_complete(coro) # Serve requests until Ctrl+C is pressed try: loop.run_forever() except KeyboardInterrupt: pass
print("transport_write") #self.key_iv() key = AESGCM.generate_key(bit_length=128) encData = AESGCM(self.enc).encrypt(self.iv,data,None) self.iv = self.increIv(self.iv) dataPacket = DataPacket(data=encData) self.transport.write(dataPacket.__serialize__()) print("crap encrypted and sent data") def data_received_duplex(self, packet): print("data_received_duplex") #self.key_iv() data = AESGCM(self.dec).decrypt(self.peer_iv, packet.data, None) self.peer_iv = self.increIv(self.peer_iv) self.higherProtocol().data_received(data) print("crap received and decrypted data") def transport_close(self): self.higherProtocol().connection_lost(None) self.transport.close() SecureClientFactory = StackingProtocolFactory.CreateFactoryType( lambda: PassthroughProtocol(mode="client"), lambda: Crap(mode="client") ) SecureServerFactory = StackingProtocolFactory.CreateFactoryType( lambda: PassthroughProtocol(mode="server"), lambda: Crap(mode="server") )
unlock PASSWORD: unlock with the given password. changePassword NEW_PASSWORD: reset the lock's password (only when unlocked) lock: set the lock to be locked.''') if len(sys.argv) == 1: basicUnitTest() print() print("Note: run with --help for more options") sys.exit(1) args = parser.parse_args() if args.option == "unittest": basicUnitTest() elif args.option == "server": lock = Lock("000", True) print("Server mode; Lock initialized as locked, password = 000") loop = asyncio.get_event_loop() f = StackingProtocolFactory(lambda: Lock1stLayerProtocol(), lambda: Lock2ndLayerProtocol()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector("passthrough", ptConnector) coro = playground.getConnector("passthrough").create_playground_server( lambda: LockServerProtocol(lock), 32768) server = loop.run_until_complete(coro) # Serve requests until Ctrl+C is pressed # print('Serving on {}'.format(server.sockets[0].getsockname())) print('Serving on Playground route ' + server.sockets[0].gethostname()[0] + ", port " + str(server.sockets[0].gethostname()[1])) try: loop.run_forever() except KeyboardInterrupt: pass
def __init__(self): super(Passthrough2, self).__init__() self.transport = None def connection_made(self, transport): print('passthrough2') self.transport = transport higherTransport2 = StackingTransport(self.transport) self.higherProtocol().connection_made(higherTransport2) def data_received(self, data): self.higherProtocol().data_received(data) if __name__ == '__main__': loop = asyncio.get_event_loop() loop.set_debug(enabled=True) print("Echo Client Connected. Starting........") f = StackingProtocolFactory(lambda: Passthrough1(), lambda: Passthrough2()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector('passthrough', ptConnector) coro = playground.getConnector('passthrough').create_playground_connection( lambda: EchoClient(loop), '20174.1.1.3', 8080) loop.run_until_complete(coro) loop.run_forever() loop.close()
''' Created on 2017年9月27日 @author: wangweizhou ''' from playground.network.packet.fieldtypes import UINT32, STRING, BUFFER,BOOL from playground.network.packet import PacketType from playground.network.common import StackingProtocol from playground.network.common import StackingProtocolFactory from playground.network.common import StackingTransport import playground import .HandShakePacket from .TranSerProto import * from .ServerPassThrough import * from .ServerAppProtocol import * from asyncio import * if __name__=='__main__': loop = get_event_loop() f = StackingProtocolFactory(lambda: ServerPassThrough(), lambda: TranSerProto()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector('ServerStack', ptConnector) coro = playground.getConnector('ServerStack').create_playground_server(lambda:ServerAppProtocol(),8998) myserver= loop.run_until_complete(coro) loop.run_forever() myserver.close() loop.close()
import playground from .Protocols.ServerProtocol import ServerProtocol from .Protocols.ClientProtocol import ClientProtocol from .Protocols.ServerPLSProtocol import ServerPLSProtocol from .Protocols.ClientPLSProtocol import ClientPLSProtocol from playground.network.common import StackingProtocolFactory clientStack = StackingProtocolFactory(ClientProtocol, ClientPLSProtocol) serverStack = StackingProtocolFactory(ServerProtocol, ServerPLSProtocol) myPlsConnector = playground.Connector(protocolStack=(clientStack, serverStack)) clientPlsConnector = playground.Connector(protocolStack=clientStack) serverPlsConnector = playground.Connector(protocolStack=serverStack) myPeepConnector = playground.Connector(protocolStack=(ClientProtocol, ServerProtocol)) clientPeepConnector = playground.Connector( protocolStack=StackingProtocolFactory(ClientProtocol)) serverPeepConnector = playground.Connector( protocolStack=StackingProtocolFactory(ServerProtocol)) playground.setConnector("lab3_protocol", myPlsConnector) playground.setConnector("my_team_lab3_protocol", myPlsConnector) playground.setConnector("lab3_client_protocol", clientPlsConnector) playground.setConnector("lab3_server_protocol", serverPlsConnector) playground.setConnector("lab2_protocol", myPeepConnector) playground.setConnector("lab2_client_protocol", clientPeepConnector) playground.setConnector("ilab2_protocol", clientPeepConnector) playground.setConnector("lab2_server_protocol", serverPeepConnector)
from .peep import PEEPClient, PEEPServer import playground from playground.network.common import StackingProtocol, StackingTransport, StackingProtocolFactory class PassThrough1(StackingProtocol): def connection_made(self, transport): print(" - PassThrough1 connection_made") self.transport = transport higherTransport = StackingTransport(transport) self.higherProtocol().connection_made(higherTransport) def data_received(self, data): print(" - PassThrough1 data_received") self.higherProtocol().data_received(data) def connection_lost(self, exc): print(" - PassThrough1 connection_lost") self.transport = None self.higherProtocol().connection_lost(exc) lab2ClientFactory = StackingProtocolFactory(PassThrough1, PEEPClient) lab2ServerFactory = StackingProtocolFactory(PassThrough1, PEEPServer) lab2Connector = playground.Connector(protocolStack=(lab2ClientFactory, lab2ServerFactory)) playground.setConnector("Guoye_protocol", lab2Connector) #playground.setConnector("team7_alt_peep_protocol", lab2Connector)
self.transport = None print("Server Connection Lost because {}".format(exc)) print("Stop the event loop") self.loop.stop() loop = asyncio.get_event_loop() loop.set_debug(enabled=True) # coro = loop.create_connection( # lambda: MyClientProtocol(loop), "127.0.0.1", 8001) # loop.run_until_complete(coro) # loop.run_forever() # loop.close() f = StackingProtocolFactory( lambda: PassThroughProtocol1(), lambda: PassThroughProtocol2()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector("passthrough", ptConnector) # The purpose of the "getConnector" method is to decide what type of playground network connection you get. # coro = playground.getConnector("passthrough").create_playground_connection( # lambda: MyClientProtocol(loop), '20174.1.1.1', 5555) # loop.run_until_complete(coro) # print("Client Connected(pt)") # loop.run_forever() # loop.close() # The default connector just connects application layer factory directly to the playground wire protocol coro = playground.getConnector().create_playground_connection( lambda: MyClientProtocol(loop), '20174.1.1.1', 5555)
highertransport = StackingTransport(self.transport) self.higherProtocol().connection_made(highertransport) def data_received(self,data): self.higherProtocol().data_received(data) def connection_lost(self,exc): pass # self.highertrasnport = None name = sys.argv[1] loop = asyncio.get_event_loop() loop.set_debug(enabled = True) f = StackingProtocolFactory(lambda:passThrough1(),lambda:passThrough2()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector("passthrough",ptConnector) if name == "server": coro = playground.getConnector('passthrough').create_playground_server(lambda: ServerProtocol(), 8888) server = loop.run_until_complete(coro) print("Echo Server Started at {}".format(server.sockets[0].gethostname())) loop.run_forever() loop.close() else: coro = playground.getConnector('passthrough').create_playground_connection(lambda: ClientProtocol(packet2, loop),"20174.1.1.1",8888) transport, protocol = loop.run_until_complete(coro) print("Echo Client Connected. Starting UI t:{}. p:{}".format(transport, protocol)) loop.run_forever() loop.close()
''' Created on 2017年9月27日 @author: wangweizhou ''' from playground.network.packet.fieldtypes import UINT32, STRING, BUFFER,BOOL from playground.network.packet import PacketType from playground.network.common import StackingProtocol from playground.network.common import StackingProtocolFactory from playground.network.common import StackingTransport import playground from .HandShakePacket import * from .ClientPassThrough import * from .ClientAppProtocol import * from asyncio import * from .TranCliProto import TranCliProto if __name__=='__main__': loop = get_event_loop() f = StackingProtocolFactory(lambda: ClientPassThrough(), lambda: TranCliProto()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector('ClientStack', ptConnector) connect = playground.getConnector('ClientStack').create_playground_connection (lambda:ClientAppProtocol(), '20174.1.1.1', 8998) mytransport, myclientprotocol = loop.run_until_complete(connect) #myclientprotocol.connection_made(mytransport) #myclientprotocol.SentRequest(); loop.run_forever() loop.close()
self.exc = "RIP" self.check = 1 self.transport.close() else: self.exc = "Checksum Error during connection: Closing Connection" self.connection_lost(None) else: self.exc = "Packet Type Exception: Nice Try!3" self.connection_lost(None) else: exc = " Error with Session: Terminating Connection" self.connection_lost(None) def shutdown(self): if len(self.packets) == 0: self.sendRIP() else: print(len(self.packets)) t = Timer(Seconds(2),self.shutdown) t.start() def connection_lost(self, exc): self.transport.close() # self.transport = None asyncio.get_event_loop().stop() Clientfactory = StackingProtocolFactory(lambda: PEEPClientProtocol())
from playground.network.common import StackingProtocolFactory from labs.lab1.src.lab2_protocol.SITHClientProtocol import SithClientProtocol from labs.lab1.src.lab2_protocol.SITHServerProtocol import SithServerProtocol from labs.lab1.src.lab1_protocol.RIPPClientProtocol import RippClientProtocol from labs.lab1.src.lab1_protocol.RIPPServerProtocol import RippServerProtocol secure_client = StackingProtocolFactory(lambda: RippClientProtocol(), lambda: SithClientProtocol()) secure_server = StackingProtocolFactory(lambda: RippServerProtocol(), lambda: SithServerProtocol())
from asyncio import Protocol import asyncio import playground import sys import logging from Server import ClientControl, PassthroughLayerOne, PassthroughLayerTwo from playground.network.common import StackingProtocol, StackingTransport, StackingProtocolFactory if __name__ == "__main__": logging.getLogger().setLevel(logging.NOTSET) logging.getLogger().addHandler(logging.StreamHandler()) f = StackingProtocolFactory(lambda: PassthroughLayerOne(), lambda: PassthroughLayerTwo()) ptConnector = playground.Connector(protocolStack=f) playground.setConnector("passthrough", ptConnector) loop = asyncio.get_event_loop() loop.set_debug(enabled=True) control = ClientControl() coro = playground.getConnector("passthrough").create_playground_connection( control.buildProtocol, '20174.1.1.1', 8000) transport, protocol = loop.run_until_complete(coro) print("\n\nEcho Client Connected. Starting UI t:{}. p:{}".format( transport, protocol)) loop.add_reader(sys.stdin, control.stdinAlert) control.connect(protocol) loop.run_forever()
print(result) pkt = DataPacket(seq=self.send_next, data=self.send_data_buff[0:15000], hash=0) pkt.hash = binascii.crc32(pkt.__serialize__()) & 0xffffffff self.send_data_buff = self.send_data_buff[15000:] else: pkt = DataPacket( seq=self.send_next, data=self.send_data_buff[0:len(self.send_data_buff)], hash=0) pkt.hash = binascii.crc32(pkt.__serialize__()) & 0xffffffff self.send_data_buff = b"" if self.recv_next == 2**32: self.recv_next = 0 else: self.send_next += 1 self.send_packet = pkt self.send_packet_time = time.time() self.transport.write(pkt.__serialize__()) print("OUT: SEQ=" + str(pkt.seq)) # self.loop.create_task(self.wait_ack_timeout(pkt)) PassthroughClientFactory = StackingProtocolFactory.CreateFactoryType( lambda: POOP(mode="client")) PassthroughServerFactory = StackingProtocolFactory.CreateFactoryType( lambda: POOP(mode="server"))
''' Created on 2017年10月4日 @author: wangweizhou ''' import playground from playground.network.common import StackingProtocolFactory from .TranCliProto import * from .TranSerProto import * from .PLSServer import * from .PLSClient import * lab3ClientFactory = StackingProtocolFactory(lambda: TranCliProto(), lambda: PLSClient()) lab3ServerFactory = StackingProtocolFactory(lambda: TranSerProto(), lambda: PLSServer()) lab3Connector = playground.Connector(protocolStack=(lab3ClientFactory, lab3ServerFactory)) playground.setConnector("lab3_protocol", lab3Connector)
if pkt.DEFINITION_IDENTIFIER == "crap.datapacket": if self.mode == "server": aesgcm = AESGCM(self.decB) try: decDataB = aesgcm.decrypt(self.ivA, pkt.data, None) except Exception as error: logger.debug("Server Decryption failed") self.ivA = (int.from_bytes(self.ivA, "big") + 1).to_bytes( 12, "big") self.higherProtocol().data_received(decDataB) if self.mode == "client": aesgcm = AESGCM(self.decA) try: decDataA = aesgcm.decrypt(self.ivB, pkt.data, None) except Exception as error: logger.debug("Client Decryption failed") self.ivB = (int.from_bytes(self.ivB, "big") + 1).to_bytes( 12, "big") self.higherProtocol().data_received(decDataA) SecureClientFactory = StackingProtocolFactory.CreateFactoryType( lambda: POOP(mode="client"), lambda: CRAP(mode="client")) SecureServerFactory = StackingProtocolFactory.CreateFactoryType( lambda: POOP(mode="server"), lambda: CRAP(mode="server"))
"""__init__""" import playground from playground.network.common import StackingProtocolFactory from . import PLSProtocols lab3ClientFactory = StackingProtocolFactory( lambda: PLSProtocols.PLSClientProtocol()) lab3ServerFactory = StackingProtocolFactory( lambda: PLSProtocols.PLSServerProtocol()) lab3Connector = playground.Connector(protocolStack=(lab3ClientFactory, lab3ServerFactory)) playground.setConnector("lab3_protocol", lab3Connector)
from .RIPPClientProtocol import ClientProtocol from .RIPPServerProtocol import ServerProtocol from playground.network.common import StackingProtocol, StackingProtocolFactory, StackingTransport import playground f_client = StackingProtocolFactory(lambda: ClientProtocol()) f_server = StackingProtocolFactory(lambda: ServerProtocol()) ptConnector = playground.Connector(protocolStack=(f_client, f_server)) playground.setConnector("lab1protocol", ptConnector) #playground.setConnector("lab1protocol_cxu", ptConnector) #playground.setConnector("lab1protocol_ty",ptConnector)
else: pass def sendClose(self): pass class PLSClientProtocol(PLSProtocol): def connection_made(self, transport): super().connection_made(transport) address, port = transport.get_extra_info("sockname") mykey, mychain = cert_factory.get_credentials(address) peeraddress = transport.get_extra_info("peername")[0] self.mycert(mykey, mychain, peeraddress) self.sendHello() class PLSServerProtocol(PLSProtocol): def connection_made(self, transport): super().connection_made(transport) address, port = transport.get_extra_info("sockname") mykey, mychain = cert_factory.get_credentials(address) peeraddress = transport.get_extra_info("peername")[0] self.mycert(mykey, mychain, peeraddress) self.state = self.SER_LISTEN PLSClientFactory = StackingProtocolFactory.CreateFactoryType(PLSClientProtocol) PLSServerFactory = StackingProtocolFactory.CreateFactoryType(PLSServerProtocol)