コード例 #1
0
    def message_received(self, message):
        self.log.debug('Message data: ' + message['data'])

        if message['TER'] == True:
            self.log.debug('Terminating Communications...')
            sys.exit(0)

        if message['actor'] == 'Chan':
            self.chan_termination -= 1
            if self.chan_termination <= 0:
                message['RST'] = True
        elif message['FIN'] == True or message[
                'data'] == 'Okay Goodbye' or 'FIN' in message['data']:
            self.log.debug('Ann connection terminated')
            sys.exit(0)

        #Send new packet in response
        send = Packet(src_port=self.routes['Ann'],
                      dest_port=self.routes[message['actor']])

        #Connection with Chan to be terminated
        if message['RST'] == True and self.chan_termination <= 0:
            self.log.debug('Terminating connection with Chan...')
            send.data = 'TER'
            send.actor = 'Ann'
            send.TER = True
            send.RST = True
            deliverable = send.serialize().encode()
            self.log.debug('Sending packet to Router A')
            self.sockets['A'].sendall(deliverable)
        else:
            #Acknowledge packet, check for urgent phrases, accept message input
            send.acknowledgement(message)
            self.log.debug('Returning acknowledgment')

            if '32° 43’ 22.77” N,97° 9’ 7.53” W' in message['data']:
                send.URG = True
                send.auth_code = 'PEPPER THE PEPPER'

            if 'CONGRATULATIONS WE FRIED DRY GREEN LEAVES' in message['data']:
                send.URG = True
                send.data = 'Congrats Meet me at this location: 32.76” N, -97.07” W'
            else:
                send.data = input('What is your message: ')

            send.actor = 'Ann'
            self.log.debug('Sending packet to Router A')
            send.pretty_print()
            deliverable = send.serialize().encode()
            self.sockets['A'].sendall(deliverable)
コード例 #2
0
 def run(self):
     while 1:
         msg = self.connection.recv(1024)
         data = bytearray(msg)
         pck = Packet()
         pck.data = data
         self.onpacketdata(pck.getPacketID(), data)
コード例 #3
0
    def message_received(self, message):
        self.log.debug('Message data: ' + message['data'])

        send = Packet(src_port=self.routes['H'], dest_port=self.routes['Jan'])
        send.data = 'Mission Success'
        deliverable = send.serialize().encode()
        self.sockets['Jan'].sendall(deliverable)
コード例 #4
0
 def send_message(self, message, destination):
     send = Packet(src_port=self.routes['Chan'],
                   dest_port=self.routes[destination])
     send.data = message
     send.actor = 'Chan'
     self.log.debug('Message from Chan to be delivered to ' + destination)
     send.pretty_print()
     deliverable = send.serialize().encode()
     self.sockets['E'].sendall(deliverable)
コード例 #5
0
ファイル: client.py プロジェクト: Infamous-devel/placeholder
 def sendAESKey(self):
     pkt = Packet()
     pkt.state = '100'
     pkt.toIP = ''
     pkt.returnIP = 'MRS'
     pkt.data = self.key
     pkt.RSAEncryptData(self.RSAPublicKey)
     pkt.length = len(pkt.data)
     self.messageQ.put(pkt)
コード例 #6
0
def send(client):
    cmd = raw_input("Enter command: ")
    pkt = Packet()
    pkt.toIP = attackip
    pkt.state = cmd
    if pkt.state == "147":
        base = "C:\Users\Matt\Desktop\\testfolder"
        path = base + "\\" + pkt.toIP + "-encryptionkey"
        try:
            f = open(path,"rb")
            pkt.data = f.read()
            pkt.length = len(pkt.data)
        except:
            print "no encryption key found"
    pkt.send(client)
コード例 #7
0
    def send_message(self, message, destination):
        send = Packet(src_port=self.routes['Jan'],
                      dest_port=self.routes[destination])
        send.data = message
        send.actor = 'Jan'

        if 'FIN' in message or message == 'Goodbye.':
            send.FIN = True
            send.TER = True

        if 'CONGRATULATIONS WE FRIED DRY GREEN LEAVES' in message:
            send.URG = True

        self.log.debug('Message from Jan to be delivered to ' + destination)
        send.pretty_print()
        deliverable = send.serialize().encode()
        self.sockets['F'].sendall(deliverable)
