elif pkt.Type == 2 and self.serverstate == 1 and pkt.SequenceNumber == self.clientseq + 1 and pkt.Acknowledgement == self.serverseq + 1:
# Data transmission can start
print("\n======================= ACK Received. Seq no=", pkt.SequenceNumber, " Ack no=", pkt.Acknowledgement)
self.serverstate += 1
if checkvalue == True:
print("\n================ TCP Connection successful! Client OK to send the Data now.============= \n")
# calling higher connection made since we have received the ACK
peeptransport = PeepServerTransport(self, self.transport)
higherTransport = StackingTransport(peeptransport)
self.higherProtocol().connection_made(higherTransport)
else:
print("================= Corrupt ACK packet. Please check on client end.===============\n")
self.transport.close()
# Reset packet received
elif pkt.Type == 5:
print("================ Server received connection close from client. Closing socket.===============\n")
def write(self,data):
print ("=================== Writing Data down ================\n")
self.transport.write(data)
Serverfactory = StackingProtocolFactory(lambda: PEEPServerProtocol())
ack = PEEP()
ack.Type = 2
ack.SequenceNumber = packet.Acknowledgement
ack.Acknowledgement = packet.SequenceNumber + sys.getsizeof(
packet) + 1
self.state += 1
ack.Checksum = self.calculateChecksum(ack)
clientpacketbytes = ack.__serialize__()
print("=================== Sending ACK =================\n")
self.transport.write(clientpacketbytes)
peeptransport = PeepClientTransport(self, self.transport)
self.higherProtocol().connection_made(peeptransport)
else:
print(
"======== Incorrect packet received. Closing connection!=========\n"
)
self.transport.close()
def connection_lost(self, exc):
print("============== Closing connection ===========\n")
self.transport.close()
def write(self, data):
print("=================== Writing Data down ================\n")
self.transport.write(data)
Clientfactory = StackingProtocolFactory(lambda: PEEPClient())
status=1,
hash=0)
new_packet.hash = binascii.crc32(
pkt.__serialize__()) & 0xffffffff
self.transport.write(new_packet.__serialize__())
self.SYN = (self.init_SYN + 1) % (2**32)
self.last_handshake = current_time
await asyncio.sleep(1 - current_time + self.last_handshake)
async def datapacket_check(self):
while True:
if (time.time() - self.last_data) > 300:
# time out after 5 min
self.flag = 0
self.transport.close()
await asyncio.sleep(300 - (time.time() - self.last_data))
def connection_lost(self, exc):
logger.debug(
"{} passthrough connection lost. Shutting down higher layer.".
format(self._mode))
self.higherProtocol().connection_lost(exc)
PassthroughClientFactory = StackingProtocolFactory.CreateFactoryType(
lambda: POOPProtocol(mode="client"))
PassthroughServerFactory = StackingProtocolFactory.CreateFactoryType(
lambda: POOPProtocol(mode="server"))
self.block0 = hashlib.sha1()
self.block0.update(b"PLS1.0")
self.block0.update(str(self.nc).encode())
self.block0.update(str(self.ns).encode())
self.block0.update(str(self.pkc).encode())
self.block0.update(str(self.pks).encode())
self.block0_digest = self.block0.digest()
print("Block 0 digest is: ", self.block0_digest)
def connection_lost(self, exc):
self.transport.close()
self.loop.stop()
self.transport = None
if __name__ == "__main__":
loop = asyncio.get_event_loop()
Clientfactory = StackingProtocolFactory(lambda: PLSClient(loop))
coro = playground.getConnector().create_playground_connection(
Clientfactory, '20174.1.1.1', 8888)
loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
loop.close()
self.transport))
def data_received(self, data):
print('pass2 receive data')
self.higherProtocol().data_received(data)
def connection_lost(self, exc):
print("ps2 con lost")
self.transport.close()
self.higherProtocol().transport.close()
if __name__ == "__main__":
loop = asyncio.get_event_loop()
f = StackingProtocolFactory(lambda: ServerPass1(), lambda: ServerPass2())
ptConnector = playground.Connector(protocolStack=f)
playground.setConnector("passthrough", ptConnector)
coro = playground.getConnector('passthrough').create_playground_server(
lambda: ColorServerPro(), 888)
server = loop.run_until_complete(coro)
print("ColorServer Started at {}".format(server.sockets[0].gethostname()))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
server.close()
loop.close()
def test():
f = StackingProtocolFactory(lambda: PassThrough1(), lambda: PassThrough2())
ptConnector = playground.Connector(protocolStack=f)
playground.setConnector("PT1", ptConnector)
def __init__(self, loop):
self.loop = loop
def send_first_packet(self):
self.loop = loop
return ShopClientProtocol(loop)
if __name__ == "__main__":
loop = asyncio.get_event_loop()
#logging.getLogger().setLevel(logging.NOTSET) # this logs *everything*
#logging.getLogger().addHandler(logging.StreamHandler()) # logs to stderr
f = StackingProtocolFactory(lambda: PLSClient(), lambda: PEEPClient(loop))
ptConnector = playground.Connector(protocolStack=f)
playground.setConnector("passthrough", ptConnector)
go = initiate(loop)
coro = playground.getConnector('passthrough').create_playground_connection(
go.send_first_packet, '20174.1.1.1', 8888)
client = loop.run_until_complete(coro)
# Serve requests until Ctrl+C is pressed
try:
loop.run_forever()
except KeyboardInterrupt:
pass
# Close the server
loop.close()
self.higherProtocol().data_received(data)
def connection_lost(self, exc):
self.transport = None
print("\nPassThrough2 Connection was Lost with Server because: {}".
format(exc))
self.transport.close()
if __name__ == "__main__":
#p_logging.EnablePresetLogging(p_logging.PRESET_TEST)
loop = asyncio.get_event_loop()
#bob = EchoServerProtocol(loop)
#bob.invite('Bob', 'California', 1, 1, '10.0.0.1', 65001, ['G711u', 'G729', 'G722', 'OPUS', 'G711a'])
f = StackingProtocolFactory(lambda: PassThrough1(), lambda: PassThrough2())
ptConnector = playground.Connector(protocolStack=f)
playground.setConnector("passthrough", ptConnector)
#loop.set_debug(enabled=True)
conn = playground.getConnector('passthrough').create_playground_server(
lambda: EchoServerProtocol(loop), 8888)
#conn = loop.create_server(lambda: EchoServerProtocol(), port=8000)
server = loop.run_until_complete(conn)
print("Echo Server Started at {}".format(server.sockets[0].gethostname()))
print('\nPress Ctrl+C to terminate the process')
try:
loop.run_forever()
except KeyboardInterrupt:
pass
loop.close()
def data_received(self, data):
print('client pass2 through received data')
self.higherProtocol().data_received(data)
def connection_lost(self, exc):
self.higherProtocol().connection_lost()
self.transport = None
print("ps2 con lost")
if __name__ == "__main__":
loop = asyncio.get_event_loop()
control = ColorControl()
f = StackingProtocolFactory(lambda: ClientPass1(),
lambda: ClientPass2())
ptConnector = playground.Connector(protocolStack=f)
playground.setConnector("pass", ptConnector)
coro = playground.getConnector('pass').create_playground_connection(lambda : control.buildProtocol(loop),
'20174.1.1.1', 888)
transport, protocol = loop.run_until_complete(coro)
control.connect(protocol)
protocol.sendfirst()
loop.run_forever()
loop.close()
def connection_lost(self, exc):
print('\nThe ShopClient sent a connection close to the server')
self.transport.close()
self.loop.stop()
if __name__ == "__main__":
loop = asyncio.get_event_loop()
# Each client connection will create a new protocol instance
#logging.getLogger().setLevel(logging.NOTSET) # this logs *everything*
#logging.getLogger().addHandler(logging.StreamHandler()) # logs to stderr
f = StackingProtocolFactory(lambda: PLSServer(),
lambda: PEEPServerProtocol(loop))
ptConnector = playground.Connector(protocolStack=f)
playground.setConnector("passthrough", ptConnector)
coro = playground.getConnector('passthrough').create_playground_server(
lambda: ShopServerProtocol(loop), 8888)
server = loop.run_until_complete(coro)
# Serve requests until Ctrl+C is pressed
try:
loop.run_forever()
except KeyboardInterrupt:
pass
# Close the server
server.close()
loop.close()
digest = hashes.Hash(hashes.SHA256(),
backend=default_backend())
digest.update(hash1)
hash2 = digest.finalize()
self.encA = hash2[0:16]
digest = hashes.Hash(hashes.SHA256(),
backend=default_backend())
digest.update(hash2)
hash3 = digest.finalize()
self.decA = hash3[0:16]
print("-" * 20)
print(self.ivA)
print(self.ivB)
print("-" * 20)
self.handshake = False
self.higherProtocol().connection_made(self.higher_transport)
print(">>>>> Client: Send Second Packet END <<<<<")
else:
error_packet = HandshakePacket(status=2)
self.transport.write(error_packet.__serialize__())
self.transport.close()
SecureClientFactory = StackingProtocolFactory.CreateFactoryType(
lambda: POOP(mode="client"), lambda: CRAP(mode="client"))
SecureServerFactory = StackingProtocolFactory.CreateFactoryType(
lambda: POOP(mode="server"), lambda: CRAP(mode="server"))
