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()