コード例 #8
0
    def sendIPList(self,address=""):
        state = "100"
        ips = self.toVirus.keys()
        data = ""
        for ip in ips:
            data += ip + ":" + self.toVirus[ip][2]
        length = len(data)

        pkt = Packet()
        pkt.state = state
        pkt.length = str(length)
        pkt.data = data
        pkt.encryptData(self.AESKey)
        print "IPList: " + data
        if address != "":
            pkt.returnIP = address[0]
            self.enqueueToClient(pkt)
        else:
            for ip in self.toClient.keys():
                self.enqueueToClient(pkt,ip)
コード例 #9
0
def ping(addr):
    print "PING (%s): %d data bytes" % (addr, datalen)

    ## create socket
    s = socket.socket(socket.AF_INET, socket.SOCK_RAW,
                      socket.getprotobyname('icmp'))
    s.connect((addr, 22))

    ## setuid back to normal user
    os.setuid(os.getuid())

    seq_num = 0
    packet_count = 0
    process_id = os.getpid()
    base_packet = Packet((8, 0))

    while 1:
        ## create ping packet
        seq_num += 1
        pdata = struct.pack("!HHd", process_id, seq_num, time.time())

        ## send initial packet
        base_packet.data = pdata
        s.send(base_packet.packet)

        ## recv packet
        buf = s.recv(BUFSIZE)
        current_time = time.time()

        ## parse packet; remove IP header first
        r = Packet.parse(buf[20:])

        ## parse ping data
        (ident, seq, timestamp) = struct.unpack("!HHd", r.data)

        ## calculate rounttrip time
        rtt = current_time - timestamp
        rtt *= 1000
        print "%d bytes from %s: id=%s, seq=%u, rtt=%.3f ms" % (
            len(buf), addr, ident, seq, rtt)
        time.sleep(1)
コード例 #10
0
    def message_received(self, message):
        self.log.debug('Message data: ' + message['data'])

        if message['TER'] == True:
            self.log.debug('Terminating Communications...')
            sys.exit(0)

        if message['data'] == 'Execute':
            send = Packet(src_port=self.routes['Jan'],
                          dest_port=self.routes['H'])
            send.data = 'HQ the enemy is located 32° 43’ 22.77” N,97° 9’ 7.53” W'
            send.URG = True
            send.auth_code = message['auth_code']
            deliverable = send.serialize().encode()
            self.sockets['H'].sendall(deliverable)

        self.log.debug('Returning acknowledgment')
        send = Packet()
        send.acknowledgement(message)
        send.actor = 'Jan'
        deliverable = send.serialize().encode()
        self.sockets['F'].sendall(deliverable)
