def __init__(self, ID, loop, logging=True):
if logging:
print("App_Layer Client Side: Init Compelete...")
self.loop = loop
self._deserializer = PacketType.Deserializer()
self.transport = None
self.state = "initial_state"
self.message = ID
self.logging = logging
self.isMock = False
def __init__(self, callback=None):
self.buffer = ""
if callback:
self.callback = callback
print("It's in callback_1")
else:
self.callback = print
self.transport = None
self.deserializer = PacketType.Deserializer()
def __init__(self, loop):
self.loop = loop
self.recv = ""
#self.loop = loop
#self.transport = None
self.result = autograder.AutogradeResultRequest()
self.response = autograder.AutogradeResultResponse()
self.deserializer = PacketType.Deserializer()
self.session = 0
self.testid = ""
def connection_made(self, transport):
self.transport = transport
self.deserializer = PacketType.Deserializer()
# self.packet = RequestRecommandation()
# RequestRecommandation().request = "request recommandation"
# packetBytes = self.packet.__serialize__()
# self.transport.write(packetBytes)
print("Client is connected to server")
firstRequest = packetClass.RequestRecommandation()
self.Request(firstRequest)
def unittest():
packet1 = initiateconnection()
packet2 = authenticationmessage()
packet3 = requestvalidation()
packet4 = validate()
packet2.imageID = 7
packet2.pixelSequence = 100111111001
packet3.imageID = 7
packet3.answer = "H"
packet4.imageID = 7
packet4.boo = True
packet1s = packet1.__serialize__()
packet1d = initiateconnection.Deserialize(packet1s)
if (packet1 == packet1d):
print("packet1 works")
packet2s = packet2.__serialize__()
packet2d = authenticationmessage.Deserialize(packet2s)
if (packet2 == packet2d):
print("packet2 works")
packet3s = packet3.__serialize__()
packet3d = requestvalidation.Deserialize(packet3s)
if (packet3 == packet3d):
print("packet3 works")
packet4s = packet4.__serialize__()
packet4d = validate.Deserialize(packet4s)
if (packet4 == packet4d):
print("packet4 works")
combinepackets = packet1.__serialize__() + packet2.__serialize__(
) + packet3.__serialize__() + packet4.__serialize__()
print(combinepackets)
deserializer = PacketType.Deserializer()
while len(combinepackets) > 0:
subpacket, combinepackets = combinepackets[:10], combinepackets[10:]
deserializer.update(subpacket)
print("chunk of combined packets")
print(subpacket)
print("original combined packets")
print(combinepackets)
for packet in deserializer.nextPackets():
print("packet received")
if packet == packet1:
print("packet1 using deserializer")
elif packet == packet2:
print("packet2 using deserializer")
elif packet == packet3:
print("packet3 using deserializer")
elif packet == packet4:
print("packet4 using deserializer")
def data_received(self, data):
self._deserializer = PacketType.Deserializer()
self._deserializer.update(data)
for pkt in self._deserializer.nextPackets():
if (pkt.DEFINITION_IDENTIFIER == "ClientHello" and dict_sessionID_states[self._session_ID] == "Connection_Made"):
dict_sessionID_states[self._session_ID] = "Server_Hello_State"
self.return_value = self.Genre_Requested_by_Client_function(pkt.Genre)
self.Packet2Bytes(pkt)
elif (pkt.DEFINITION_IDENTIFIER == "ClientRequest" and dict_sessionID_states[self._session_ID] == "Server_Hello_Rcd"):
dict_sessionID_states[self._session_ID] = "Server_Stream_State"
self.Packet2Bytes1(pkt, self.return_value)
def __init__(self, loop, logging=True):
if logging:
print("App_Layer Server Side: Init Compelete...")
self.loop = loop
self._deserializer = PacketType.Deserializer()
self.transport = None
self.state = "wait_for_request_packet"
self._result = "null"
self._verificationCode = 1
self.logging = logging
self.isMock = False
def __init__(self, server_addr, team_number, test_type, mode):
self.test_type = test_type
self.mode = mode
self.server_addr = server_addr
self.server_port = None
self.deserializer = PacketType.Deserializer()
self.my_server_port = random.randint(50000, 60000)
self.server_test_protocol = None
self.server = None
self.test_id = None
self.team_number = team_number
def data_received(self, buffer):
logger.debug("{} passthrough received a buffer of size {}".format(
self._mode, len(buffer)))
# after handshake successfully, the deserializer should be changed
if self.flag == 0:
self.buffer = HandshakePacket.Deserializer()
self.buffer.update(buffer)
else:
self.buffer = PacketType.Deserializer() #当flag=1时，就已经是正常的包了
self.buffer.update(buffer)
for packet in self.buffer.nextPackets():
print(packet)
if self._mode == "server" and isinstance(packet, HandshakePacket):
if packet.status == 0:
# Upon receiving packet, the server sends back a packet with SYN+1, ACK set to 0 and status SUCCESS.
new_packet = HandshakePacket()
new_packet.SYN = self.SYN
new_packet.ACK = (packet.SYN + 1) % 2**32
new_packet.status = 1
self.transport.write(new_packet.__serialize__())
elif packet.ACK == (self.SYN + 1) % 2**32:
# Upon receiving the SUCCESS packet, the server checks if ACK is 1. If success, the server
# acknowledges this connection. Else, the server sends back a packet to the client with status
# ERROR.
higher_transport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higher_transport)
self.flag = 1
else:
new_packet = HandshakePacket()
new_packet.status = 2
self.transport.write(new_packet.__serialize__())
elif self._mode == "client" and isinstance(packet,
HandshakePacket):
# Upon receiving the SUCCESS packet, the client checks if new SYN is old SYN + 1. If it is correct,
# the client sends back to server a packet with ACK set to 1 and status SUCCESS and acknowledge this
# connection with server. Else, the client sends back to server a packet with status set to ERROR.
if packet.ACK == (self.SYN + 1) % 2**32:
new_packet = HandshakePacket()
new_packet.SYN = (packet.ACK + 1) % 2**32
new_packet.ACK = (packet.SYN + 1) % 2**32
new_packet.status = 1
self.flag = 1
self.transport.write(new_packet.__serialize__())
higher_transport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higher_transport)
else:
new_packet = HandshakePacket()
new_packet.status = 2
self.transport.write(new_packet.__serialize__())
else:
self.higherProtocol().data_received(buffer)
def connection_made(self, transport):
peername = transport.get_extra_info("peername")
print(peername)
self.transport = transport
self.game = ERM.EscapeRoomGame(output=self.write_func)
self.game.create_game(cheat=True)
self.game.start()
self.deserializer = PacketType.Deserializer()
self.responsepkt = gamepacket.GameResponsePacket()
self.loop = asyncio.get_event_loop()
self.loop.create_task(
asyncio.wait([asyncio.ensure_future(a) for a in self.game.agents]))
def __init__(self):
super().__init__()
self.transport = None
self._deserializer = PacketType.Deserializer()
self._timeout_handler = None
self._sequence_number = None
self._state = 0
self._sequence_number = 0
self._expect_seq_number = 0
self._passed_list = []
self._backlog_list = []
self._receive_list = []
def connection_made(self, transport):
self.transport = transport
self.d = PacketType.Deserializer()
#start_packet = AutogradeStartTest(
# name="Jaron Lee",
# team=9,
# email="*****@*****.**",
# port=7816,
# packet_file=b""
# )
#self.transport.write(start_packet.__serialize__())
print("C: Sent packet")
def connection_made(self, transport):
peername = transport.get_extra_info("peername")
print(peername)
self.transport = transport
self.deserializer = PacketType.Deserializer()
self.responsepkt = gamepacket.GameResponsePacket()
self.loop = asyncio.get_event_loop()
self.unique_id = "doaiuafavnriuu"
self.account = "zlin32_account"
self.username = "******"
self.permit = 0
self.payment = 10
def __init__(self, loop, bank_client, bank_addr, bank_port, username,
user_acct):
self.loop = loop
self.bank_client = bank_client
self.bank_addr = bank_addr
self.bank_port = bank_port
self.username = username
self.user_acct = user_acct
self.transferResult = None
self.game_status = None
self.loop.add_reader(sys.stdin, self.game_next_input)
self.deserializer = PacketType.Deserializer()
def data_received(self, data):
#print("mmy")
#print("mmy")
d = PacketType.Deserializer()
d.update(data)
for gamePacket in d.nextPackets():
if isinstance(gamePacket,
autograder_ex6_packets.AutogradeTestStatus):
print("Got {} from server.".format(gamePacket.test_id))
print(gamePacket.submit_status)
print(gamePacket.client_status)
print(gamePacket.server_status)
print(gamePacket.error)
self.command_packet = gamePackage.GameCommandPacket.create_game_command_packet(
"Submit")
self.transport.write(self.command_packet.__serialize__())
print("good")
elif isinstance(gamepacket, gamePackage.GameRequirePayPacket):
unique_id, account, amount = process_game_require_pay_packet(
gamePacket)
print(unique_id)
print(account)
print(amount)
self.loop.create_task(
self.CreatePayment(account, amount, unique_id))
elif isinstance(gamePacket, gamePackage.GameResponsePacket):
print(gamePacket.resp)
if self.count < 5:
print("first")
gameCommandPacket = gamePackage.GameCommandPacket.create_game_command_packet(
self.good_list[self.count])
print(gameCommandPacket.command())
self.transport.write(gameCommandPacket.__serialize__())
self.count += 1
print(self.count)
time.sleep(0.25)
elif self.count == 5 and gamePacket.response().split(
)[-1] == 'wall':
gameCommandPacket = gamePackage.GameCommandPacket.create_game_command_packet(
"hit flyingkey with hammer")
self.transport.write(gameCommandPacket.__serialize__())
self.count += 1
time.sleep(0.25)
elif self.count > 5:
if self.count2 < 4:
gameCommandPacket = gamePackage.GameCommandPacket.create_game_command_packet(
self.good_list2[self.count2])
self.transport.write(gameCommandPacket.__serialize__())
self.count2 += 1
def basicUnitTest():
packet1 = RequestColorpackage()
packet1Bytes = packet1.__serialize__()
packet1a = RequestColorpackage.Deserialize(packet1Bytes)
if packet1 == packet1a:
print("these two RequestColorpackage are same")
else:
print('wrong')
packet2 = ColorCodepackage()
packet2.ID = 1
packet2.colorcode = "A52A2A"
packet2Bytes = packet2.__serialize__()
packet2a = ColorCodepackage.Deserialize(packet2Bytes)
if packet2 == packet2a:
print("these two ColorCodepackage are same")
else:
print('wrong')
packet3 = Decodepackage()
packet3.ID = 1
packet3.value1 = 105
packet3.value2 = 100
packet3.value3 = 0
packet3Bytes = packet3.__serialize__()
packet3a = Decodepackage.Deserialize(packet3Bytes)
if packet3 == packet3a :
print("these two Decodepackage are same")
else:
print('wrong')
packet4 = Resultpackage()
packet4.ID = 3
packet4.passfail = True
packet4Bytes = packet4.__serialize__()
packet4a = Resultpackage.Deserialize(packet4Bytes)
if packet4a == packet4 :
print("these two Resultpackage are same")
else:
print("wrong")
pstream = packet1Bytes + packet2Bytes + packet3Bytes + packet4Bytes
deserializer = PacketType.Deserializer()
deserializer.update(pstream)
for pkt in deserializer.nextPackets():
if isinstance(pkt,RequestColorpackage): print('color request')
elif isinstance(pkt, ColorCodepackage): print('color code')
elif isinstance(pkt, Decodepackage): print('decode color')
elif isinstance(pkt, Resultpackage): print('pass fail')
else: print("none")
def data_received(self, data):
d = PacketType.Deserializer()
d.update(data)
for gamePacket in d.nextPackets():
if isinstance(gamePacket, GameRequirePayPacket):
print(gamePacket.amount)
unique_id, account, amount = process_game_require_pay_packet(gamePacket)
print(unique_id)
print(account)
print(amount)
self.loop.create_task(self.Create_Payment(account, amount, unique_id))
elif isinstance(gamePacket, GameResponsePacket):
print(gamePacket.response)
self.flush_output(">> ", end='')
def basicUnitTest4():
packet2 = ConfirmedAnswerPacket()
packet2.confirmedstatus = 1
packet2.sessionID = "wwz1234"
packet3 = OperationRequestPacket()
packet3.sessionID = "wwz1234"
packet3.data1 = b"hello"
packet3.data2 = b"world"
packet3.operation1 = 1
pkgBytes = packet2.__serialize__() + packet3.__serialize__()
deserializer = PacketType.Deserializer()
deserializer.update(pkgBytes)
for packet in deserializer.nextPackets():
if packet == packet2: print("This is packet2")
if packet == packet3: print("This is packet3")
def basicUnitTest():
p = PacketType()
class TestPacket1(PacketType):
DEFINITION_IDENTIFIER = "packettype.basicunittest.TestPacket1"
DEFINITION_VERSION = "1.0"
class SubFields(PacketFields):
FIELDS = [("subfield1",Uint({Bits:16})), ("subfield2",Uint({Bits:16}))]
FIELDS = [
("ls", ListFieldType(ComplexFieldType(SubFields)))
]
packet = TestPacket1()
packet.ls = []
subFields = TestPacket1.SubFields();
subFields.subfield1 = 21
subFields.subfield2 = 45
packet.ls.append(subFields)
serializedData = packet.__serialize__()
restoredPacket = PacketType.Deserialize(serializedData)
print("Success!")
def demux(src, srcPort, dst, dstPort, demuxData):
deserializer = PacketType.Deserializer()
deserializer.update(demuxData)
#print("data:",demuxData)
#if src not in ['20174.1.1337.6','20174.1.1337.4']:
# return
print("src", src)
for packet in deserializer.nextPackets():
if isinstance(packet, OpenSession):
print("packet from ", src, ":", srcport)
print("packet destination", dst, ":", dstport)
print("Data", demuxData)
print("user", packet.Login)
print("passwd", packet.PasswordHash)
print("--------------------------------------")
def connection_made(self, transport):
print("Initialized handshake with {}".format(
transport.get_extra_info("peername")))
self.transport = transport
self.deserializer = PacketType.Deserializer()
pack = PEEPPacket()
pack.Type = 0
pack.SequenceNumber = random.randrange(9999)
pack.Checksum = 0
packet4Bytes = pack.__serialize__()
pack.Checksum = calculateChecksum(packet4Bytes)
packet4Bytes = pack.__serialize__()
print("Type= {} SequenceNumber = {} Checksum = {}".format(
pack.Type, pack.SequenceNumber, pack.Checksum))
self.transport.write(packet4Bytes)
print("SYN Packet Sent")
def data_received(self, data):
print("C: Received packet")
d = PacketType.Deserializer()
d.update(data)
packets = list(d.nextPackets())
packet = packets[0]
print(packet)
time.sleep(.2)
print("C: ", packet.DEFINITION_IDENTIFIER)
if packet.DEFINITION_IDENTIFIER == "20194.exercise6.autogradesubmitresponse":
print("C: {}".format(packet.test_id))
print("C: SUBMITRESPONSE {} {} {}".format(packet.submit_status,
packet.client_status,
packet.server_status))
#if packet.submit_status != AutogradeTestStatus.PASSED:
# print(packet.error)
elif packet.DEFINITION_IDENTIFIER == "jaronresponsepacket":
text = packet.server_response
print("C :", text)
if packet.game_over():
print("C: GAME OVER - safe to terminate")
elif self.instruction_counter < len(self.instructions):
#if self.instruction_counter < len(self.instructions):
if self.instructions[
self.
instruction_counter] == "hit flyingkey with hammer":
if text.split("<EOL>\n")[0].endswith("wall"):
instruction = self.instructions[
self.instruction_counter] # + "<EOL>\n"
print("CS: {}".format(instruction))
self.transport.write(
GameCommandPacket(
server_command=instruction).__serialize__())
self.instruction_counter += 1
else:
instruction = self.instructions[
self.instruction_counter] #+ "<EOL>\n"
print("CS: {}".format(instruction))
self.transport.write(
GameCommandPacket(
server_command=instruction).__serialize__())
self.instruction_counter += 1
else:
raise ValueError(packet.DEFINITION_IDENTIFIER)
def data_received(self, data):
print('Client : The data has been recieved')
self.deserializer = PacketType.Deserializer()
self.deserializer.update(data)
for pkt in self.deserializer.nextPackets():
print(pkt)
if (pkt.counter1 == 2):
print('Client:Received Packet 2 Successfully')
packet_t3 = testpacket()
packet_t3.counter1 = 3
packet_t3.data = b"Hello"
packet_t3bytes = packet_t3.__serialize__()
#ClientSide.connection_made(MockTransportToProtocol(ServerSide()),packet_t3bytes)
self.transport.write(packet_t3bytes)
#ServerSide.data_received(ServerSide(),packet_t3bytes)
elif (pkt.counter1 == 4):
print('Client : Recieved Packet 4 Successfully.')
def data_received(self, data):
self._deserializer = PacketType.Deserializer()
self._deserializer.update(data)
for pckt in self._deserializer.nextPackets():
if isinstance(pckt, RequestWriteMessage):
print("\n\nGot Packet 1")
print(pckt)
print("Packet Details: ClientID: " + pckt.clientID + "\n\n")
respondPacket = RequestReceiverInfo()
elif isinstance(pckt, SendReceiverInfo):
print("\n\nGot Packet 3")
print(pckt)
print("Packet Details: ReceiverID: " + pckt.receiverID)
print("Message: " + str(pckt.message) + "\n\n")
respondPacket = MessageSent()
respondPacket.messageSentTime = str(datetime.datetime.now())
self.transport.write(respondPacket.__serialize__())
def __init__(self, loop):
self.loop = loop
self.name = "ziyang lin"
self.email = "*****@*****.**"
self.team = "2"
self.port = "4225"
self.packet_file = b""
self.deserializer = PacketType.Deserializer()
self.message = [
'look mirror', 'get hairpin', 'unlock chest with hairpin',
'open chest', 'get hammer from chest', 'hit flyingkey with hammer',
"get key", 'unlock door with key', 'open door'
]
#self.recv = ""
#self.loop = loop
#self.transport = None
self.session = 0
self.commpkt = gamepacket.GameCommandPacket()
def data_received(self, data):
self._deserializer = PacketType.Deserializer()
self._deserializer.update(data)
for packet in self._deserializer.nextPackets():
if (packet.DEFINITION_IDENTIFIER == "Antara.Packet2"):
ClientPacket2 = SendData()
ClientPacket2.SessionID = packet.SessionID
ClientPacket2.metricFrom = "Celsius"
ClientPacket2.metricTo = "Fahrenheit"
ClientPacket2.value = self.input_value()
print("Value to convert is: ", self.input_metric)
ClientPacket2bytes = ClientPacket2.__serialize__()
pair[packet.SessionID] = "Data_Sent"
self._transport.write(ClientPacket2bytes)
else:
print("No packet")
self._transport.close()
def data_received(self, data): ##Evaluating which packet is recieved and responding accordingly
self._deserializer = PacketType.Deserializer()
self._deserializer.update(data)
for pckt in self._deserializer.nextPackets():
print("Got a Packet from Server and the packet is ")
print(pckt)
if isinstance(pckt, RequestReceiverInfo):
print("Got packet 2")
print("Packet Details: Only request was transfered for this packet\n")
respondPacket = SendReceiverInfo()
respondPacket.receiverID = self._receiver_id
respondPacket.message = self._msg
elif isinstance(pckt, MessageSent):
print("Got Packet 4")
print("Packet Details: MessageSentTime: " + pckt.messageSentTime + "\n")
self.connection_lost()
return
self.transport.write(respondPacket.__serialize__())
def __init__(self, callback=None):
if callback:
self.callback = callback
self.transport = None
self.rl = RequestLogin()
self.rl.LoginRequest = True
# self.ii = IdentifyInfo()
# self.ii.pin = 123
# self.ii.IDRequest = "Require ID"
# self.ii.PSWRequest = "Require psw"
self.ans = Answer()
# self.res = Result()
# self.res.pin = 123
# self.res.PassOrFail = True
self.deserializer = PacketType.Deserializer()
def data_received(self, data):
deserializer = PacketType.Deserializer()
deserializer.update(data)
for pkt in deserializer.nextPackets():
if isinstance(pkt,
ColorCodepackage) and self.state == 'r_colorcode':
print('client: color code received')
self.colorcode = pkt.colorcode
self.id = pkt.ID
# self.value1 = int(pkt.colorcode[:2], 16)
# self.value2 = int(pkt.colorcode[2:4], 16)
# self.value3 = int(pkt.colorcode[4:], 16)
self.state = 'r_result'
elif isinstance(pkt, Resultpackage) and self.state == 'r_result':
print('client: pass fail received')
self.state = 'complete'
else:
print('client: none expect package matched')
self.transport = None
self.loop.stop()
def __init__(self):
self.transport = None
# self.rl = RequestLogin()
# self.rl.LoginRequest = True
self.ii = IdentifyInfo()
self.ii.pin = 123
self.ii.IDRequest = "Require ID"
self.ii.PSWRequest = "Require psw"
self.ans = Answer()
self.ans.pin = 123
self.ans.ID = "Alex"
self.ans.PSW = "2017alex"
self.res = Result()
self.res.pin = 123
# self.res.PassOrFail = True
self.deserializer = PacketType.Deserializer()
