From 12dbcbe36b33f790f0b0c3168f113cafc6bcbb7e Mon Sep 17 00:00:00 2001 From: jeboog Date: Thu, 18 Feb 2021 11:36:53 -0500 Subject: [PATCH] Pep8 reformatting --- Python/dddController.py | 42 +++--- Python/dddPortMapping.py | 17 ++- Python/filegenerator.py | 296 ++++++++++++++++++++++++++++++--------- 3 files changed, 255 insertions(+), 100 deletions(-) diff --git a/Python/dddController.py b/Python/dddController.py index 7c63e09..141611b 100644 --- a/Python/dddController.py +++ b/Python/dddController.py @@ -1,4 +1,4 @@ -#DDD Controller: This class provides functionality for the ddd controller +# DDD Controller: This class provides functionality for the ddd controller import random from . import dddPortMapping @@ -6,48 +6,48 @@ class dddController: def __init__(self, timePortsLast, overlapTime, openNumbPorts, fileGen): - self.curTime = 0 #Current time - self.timePortsLast = timePortsLast #How long until the next port switch - self.toNextChange = self.curTime + self.timePortsLast #Exact time of next port switch - self.timeOverlap = overlapTime #Overlap time for old ports - self.oldPorts = [] #Old ports list - self.timeToFullChange = 0 #The time when old ports get deleted, leaving new ports - self.openNumbPorts = openNumbPorts #Amount of open ports - self.currentUsablePorts = self.generatePorts(openNumbPorts, []) #Current open ports that can be mapped - self.dddPortMapper = dddPortMapping.dddPortMapping(self.currentUsablePorts) #Port mapper object - - self.fileGen = fileGen #File management object - - #This function generates a list of new ports based of the amount of ports needed and the current open ports + self.curTime = 0 # Current time + self.timePortsLast = timePortsLast # How long until the next port switch + self.toNextChange = self.curTime + self.timePortsLast # Exact time of next port switch + self.timeOverlap = overlapTime # Overlap time for old ports + self.oldPorts = [] # Old ports list + self.timeToFullChange = 0 # The time when old ports get deleted, leaving new ports + self.openNumbPorts = openNumbPorts # Amount of open ports + self.currentUsablePorts = self.generatePorts(openNumbPorts, []) # Current open ports that can be mapped + self.dddPortMapper = dddPortMapping.dddPortMapping(self.currentUsablePorts) # Port mapper object + + self.fileGen = fileGen # File management object + + # This function generates a list of new ports based of the amount of ports needed and the current open ports def generatePorts(self, openNumbPorts, currentOpenPorts): newPorts = [] for i in range(openNumbPorts): - portNumber = random.randint(0, 500) #generate a random port number - #Makes sure ports aren't getting reused from the last iteration + portNumber = random.randint(0, 500) # generate a random port number + # Makes sure ports aren't getting reused from the last iteration if(portNumber in currentOpenPorts): while(portNumber in currentOpenPorts): - portNumber = random.randint(0, 500) #generate a random port number + portNumber = random.randint(0, 500) # generate a random port number newPorts.append(portNumber) return newPorts - #Checks to see if ports need to be changed. Saves the old ports and generates new usuable ports for mapping + # Checks to see if ports need to be changed. Saves the old ports and generates new usuable ports for mapping def changePorts(self): if(self.toNextChange <= self.curTime): self.oldPorts = self.currentUsablePorts self.currentUsablePorts = self.generatePorts(self.openNumbPorts, self.currentUsablePorts) self.dddPortMapper.addNewPorts(self.currentUsablePorts) - #Resets timer for next port change and when to drop old ports + # Resets timer for next port change and when to drop old ports self.timeToFullChange = self.curTime + self.timeOverlap self.toNextChange = self.curTime + self.timePortsLast - #Once overlap timer is set off, the old ports are deleted. + # Once overlap timer is set off, the old ports are deleted. def waitForOverlap(self): if(self.timeToFullChange <= self.curTime): self.dddPortMapper.deletePorts(self.oldPorts) self.oldPorts = [] self.timeToFullChange = 0 - #Updates timer and runs functions on every time unit + # Updates timer and runs functions on every time unit def updateTime(self): self.curTime = self.curTime + 1 self.numberOfPacketsReceived = 0 diff --git a/Python/dddPortMapping.py b/Python/dddPortMapping.py index 72928af..b0ac300 100644 --- a/Python/dddPortMapping.py +++ b/Python/dddPortMapping.py @@ -1,33 +1,32 @@ -#DDD Port Mapper: This class provides functionality for the port mapper within our simulation +# DDD Port Mapper: This class provides functionality for the port mapper within our simulation class dddPortMapping: def __init__(self, currentPorts): - self.portMappings = [] #Mapping of current ports, each entry is (internal port number, external port number) - #Maps the ports with a internal port number of 0 to begin with - for i in range(len(currentPorts)): + self.portMappings = [] # Mapping of current ports, each entry is (internal port number, external port number) + # Maps the ports with a internal port number of 0 to begin with + for i in range(len(currentPorts)): self.portMappings.append([0, currentPorts[i]]) - #Returns a port that hasn't been mapped yet + # Returns a port that hasn't been mapped yet def getAvailableOpenPort(self): for i in self.portMappings: if(i[0] == 0): return i[1] return 0 - #Deletes the old ports from the mappings + # Deletes the old ports from the mappings def deletePorts(self, oldPorts): for i in oldPorts: for j in self.portMappings: if(i == j[1]): self.portMappings.remove(j) - - #Adds the new ports to the port mapping that the ddd controller picked + # Adds the new ports to the port mapping that the ddd controller picked def addNewPorts(self, newPorts): for i in newPorts: self.portMappings.append([0, i]) - #Updates the mapping given the internal port number and external port number + # Updates the mapping given the internal port number and external port number def updateMappings(self, internalPortNumber, externalPortNumber): for i in self.portMappings: if(i[1] == externalPortNumber): diff --git a/Python/filegenerator.py b/Python/filegenerator.py index 18c7637..2f9bb3a 100644 --- a/Python/filegenerator.py +++ b/Python/filegenerator.py @@ -1,4 +1,4 @@ -from time import strftime as getTime #Only need the one function from this file for the time being +from time import strftime as getTime import csv import json @@ -6,16 +6,22 @@ class filegenerator: - def __init__(self, make_log, make_summary, make_animation, log_name, summary_name, dddState, packetSize, resendSynAckTime, MaxQueueSize, DDDMappingDelay, PropDelay, NumbDDDPortsOpen, bandwidths, timeUntilNextDDDChange, overlapTime, numbSynAckResends, attackerType, isAmplification): - #boolean statements for deciding which files to make + def __init__(self, make_log, make_summary, + make_animation, log_name, summary_name, + dddState, packetSize, resendSynAckTime, + MaxQueueSize, DDDMappingDelay, PropDelay, + NumbDDDPortsOpen, bandwidths, timeUntilNextDDDChange, + overlapTime, numbSynAckResends, attackerType, + isAmplification): + # boolean statements for deciding which files to make self.makeLog = make_log self.makeSummary = make_summary self.makeAnimation = make_animation - #names of the output files + # names of the output files self.logName = log_name - self.summaryName = summary_name + self.summaryName = summary_name - self.curTime = 0 #current time unit (same as the other classes) + self.curTime = 0 # current time unit (same as the other classes) self.dddState = dddState self.clientToRouter = bandwidths[0] @@ -52,23 +58,78 @@ def __init__(self, make_log, make_summary, make_animation, log_name, summary_nam if (self.makeLog): self.initializeLog() - def initializeLog(self): #initializer for the log file - self.packetDictionary = dict() #keys are the packetIDs, values are lists which contain triples denoting the packetID, the time, and the status / location of the packet - self.lengthLongestEntry = 0 #used to help create the log in a CSV format. Tracks the packet with the longest log entry to help create an appropriately sized CSV - #the file itself isn't written until after the simulation runs, so we don't need to open the file - for x in [' Step', 'Packets Generated (Attacker)', 'Packets Sent (Attacker)', 'Packets Received (Attacker)', 'Packets Dropped (Attacker)','Average Number of Packets Received per ms (Attacker)', 'Average Number of Packets Dropped per ms (Attacker)','Packets Generated (Client)', 'Packets Sent (Client)', 'Packets Received (Client)', 'Packets Dropped (Client)','Average Number of Packets Received per ms (Client)', 'Average Number of Packets Dropped per ms (Client)','Packets Sent (Router)', 'Packets Received (Router)','Packets Dropped (Router)','Average Number of Packets Received per ms (Router)', 'Average Number of Packets Dropped per ms (Router)','Packets Generated (Malicious Server)', 'Packets Sent (Malicious Server)', 'Packets Received (Malicious Server)', 'Packets Dropped (Malicious Server)', 'Average Number of Packets Received per ms (Malicious Server)', 'Average Number of Packets Dropped per ms (Malicious Server)', 'Packets Generated (Normal Server)', 'Packets Sent (Normal Server)', 'Packets Received (Normal Server)', 'Packets Dropped (Normal Server)', 'Average Number of Packets Received per ms (Normal Server)', 'Average Number of Packets Dropped per ms (Normal Server)', 'Packets Accepted (Connection: Attacker-Malicious Server)', 'Packets Dropped (Connection: Attacker-Malicious Server)', 'Packets Delivered (Connection: Attacker-Malicious Server)', 'Average Number of Packets Received per ms (Connection: Attacker-Malicious Server)', 'Average Number of Packets Dropped per ms (Connection: Attacker-Malicious Server)', 'Packets Accepted (Connection: Malicious Server-Router)', 'Packets Dropped (Connection: Malicious Server-Router)', 'Packets Delivered (Connection: Malicious Server-Router)','Average Number of Packets Received per ms (Connection: Malicious Server-Router)', 'Average Number of Packets Dropped per ms (Connection: Malicious Server-Router)', 'Packets Accepted (Connection: Normal Server-Router)', 'Packets Dropped (Connection: Normal Server-Router)', 'Packets Delivered (Connection: Normal Server-Router)','Average Number of Packets Received per ms (Connection: Normal Server-Router)', 'Average Number of Packets Dropped per ms (Connection: Normal Server-Router)', 'Packets Accepted (Connection: Router-Client)', 'Packets Dropped (Connection: Router-Client)', 'Packets Delivered (Connection: Router-Client)','Average Number of Packets Received per ms (Connection: Router-Client)', 'Average Number of Packets Dropped per ms (Connection: Router-Client)']: #[:32] + # initializer for the log file + def initializeLog(self): + self.packetDictionary = dict() # keys are the packetIDs, values are lists which contain triples denoting the packetID, the time, and the status / location of the packet + self.lengthLongestEntry = 0 # used to help create the log in a CSV format. Tracks the packet with the longest log entry to help create an appropriately sized CSV + # the file itself isn't written until after the simulation runs, so we don't need to open the file + for x in [' Step', 'Packets Generated (Attacker)', + 'Packets Sent (Attacker)', 'Packets Received (Attacker)', + 'Packets Dropped (Attacker)', + 'Average Number of Packets Received per ms (Attacker)', + 'Average Number of Packets Dropped per ms (Attacker)', + 'Packets Generated (Client)', 'Packets Sent (Client)', + 'Packets Received (Client)', 'Packets Dropped (Client)', + 'Average Number of Packets Received per ms (Client)', + 'Average Number of Packets Dropped per ms (Client)', + 'Packets Sent (Router)', 'Packets Received (Router)', + 'Packets Dropped (Router)', + 'Average Number of Packets Received per ms (Router)', + 'Average Number of Packets Dropped per ms (Router)', + 'Packets Generated (Malicious Server)', + 'Packets Sent (Malicious Server)', 'Packets Received (Malicious Server)', + 'Packets Dropped (Malicious Server)', + 'Average Number of Packets Received per ms (Malicious Server)', + 'Average Number of Packets Dropped per ms (Malicious Server)', + 'Packets Generated (Normal Server)', 'Packets Sent (Normal Server)', + 'Packets Received (Normal Server)', 'Packets Dropped (Normal Server)', + 'Average Number of Packets Received per ms (Normal Server)', + 'Average Number of Packets Dropped per ms (Normal Server)', + 'Packets Accepted (Connection: Attacker-Malicious Server)', + 'Packets Dropped (Connection: Attacker-Malicious Server)', + 'Packets Delivered (Connection: Attacker-Malicious Server)', + 'Average Number of Packets Received per ms (Connection: Attacker-Malicious Server)', + 'Average Number of Packets Dropped per ms (Connection: Attacker-Malicious Server)', + 'Packets Accepted (Connection: Malicious Server-Router)', + 'Packets Dropped (Connection: Malicious Server-Router)', + 'Packets Delivered (Connection: Malicious Server-Router)', + 'Average Number of Packets Received per ms (Connection: Malicious Server-Router)', + 'Average Number of Packets Dropped per ms (Connection: Malicious Server-Router)', + 'Packets Accepted (Connection: Normal Server-Router)', + 'Packets Dropped (Connection: Normal Server-Router)', + 'Packets Delivered (Connection: Normal Server-Router)', + 'Average Number of Packets Received per ms (Connection: Normal Server-Router)', + 'Average Number of Packets Dropped per ms (Connection: Normal Server-Router)', + 'Packets Accepted (Connection: Router-Client)', + 'Packets Dropped (Connection: Router-Client)', + 'Packets Delivered (Connection: Router-Client)', + 'Average Number of Packets Received per ms (Connection: Router-Client)', + 'Average Number of Packets Dropped per ms (Connection: Router-Client)']: # [:32] self.packetDictionary['S: ' + x] = [] - def addToLog(self, packetID, status, SYNNum, ACKNum, type, time): #adds entries to the log. - if (self.makeLog): #if we are making the log - if (packetID not in self.packetDictionary): #Check if the packet is in the packetDictionary, if not, prep the dictionary to accept it - self.packetDictionary[packetID] = [] #create the list - self.packetDictionary[packetID].append("(" + status + ", " + "Type: "+ type + ", SYN:" + str(SYNNum) + ", ACK: " + str(ACKNum)+ ", Time: " + str(time) +")") #append the status + + def addToLog(self, packetID, status, + SYNNum, ACKNum, type, time): # adds entries to the log. + if (self.makeLog): # if we are making the log + if (packetID not in self.packetDictionary): # Check if the packet is in the packetDictionary, if not, prep the dictionary to accept it + self.packetDictionary[packetID] = [] # create the list + self.packetDictionary[packetID].append("(" + status + ", " + "Type: " + + type + ", SYN:" + str(SYNNum) + + ", ACK: " + str(ACKNum) + ", Time: " + + str(time) + ")") # append the status else: - self.packetDictionary[packetID].append("(" + status + ", " + "Type: "+ type + ", SYN:" + str(SYNNum) + ", ACK: " + str(ACKNum)+ ", Time: " + str(time) +")") #append the status - if (len(self.packetDictionary[packetID]) > self.lengthLongestEntry): #set the new length of the longest entry if needed + self.packetDictionary[packetID].append("(" + status + ", " + "Type: " + + type + ", SYN:" + str(SYNNum) + + ", ACK: " + str(ACKNum) + ", Time: " + + str(time) + ")") # append the status + if (len(self.packetDictionary[packetID]) > self.lengthLongestEntry): # set the new length of the longest entry if needed self.lengthLongestEntry = len(self.packetDictionary[packetID]) - def addSummaryDataToLog(self, client, attacker, MServer, NServer, router, connectionClientRouter, connectionRouterMServer, connectionRouterNServer, connectionAttackerMServer): + def addSummaryDataToLog(self, client, attacker, + MServer, NServer, router, + connectionClientRouter, + connectionRouterMServer, + connectionRouterNServer, + connectionAttackerMServer): if(self.makeLog): self.packetDictionary['S: ' + ' Step'].append(self.curTime) self.packetDictionary['S: ' + 'Packets Generated (Attacker)'].append(attacker.packetsGenerated) @@ -98,7 +159,6 @@ def addSummaryDataToLog(self, client, attacker, MServer, NServer, router, connec self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Malicious Server)'].append(MServer.packetsReceived/self.curTime) self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Malicious Server)'].append(MServer.packetsDropped/self.curTime) - self.packetDictionary['S: ' + 'Packets Generated (Normal Server)'].append(NServer.packetsGenerated) self.packetDictionary['S: ' + 'Packets Sent (Normal Server)'].append(NServer.packetsSent) self.packetDictionary['S: ' + 'Packets Received (Normal Server)'].append(NServer.packetsReceived) @@ -106,8 +166,6 @@ def addSummaryDataToLog(self, client, attacker, MServer, NServer, router, connec self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Normal Server)'].append(NServer.packetsReceived/self.curTime) self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Normal Server)'].append(NServer.packetsDropped/self.curTime) - - self.packetDictionary['S: ' + 'Packets Accepted (Connection: Attacker-Malicious Server)'].append(connectionAttackerMServer.packetsAccepted) self.packetDictionary['S: ' + 'Packets Dropped (Connection: Attacker-Malicious Server)'].append(connectionAttackerMServer.packetsDropped) self.packetDictionary['S: ' + 'Packets Delivered (Connection: Attacker-Malicious Server)'].append(connectionAttackerMServer.packetsDelivered) @@ -135,15 +193,12 @@ def addSummaryDataToLog(self, client, attacker, MServer, NServer, router, connec if (len(self.packetDictionary['S: ' + ' Step']) > self.lengthLongestEntry): self.lengthLongestEntry = len(self.packetDictionary["S: " + ' Step']) - - - def initializeSummary(self): #initializer for the summary file + def initializeSummary(self): # initializer for the summary file self.summaryFile = open("summary.csv", "w") self.headerGen(self.summaryFile) - def initializeAnimationInstructions(self): - #self.currentAnimations = "" #used to hold the instructions for the current line of the animation instructions + # self.currentAnimations = "" #used to hold the instructions for the current line of the animation instructions self.prefix_map = {'C': 'client', 'A': 'attacker', 'R': 'router', 'M': 'mserver', 'N': 'nserver'} self.instructions = [] self.tempInstructions = [] @@ -151,38 +206,138 @@ def initializeAnimationInstructions(self): def updateTime(self): self.curTime += 1 if (self.makeAnimation): - #self.currentAnimations +="\n" + # self.currentAnimations +="\n" self.instructions.append(self.tempInstructions) self.tempInstructions = [] - - def animateTransit(self, source, destination, packet_type, sequence_number, ack_number, dst_port_number, duration): + def animateTransit(self, source, destination, + packet_type, sequence_number, + ack_number, dst_port_number, + duration): if (self.makeAnimation): - #self.currentAnimations += "(" + source + "," + destination + "," + packet_type + "," + str(sequence_number) + "," + str(ack_number) + "," + str(dst_port_number) + ","+ str(duration) + ")" - instruction = ['transit', [self.prefix_map[source], self.prefix_map[destination], packet_type , sequence_number, ack_number, dst_port_number, duration]] + # self.currentAnimations += "(" + source + "," + destination + "," + packet_type + "," + str(sequence_number) + "," + str(ack_number) + "," + str(dst_port_number) + ","+ str(duration) + ")" + instruction = ['transit', [self.prefix_map[source], + self.prefix_map[destination], + packet_type, sequence_number, + ack_number, dst_port_number, duration]] self.tempInstructions.append(instruction) - def animateDrop(self, source, packet_type, sequence_number, ack_number, dst_port_number): + def animateDrop(self, source, packet_type, + sequence_number, ack_number, + dst_port_number): if (self.makeAnimation): - #self.currentAnimations += "[" + source + "," + packet_type + "," + str(sequence_number) + "," + str(ack_number) + "," + str(dst_port_number) + "]" + # self.currentAnimations += "[" + source + "," + packet_type + "," + str(sequence_number) + "," + str(ack_number) + "," + str(dst_port_number) + "]" instruction = ['drop', [self.prefix_map[source], packet_type, sequence_number, ack_number, dst_port_number]] self.tempInstructions.append(instruction) - def animateData(self, clientData, MServerData, NServerData, routerData, attackerData): #function for generating data instructions. Using lists vastly improves readability (the alternative is this function being 25 arguments long) + def animateData(self, clientData, MServerData, + NServerData, routerData, + attackerData): # function for generating data instructions. if (self.makeAnimation): for entity in [clientData, MServerData, NServerData, routerData, attackerData]: instruction = ['data', entity] self.tempInstructions.append(instruction) - def updateSummary(self, client, attacker, MServer, NServer, router, connectionClientRouter, connectionRouterMServer, connectionRouterNServer, connectionAttackerMServer): - flag = False; - if (self.makeSummary and flag == False): - self.summaryFile.write(str(self.curTime) + ',' + str(attacker.packetsSent) + ',' + str(attacker.packetsReceived) + ',' + str(attacker.packetsDropped) + ',0,0,' + str(client.packetsSent) + ',' + str(client.packetsReceived) + ',' + str(client.packetsDropped) + ','+ str(client.packetsReceived/self.curTime) +','+ str(client.packetsDropped/self.curTime) + ',' + str(router.packetsSent) + ',' + str(router.packetsReceived) + ',' + str(router.packetsDropped) + ',' + str(router.packetsReceived/self.curTime) +','+ str(router.packetsDropped/self.curTime) + ',' + str(MServer.packetsSent) + ',' + str(MServer.packetsReceived) + ',' + str(MServer.packetsDropped) + ','+ str(MServer.packetsReceived/self.curTime) +','+ str(MServer.packetsDropped/self.curTime) + ',' + str(NServer.packetsSent) + ',' + str(NServer.packetsReceived) + ',' + str(NServer.packetsDropped) + ','+ str(NServer.packetsReceived/self.curTime) +','+ str(NServer.packetsDropped/self.curTime) + ',' + str(connectionAttackerMServer.packetsAccepted) + ',' + str(connectionAttackerMServer.packetsDropped) + ',' + str(connectionAttackerMServer.packetsDelivered) + ',' + str(connectionAttackerMServer.packetsReceived/self.curTime) +','+ str(connectionAttackerMServer.packetsDropped/self.curTime) + ',' + str(connectionRouterMServer.packetsAccepted) + ',' + str(connectionRouterMServer.packetsDropped) + ',' + str(connectionRouterMServer.packetsDelivered) + ',' + str(connectionRouterMServer.packetsReceived/self.curTime) +','+ str(connectionRouterMServer.packetsDropped/self.curTime) + ',' + str(connectionRouterNServer.packetsAccepted) + ',' + str(connectionRouterNServer.packetsDropped) + ',' + str(connectionRouterNServer.packetsDelivered) + ','+ str(connectionRouterNServer.packetsReceived/self.curTime) +','+ str(connectionRouterNServer.packetsDropped/self.curTime) + ',' + str(connectionClientRouter.packetsAccepted) + ',' + str(connectionClientRouter.packetsDropped) + ',' + str(connectionClientRouter.packetsDelivered) + ',' + str(connectionClientRouter.packetsReceived/self.curTime) +','+ str(connectionClientRouter.packetsDropped/self.curTime) + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + '\n') - elif (self.makeSummary and flag == True): + def updateSummary(self, client, attacker, + MServer, NServer, router, + connectionClientRouter, + connectionRouterMServer, + connectionRouterNServer, + connectionAttackerMServer): + flag = False + if(self.makeSummary and flag is False): + self.summaryFile.write(str(self.curTime) + ',' + + str(attacker.packetsSent) + ',' + + str(attacker.packetsReceived) + + ',' + str(attacker.packetsDropped) + + ',0,0,' + str(client.packetsSent) + + ',' + str(client.packetsReceived) + + ',' + str(client.packetsDropped) + + ',' + str(client.packetsReceived/self.curTime) + + ',' + str(client.packetsDropped/self.curTime) + + ',' + str(router.packetsSent) + + ',' + str(router.packetsReceived) + + ',' + str(router.packetsDropped) + + ',' + str(router.packetsReceived/self.curTime) + + ',' + str(router.packetsDropped/self.curTime) + + ',' + str(MServer.packetsSent) + + ',' + str(MServer.packetsReceived) + + ',' + str(MServer.packetsDropped) + + ',' + str(MServer.packetsReceived/self.curTime) + + ',' + str(MServer.packetsDropped/self.curTime) + + ',' + str(NServer.packetsSent) + + ',' + str(NServer.packetsReceived) + + ',' + str(NServer.packetsDropped) + + ',' + str(NServer.packetsReceived/self.curTime) + + ',' + str(NServer.packetsDropped/self.curTime) + + ',' + str(connectionAttackerMServer.packetsAccepted) + + ',' + str(connectionAttackerMServer.packetsDropped) + + ',' + str(connectionAttackerMServer.packetsDelivered) + + ',' + str(connectionAttackerMServer.packetsReceived/self.curTime) + + ',' + str(connectionAttackerMServer.packetsDropped/self.curTime) + + ',' + str(connectionRouterMServer.packetsAccepted) + + ',' + str(connectionRouterMServer.packetsDropped) + + ',' + str(connectionRouterMServer.packetsDelivered) + + ',' + str(connectionRouterMServer.packetsReceived/self.curTime) + + ',' + str(connectionRouterMServer.packetsDropped/self.curTime) + + ',' + str(connectionRouterNServer.packetsAccepted) + + ',' + str(connectionRouterNServer.packetsDropped) + + ',' + str(connectionRouterNServer.packetsDelivered) + + ',' + str(connectionRouterNServer.packetsReceived/self.curTime) + + ',' + str(connectionRouterNServer.packetsDropped/self.curTime) + + ',' + str(connectionClientRouter.packetsAccepted) + + ',' + str(connectionClientRouter.packetsDropped) + + ',' + str(connectionClientRouter.packetsDelivered) + + ',' + str(connectionClientRouter.packetsReceived/self.curTime) + + ',' + str(connectionClientRouter.packetsDropped/self.curTime) + + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + '\n') + elif (self.makeSummary and flag is True): print(".") - self.summaryFile.write(str(self.curTime) + ',' + str('attacker.packetsSent') + ',' + str('attacker.packetsReceived') + ',' + str('attacker.packetsDropped') + ',0,0,' + str('client.packetsSent') + ',' + str('client.packetsReceived') + ',' + str('client.packetsDropped') + ','+ str('client.packetsReceived/self.curTime') +','+ str('client.packetsDropped/self.curTime') + ',' + str('router.packetsSent') + ',' + str('router.packetsReceived') + ',' + str('router.packetsDropped') + ',' + str('router.packetsReceived/self.curTime') +','+ str('router.packetsDropped/self.curTime') + ',' + str('MServer.packetsSent') + ',' + str('MServer.packetsReceived') + ',' + str('MServer.packetsDropped') + ','+ str('MServer.packetsReceived/self.curTime') +','+ str('MServer.packetsDropped/self.curTime') + ',' + str('NServer.packetsSent') + ',' + str('NServer.packetsReceived') + ',' + str('NServer.packetsDropped') + ','+ str('NServer.packetsReceived/self.curTime') +','+ str('NServer.packetsDropped/self.curTime') + ',' + str('connectionAttackerMServer.packetsAccepted') + ',' + str('connectionAttackerMServer.packetsDropped') + ',' + str('connectionAttackerMServer.packetsDelivered') + ',' + str('connectionAttackerMServer.packetsReceived/self.curTime') +','+ str('connectionAttackerMServer.packetsDropped/self.curTime') + ',' + str('connectionRouterMServer.packetsAccepted') + ',' + str('connectionRouterMServer.packetsDropped') + ',' + str('connectionRouterMServer.packetsDelivered') + ',' + str('connectionRouterMServer.packetsReceived/self.curTime') +','+ str('connectionRouterMServer.packetsDropped/self.curTime') + ',' + str('connectionRouterNServer.packetsAccepted') + ',' + str('connectionRouterNServer.packetsDropped') + ',' + str('connectionRouterNServer.packetsDelivered') + ','+ str('connectionRouterNServer.packetsReceived/self.curTime') +','+ str('connectionRouterNServer.packetsDropped/self.curTime') + ',' + str('connectionClientRouter.packetsAccepted') + ',' + str('connectionClientRouter.packetsDropped') + ',' + str('connectionClientRouter.packetsDelivered') + ',' + str('connectionClientRouter.packetsReceived/self.curTime') +','+ str('connectionClientRouter.packetsDropped/self.curTime') + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + '\n') - - + self.summaryFile.write(str(self.curTime) + ',' + + str('attacker.packetsSent') + + ',' + str('attacker.packetsReceived') + + ',' + str('attacker.packetsDropped') + + ',0,0,' + str('client.packetsSent') + + ',' + str('client.packetsReceived') + + ',' + str('client.packetsDropped') + + ',' + str('client.packetsReceived/self.curTime') + + ',' + str('client.packetsDropped/self.curTime') + + ',' + str('router.packetsSent') + + ',' + str('router.packetsReceived') + + ',' + str('router.packetsDropped') + + ',' + str('router.packetsReceived/self.curTime') + + ',' + str('router.packetsDropped/self.curTime') + + ',' + str('MServer.packetsSent') + + ',' + str('MServer.packetsReceived') + + ',' + str('MServer.packetsDropped') + + ',' + str('MServer.packetsReceived/self.curTime') + + ',' + str('MServer.packetsDropped/self.curTime') + + ',' + str('NServer.packetsSent') + + ',' + str('NServer.packetsReceived') + + ',' + str('NServer.packetsDropped') + + ',' + str('NServer.packetsReceived/self.curTime') + + ',' + str('NServer.packetsDropped/self.curTime') + + ',' + str('connectionAttackerMServer.packetsAccepted') + + ',' + str('connectionAttackerMServer.packetsDropped') + + ',' + str('connectionAttackerMServer.packetsDelivered') + + ',' + str('connectionAttackerMServer.packetsReceived/self.curTime') + + ',' + str('connectionAttackerMServer.packetsDropped/self.curTime') + + ',' + str('connectionRouterMServer.packetsAccepted') + + ',' + str('connectionRouterMServer.packetsDropped') + + ',' + str('connectionRouterMServer.packetsDelivered') + + ',' + str('connectionRouterMServer.packetsReceived/self.curTime') + + ',' + str('connectionRouterMServer.packetsDropped/self.curTime') + + ',' + str('connectionRouterNServer.packetsAccepted') + + ',' + str('connectionRouterNServer.packetsDropped') + + ',' + str('connectionRouterNServer.packetsDelivered') + + ',' + str('connectionRouterNServer.packetsReceived/self.curTime') + + ',' + str('connectionRouterNServer.packetsDropped/self.curTime') + + ',' + str('connectionClientRouter.packetsAccepted') + + ',' + str('connectionClientRouter.packetsDropped') + + ',' + str('connectionClientRouter.packetsDelivered') + + ',' + str('connectionClientRouter.packetsReceived/self.curTime') + + ',' + str('connectionClientRouter.packetsDropped/self.curTime') + + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + ' ' + ',' + '\n') def outputFile(self): # if(self.makeAnimation): @@ -199,16 +354,17 @@ def outputFile(self): # self.packetDictionary["Inputs: "] = ["DDD State " + str(self.dddState), "Send Rate: " + str("self.sendRate") + " MB/s", "Packet Size: " + str(self.packetSize) + " MB", "Resend Time for SYN-ACKs: " + str(self.resendSynAckTime) + " ms", "Max Queue Size for half open connections: " + str(self.MaxQueueSize) + '" MB"', "DDD Mapping Delay" + str(self.dddMappingDelay) + " ms", "Propagation Delay: " + str(self.PropDelay) + " ms", "Number of DDD ports open: " + str(self.NumbDDDPortsOpen), "Bandwidth of connections: " + str("N/A") + " MB/s", "Time until next DDD port change: " + str(self.timeUntilNextDDDChange) + " ms", "Overlap time for old DDD Ports: " + str(self.overlapTime) + " ms", " ", "Program Version 2", "Date and time: " + str(getTime("%c"))] # if (len(self.packetDictionary[ "Inputs: "]) > self.lengthLongestEntry): # self.lengthLongestEntry = len(self.packetDictionary[" Inputs: "]) - for key in self.packetDictionary: #All this does is make each dictionary entry have the same length + for key in self.packetDictionary: # All this does is make each dictionary entry have the same length while (len(self.packetDictionary.get(key)) < self.lengthLongestEntry): self.packetDictionary.get(key).append("") - sortedKeys = sorted(self.packetDictionary.keys(), key = self.sortHelper) + sortedKeys = sorted(self.packetDictionary.keys(), key=self.sortHelper) outputLogFile = open("log.csv", "w", newline='') self.headerGen(outputLogFile, "%L") generator = csv.writer(outputLogFile) generator.writerow(sortedKeys) generator.writerows(zip(*[self.packetDictionary[key] for key in sortedKeys])) outputLogFile.close() + def sortHelper(self, string): if ("Input" in string) or ("Program" in string): return ("A", -1) @@ -217,37 +373,37 @@ def sortHelper(self, string): else: return (string[0], int(string[2:])) - def headerGen(self, file, LogFlag = ""): - #The purpose of this function is to create the header seen at the start of each output file. - #It takes a starting file containing markers (a '$' followed by some letters) and replaces each marker with the corresponding variable, and then writes the updated version to the appropriate file. - #If it is being attached to the log file, indicated by the LogFlag, then the summary section of the header is not included. + def headerGen(self, file, LogFlag=""): + # The purpose of this function is to create the header seen at the start of each output file. + # It takes a starting file containing markers (a '$' followed by some letters) and replaces each marker with the corresponding variable, and then writes the updated version to the appropriate file. + # If it is being attached to the log file, indicated by the LogFlag, then the summary section of the header is not included. self.header = open("summaryHeader.txt", "r") for line in self.header: if (("DATA:" in line) and (LogFlag == "%L")): file.write(line) break - line = line.replace("$BWCR", str(self.clientToRouter)) #BWCR - line = line.replace("$BWRC", str(self.routerToClient)) #BWRC - line = line.replace("$BWRMS", str(self.routerToMServer)) #BWRMS - line = line.replace("$BWRNS", str(self.routerToNServer)) #BWRNS - line = line.replace("$BWNSR", str(self.NServerToRouter)) #BWNSR - line = line.replace("$BWMSR", str(self.MServerToRouter)) #BWMSR - line = line.replace("$BWAMS", str(self.attackerToReflector)) #BWAMS - - line = line.replace("$PACS", str(self.packetSize)) #PACS - line = line.replace("$RSAI", str(self.resendSynAckTime)) #RSAI - line = line.replace("$NSAR", str(self.numbSynAckResends)) #NSAR - line = line.replace("$HOCMQ", str(self.MaxQueueSize)) #HOCMQ - line = line.replace("$DDDMD", str(self.dddMappingDelay)) #DDDMD - line = line.replace("$PROPD", str(self.PropDelay)) #PROPD - line = line.replace("$DDDS", str(self.dddState)) #DDDS - line = line.replace("$DDDPO", str(self.NumbDDDPortsOpen)) #DDDPO - line = line.replace("$DDDCI", str(self.timeUntilNextDDDChange)) #DDDCI - line = line.replace("$DDDOO", str(self.overlapTime))#DDDOO - line = line.replace("$DATE", getTime("%c")) #DATE - line = line.replace("$AI", self.attackerType) #AI - line = line.replace("$APOFLD", self.isAmplification) #APOFLD + line = line.replace("$BWCR", str(self.clientToRouter)) # BWCR + line = line.replace("$BWRC", str(self.routerToClient)) # BWRC + line = line.replace("$BWRMS", str(self.routerToMServer)) # BWRMS + line = line.replace("$BWRNS", str(self.routerToNServer)) # BWRNS + line = line.replace("$BWNSR", str(self.NServerToRouter)) # BWNSR + line = line.replace("$BWMSR", str(self.MServerToRouter)) # BWMSR + line = line.replace("$BWAMS", str(self.attackerToReflector)) # BWAMS + + line = line.replace("$PACS", str(self.packetSize)) # PACS + line = line.replace("$RSAI", str(self.resendSynAckTime)) # RSAI + line = line.replace("$NSAR", str(self.numbSynAckResends)) # NSAR + line = line.replace("$HOCMQ", str(self.MaxQueueSize)) # HOCMQ + line = line.replace("$DDDMD", str(self.dddMappingDelay)) # DDDMD + line = line.replace("$PROPD", str(self.PropDelay)) # PROPD + line = line.replace("$DDDS", str(self.dddState)) # DDDS + line = line.replace("$DDDPO", str(self.NumbDDDPortsOpen)) # DDDPO + line = line.replace("$DDDCI", str(self.timeUntilNextDDDChange)) # DDDCI + line = line.replace("$DDDOO", str(self.overlapTime)) # DDDOO + line = line.replace("$DATE", getTime("%c")) # DATE + line = line.replace("$AI", self.attackerType) # AI + line = line.replace("$APOFLD", self.isAmplification) # APOFLD file.write(line) self.header.close()