コード例 #11
0
    def send_data(self, filename, win_size, d_address, d_port, sock_to_send):
        file_reader = FileReader(filename)
        # Pre-load file chunks with enough to fill the window at first
        file_chunks = file_reader.get_chunk(win_size)
        # load in the first packets
        window = Window(win_size)
        packets = []

        for chunk in file_chunks:
            packets.append(
                Packet.data(self.seq_number, chunk, self.port, d_port))
            self.up_sequence_number(len(chunk))

        window.add_packets(packets)
        print("Sending first window...")
        window.send(sock_to_send, d_address, d_port)

        done = False

        while not done:
            sock_to_send.settimeout(.5)
            try:
                print("Waiting for ack...")
                message, address = sock_to_send.recvfrom(1472)
                ack_packet = Packet.read_packet(message)
                print("Packet received, checking...")
                # checking valid checksum
                if ack_packet[1]:
                    # adding packets into the window to be sent
                    if ack_packet[0] == 'Ack':
                        print("Ack received")
                        window.remove_packets(ack_packet[2])

                        file_chunks = file_reader.get_chunk(
                            window.get_packet_space())

                        # removing empty chunks if they are present
                        if file_chunks[-1] == b'':
                            file_chunks = list(filter(None, file_chunks))
                            # after removing all the empty chunks, add one more blank if the last packet is exactly 1452
                            if file_chunks:
                                if len(file_chunks[-1]) == 1452:
                                    file_chunks.append(b'')
                            else:
                                file_chunks.append(b'')

                        packets = []

                        for chunk in file_chunks:
                            if len(chunk) == 1452:
                                packets.append(
                                    Packet.data(self.seq_number, chunk,
                                                self.port, d_port))
                                self.up_sequence_number(len(chunk))
                            else:
                                packets.append(
                                    Packet.data(self.seq_number,
                                                chunk,
                                                self.port,
                                                d_port,
                                                fin=True))
                                print("final packet created")
                                print(packets[-1].sequence_number)
                                done = True

                        window.add_packets(packets)

                        window.send(sock_to_send, d_address, d_port)
                    # If the ack packet is instead an error packet, print error, dropped acked packets, then resend
                    elif ack_packet[0] == 'Err':
                        print("Error returned: " + str(ack_packet[2]) + " " +
                              str(ack_packet[3]))
                        print(
                            "Fixing checksums, moving acked packets out of window, and resending..."
                        )
                        window.re_checksum()
                        window.remove_packets(ack_packet[4], error=True)
                        if window.get_packet_space() > 0:
                            file_chunks = file_reader.get_chunk(
                                window.get_packet_space())
                            # removing empty chunks if they are present
                            if file_chunks[-1] == b'':
                                file_chunks = list(filter(None, file_chunks))
                                # after removing all the empty chunks, add one more blank if the last packet is exactly 1452
                                if file_chunks:
                                    if len(file_chunks[-1]) == 1452:
                                        file_chunks.append(b'')
                                else:
                                    file_chunks.append(b'')

                            packets = []

                            for chunk in file_chunks:
                                if len(chunk) == 1452:
                                    packets.append(
                                        Packet.data(self.seq_number, chunk,
                                                    self.port, d_port))
                                    self.up_sequence_number(len(chunk))
                                else:
                                    packets.append(
                                        Packet.data(self.seq_number,
                                                    chunk,
                                                    self.port,
                                                    d_port,
                                                    fin=True))
                                    done = True

                            window.add_packets(packets)
                        window.send(sock_to_send, d_address, d_port)
                else:
                    error_packet = Packet.error(0,
                                                d_port,
                                                self.port,
                                                self.seq_number,
                                                in_message="Checksum error")
                    sock_to_send.sendto(error_packet.binary_combine(),
                                        d_address)
                    self.up_sequence_number(len(error_packet))
            except socket.timeout as e:
                print("Receiving ack timeout, resending...")
                window.send(sock_to_send, d_address, d_port)

        sock_to_send.settimeout(2)
        final_packet_received = False
        while not final_packet_received:
            try:
                final_packet, address = sock_to_send.recvfrom(1472)
                final_info = Packet.read_packet(final_packet)
                if final_info[1]:
                    if final_info[0] == "Ack":
                        window.remove_packets(final_info[2])
                        if window.get_packet_space() == win_size:
                            print("Final ack received, closing connection")
                            sock_to_send.close()
                            final_packet_received = True
                        else:
                            print("Final ack not received, sending whats left")
                            window.send(sock_to_send, d_address, d_port)
            except socket.timeout as e:
                print("Final ack timed out, trying to resend")
                window.send(sock_to_send, d_address, d_port)
コード例 #12
0
	signal.signal(signal.SIGALRM, timeouts_signal_handler)
	signal.setitimer(signal.ITIMER_REAL, 0.01, 0.01)

	window_first_index = 0

	while not send_completed:
		send_index = window_last_index + 1
		packet_data = get_next_message_segment().encode()
		packet_checksum = calculate_string_checksum(pack('IH' + str(len(packet_data)) + 's', sequence_number, ZERO_ONE_INT, packet_data).decode())

		packet = Packet()
		packet.sequence_number = sequence_number
		packet.checksum = int(packet_checksum)
		packet.header = ZERO_ONE_INT
		packet.data = packet_data

		if send_index < WINDOW_SIZE:
			send_buffer.append(packet.get_pack())
			timeout_timers.append(TIMEOUT)
		else:
			send_buffer[send_index % WINDOW_SIZE] = packet.get_pack()
			timeout_timers[send_index % WINDOW_SIZE] = TIMEOUT

		print("Sending #" + str(sequence_number))
		client_socket.sendto(packet.get_pack(), (HOST_IP, HOST_PORT))

		window_last_index = window_last_index + 1
		sequence_number = sequence_number + 1

	while not acked_completed: