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)
