diff --git a/Python/client.py b/Python/client.py index 9c45f17..bb241f8 100644 --- a/Python/client.py +++ b/Python/client.py @@ -4,121 +4,144 @@ class client: - def __init__(self, router_connection, client_IP, normal_Server_IP, reflector_ip,attacker_ip, normal_traffic_rate, fileGen, packetSize, max_port_numb,queueLimit, bandwidthToRouter, packet_ID_prefix = "C-"): - self.clientIP = client_IP #client's ip - self.normalServerIP = normal_Server_IP #normal traffic's - self.routerConnection = router_connection #connection used to connect with the router + def __init__(self, router_connection, client_IP, + normal_Server_IP, reflector_ip, attacker_ip, + normal_traffic_rate, fileGen, packetSize, + max_port_numb, queueLimit, bandwidthToRouter, + packet_ID_prefix="C-"): + self.clientIP = client_IP # client's ip + self.normalServerIP = normal_Server_IP # normal traffic's + self.routerConnection = router_connection self.reflectorIP = reflector_ip - self.internetHalfOpenConnections = [] #list of half open connections from normal traffic - self.serverHalfOpenConnections = [] #list of half open connections with the server that's under attack - self.receiveBuffer = [] #Receive buffer for client + self.internetHalfOpenConnections = [] # half open connections (normal traffic) + self.serverHalfOpenConnections = [] # list of half open connections (Server) + self.receiveBuffer = [] # Receive buffer for client self.packetsInReceiveBuffer = 0 - self.queue = [] #queue of the client, for the router connection - self.curTime = 0 #current time of the simulation - self.expectedSYNACKs = dict() #Stores the list of expected SYN-ACKs as a dictionary. I assume that the keys are (source IP, expected ACK Number), and the value is the number of times a response has been sent - self.sendingPacket = None #Current packet that is being sent out - self.normalTrafficRate = normal_traffic_rate #rate at which the client sends normal traffic, packets per sec - self.trafficInterval = 1000 / self.normalTrafficRate - self.sendNextSyn = 0 #Time until next syn is sent (random traffic) + self.queue = [] # queue of the router conneciton + self.curTime = 0 # current time of the simulation + self.expectedSYNACKs = dict() # Stores the list of expected SYN-ACKs as a dictionary. + self.sendingPacket = None # Current packet being sent + self.normalTrafficRate = normal_traffic_rate # packets per sec + self.trafficInterval = 1000 / self.normalTrafficRate + self.sendNextSyn = 0 # Time until next syn is sent self.queueLimit = queueLimit self.currentQueueLoad = 0 - self.packetSize = packetSize #Size of packets in MB + self.packetSize = packetSize # Size of packets in MB self.maxNumbPorts = max_port_numb - self.packetsSent = 0 #counter for logging purposes - self.packetsReceived = 0 #counter for logging purposes - self.packetsDropped = 0 #counter for packets dropped (currently unused but it makes it easier for the log file to operate) - self.packetsInQueue = 0 #counter for packets in the queue - self.packetsGenerated = 0 #number of unique packets generated - self.packetsInSendBuffer = 0 #counter for packets in the sendBuffer - self.packetsDroppedOnConnection = 0 #specifies the number of packets that dropped on the connectionObject due to bandwidth after being sent by the device - #elf.sendRate = send_rate #MB per Sec + self.packetsSent = 0 # counter for logging purposes + self.packetsReceived = 0 # counter for logging purposes + self.packetsDropped = 0 # counter for packets dropped + self.packetsInQueue = 0 # counter for packets in the queue + self.packetsGenerated = 0 # number of unique packets generated + self.packetsInSendBuffer = 0 # counter for packets in the sendBuffer + self.packetsDroppedOnConnection = 0 # Numb packets dropped + self.bandwidthToRouter = bandwidthToRouter - self.fileGen = fileGen #File management object - self.packetIDPrefix = packet_ID_prefix #Used for packet IDs as a prefix so that we're not using the IPs + self.fileGen = fileGen # File management object + self.packetIDPrefix = packet_ID_prefix # Used for packet IDs self.timeToNextIteration = 1 self.sendToNormalServer = True - #If no packet is being sent, it will pop a packet from the queue and start sending it + + # If no packet is being sent, it will send another one def processPackets(self): - if(len(self.queue) > 0 and self.sendingPacket == None): + if(len(self.queue) > 0 and self.sendingPacket is None): curPacket = self.queue.pop(0) - ### DW AUDIT 31JAN2021 transmissionDelay = (curPacket.packetSize / self.sendRate) * 1000 transmissionDelay = (self.packetSize / self.bandwidthToRouter) * 1000 self.timeToNextIteration -= transmissionDelay if(self.timeToNextIteration >= 0): - #self.packetsGenerated += 1 - self.sendingPacket = [curPacket, self.curTime + transmissionDelay] #Packet will be put onto connection after transmission delay has occured + self.sendingPacket = [curPacket, self.curTime + transmissionDelay] self.currentQueueLoad -= curPacket.packetSize else: self.timeToNextIteration += transmissionDelay - #self.packetsGenerated += 1 self.sendingPacket = [curPacket, (self.curTime + transmissionDelay) - (self.timeToNextIteration)] self.currentQueueLoad -= curPacket.packetSize self.timeToNextIteration -= transmissionDelay - elif(self.sendingPacket != None): + elif(self.sendingPacket is not None): leftoverTime = self.sendingPacket[1] - self.curTime self.timeToNextIteration -= leftoverTime - #self.sendPackets() - #If packet is being sent, the packet is placed onto the connection after the packet's transmission delay is satifisfied + # Place packet on connection after trans delay def sendPackets(self): if((self.sendingPacket[1] - self.curTime) < 1): - self.packetsSent += 1 #increment counter - self.routerConnection.transferPacketOut(self.sendingPacket[0]) #place packet on connection + self.packetsSent += 1 # increment counter + self.routerConnection.transferPacketOut(self.sendingPacket[0]) # place packet on connection self.sendingPacket = None - #Places new packets into the receive buffer + # Places new packets into the receive buffer def receivePacket(self, packet): self.receiveBuffer.append(packet) - self.fileGen.addToLog(packet.packetID, "Received at Client", packet.sequenceNumber, packet.ackNumber, packet.packetType, self.curTime) + self.fileGen.addToLog(packet.packetID, "Received at Client", + packet.sequenceNumber, packet.ackNumber, + packet.packetType, self.curTime) self.packetsInReceiveBuffer += 1 self.packetsReceived += 1 - #Takes packets in the receive buffer and creates reponses based on the packet type and data. + # Creates reponses based on the packet type and data. def createResponses(self): i = 0 - while (i < len(self.receiveBuffer)): #iterate over the receive buffer + while (i < len(self.receiveBuffer)): # iterate over the receive buffer curPacket = self.receiveBuffer[i] - if ( (curPacket.srcIP, curPacket.ackNumber) in self.expectedSYNACKs): + if((curPacket.srcIP, curPacket.ackNumber) in self.expectedSYNACKs): self.packetsGenerated += 1 - responsePacket = packet.packet(self.clientIP, curPacket.dstPortNumber, curPacket.srcIP, curPacket.srcPortNumber, "ACK", 0, curPacket.sequenceNumber + 1, self.packetIDPrefix + str(self.packetsGenerated),self.packetSize, self.clientIP) - self.fileGen.addToLog(responsePacket.packetID, "Generated at Client", responsePacket.sequenceNumber, responsePacket.ackNumber, responsePacket.packetType, self.curTime) + responsePacket = packet.packet(self.clientIP, curPacket.dstPortNumber, + curPacket.srcIP, curPacket.srcPortNumber, + "ACK", 0, curPacket.sequenceNumber + 1, + self.packetIDPrefix + str(self.packetsGenerated), + self.packetSize, self.clientIP) + self.fileGen.addToLog(responsePacket.packetID, "Generated at Client", + responsePacket.sequenceNumber, responsePacket.ackNumber, + responsePacket.packetType, self.curTime) self.currentQueueLoad += responsePacket.packetSize if(self.currentQueueLoad <= self.queueLimit): self.queue.append(responsePacket) else: self.currentQueueLoad -= responsePacket.packetSize - #Drop Packet - else: #if the packet is not expected, send an RST ###dw - check this with Jesse since I'm not sure how the RSTs should be formatted + # Drop Packet + else: # if the packet is not expected, send an RST self.packetsGenerated += 1 - responsePacket = packet.packet(self.clientIP, curPacket.dstPortNumber, curPacket.srcIP, curPacket.srcPortNumber, "RST", 0, curPacket.sequenceNumber + 1, self.packetIDPrefix + str(self.packetsGenerated),self.packetSize, self.clientIP) - self.fileGen.addToLog(responsePacket.packetID, "Generated at Client", responsePacket.sequenceNumber, responsePacket.ackNumber, responsePacket.packetType, self.curTime) + responsePacket = packet.packet(self.clientIP, curPacket.dstPortNumber, + curPacket.srcIP, curPacket.srcPortNumber, + "RST", 0, curPacket.sequenceNumber + 1, + self.packetIDPrefix + str(self.packetsGenerated), + self.packetSize, self.clientIP) + self.fileGen.addToLog(responsePacket.packetID, "Generated at Client", + responsePacket.sequenceNumber, responsePacket.ackNumber, + responsePacket.packetType, self.curTime) self.currentQueueLoad += responsePacket.packetSize if(self.currentQueueLoad <= self.queueLimit): self.queue.append(responsePacket) else: self.currentQueueLoad -= responsePacket.packetSize - #Drop Packet - self.receiveBuffer.pop(i) #remove the packet from the queue + # Drop Packet + self.receiveBuffer.pop(i) # remove the packet from the queue self.packetsInReceiveBuffer -= 1 - self.fileGen.addToLog(curPacket.packetID, "Responded to by Client", curPacket.sequenceNumber, curPacket.ackNumber, curPacket.packetType, self.curTime) + self.fileGen.addToLog(curPacket.packetID, "Responded to by Client", + curPacket.sequenceNumber, curPacket.ackNumber, + curPacket.packetType, self.curTime) - #Simulates normal traffic by sending periodic syn requests to a normal server + # Simulates normal traffic by sending periodic syn requests to a normal server def createNormalTraffic(self): if(self.sendNextSyn <= self.curTime): - #Send a syn packet to the normal server + # Send a syn packet to the normal server if(self.sendToNormalServer): self.packetsGenerated += 1 - normalPacket = packet.packet(self.clientIP, random.randint(0, self.maxNumbPorts), self.normalServerIP, random.randint(0,1000), "SYN", random.randint(0, 10000), 0, self.packetIDPrefix + str(self.packetsGenerated),self.packetSize, self.clientIP) - self.fileGen.addToLog(normalPacket.packetID, "Generated at Client", normalPacket.sequenceNumber, normalPacket.ackNumber, normalPacket.packetType, self.curTime) + normalPacket = packet.packet(self.clientIP, random.randint(0, self.maxNumbPorts), + self.normalServerIP, random.randint(0, 1000), "SYN", + random.randint(0, 10000), 0, + self.packetIDPrefix + str(self.packetsGenerated), + self.packetSize, self.clientIP) + self.fileGen.addToLog(normalPacket.packetID, "Generated at Client", + normalPacket.sequenceNumber, normalPacket.ackNumber, + normalPacket.packetType, self.curTime) self.currentQueueLoad += normalPacket.packetSize if(self.currentQueueLoad <= self.queueLimit): self.queue.append(normalPacket) self.packetsInQueue += 1 self.sendNextSyn = self.curTime + self.normalTrafficRate - #Code for adding the expected response to the dictionary + # Code for adding the expected response to the dictionary if ((normalPacket.dstIP, normalPacket.sequenceNumber + 1) not in self.expectedSYNACKs): self.expectedSYNACKs[(normalPacket.dstIP, normalPacket.sequenceNumber + 1)] = 0 else: @@ -126,19 +149,25 @@ def createNormalTraffic(self): else: self.currentQueueLoad -= normalPacket.packetSize self.sendNextSyn = self.curTime + self.normalTrafficRate - #Drop Packet + # Drop Packet self.sendToNormalServer = False - #send a syn packet to the reflector server + # send a syn packet to the reflector server else: self.packetsGenerated += 1 - normalPacket = packet.packet(self.clientIP, random.randint(0, self.maxNumbPorts), self.reflectorIP, random.randint(0,1000), "SYN", random.randint(0, 10000), 0, self.packetIDPrefix + str(self.packetsGenerated),self.packetSize, self.clientIP) - self.fileGen.addToLog(normalPacket.packetID, "Generated at Client", normalPacket.sequenceNumber, normalPacket.ackNumber, normalPacket.packetType, self.curTime) + normalPacket = packet.packet(self.clientIP, random.randint(0, self.maxNumbPorts), + self.reflectorIP, random.randint(0, 1000), "SYN", + random.randint(0, 10000), 0, + self.packetIDPrefix + str(self.packetsGenerated), + self.packetSize, self.clientIP) + self.fileGen.addToLog(normalPacket.packetID, "Generated at Client", + normalPacket.sequenceNumber, normalPacket.ackNumber, + normalPacket.packetType, self.curTime) self.currentQueueLoad += normalPacket.packetSize if(self.currentQueueLoad <= self.queueLimit): self.queue.append(normalPacket) self.packetsInQueue += 1 self.sendNextSyn = self.curTime + self.normalTrafficRate - #Code for adding the expected response to the dictionary + # Code for adding the expected response to the dictionary if ((normalPacket.dstIP, normalPacket.sequenceNumber + 1) not in self.expectedSYNACKs): self.expectedSYNACKs[(normalPacket.dstIP, normalPacket.sequenceNumber + 1)] = 0 else: @@ -148,7 +177,7 @@ def createNormalTraffic(self): self.sendNextSyn = self.curTime + self.normalTrafficRate self.sendToNormalServer = True - #Updates time and calls necessary functions for each iteration + # Updates time and calls necessary functions for each iteration def updateTime(self): self.curTime += 1 self.timeToNextIteration = 1 @@ -157,5 +186,3 @@ def updateTime(self): while((len(self.queue) > 0 or self.sendingPacket is not None) and self.timeToNextIteration > 0): self.processPackets() self.sendPackets() - # while(self.timeToNextIteration > 0): - # self.sendPackets()