Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
CSEGroup22SDP/Python/filegenerator.py
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
619 lines (573 sloc)
44.2 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| from time import strftime as getTime | |
| import csv | |
| import json | |
| import os | |
| from . import connectionObject | |
| import matplotlib.pyplot as plt | |
| 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, storageFolder, sessionId): | |
| # boolean statements for deciding which files to make | |
| self.makeLog = make_log | |
| self.makeSummary = make_summary | |
| self.makeAnimation = make_animation | |
| # Make folders | |
| try: | |
| os.mkdir(storageFolder) | |
| except FileExistsError: | |
| pass # This error is to be expected. | |
| # If FileExistsError happens here, this means a GUID collision. I don't think it is possible. | |
| os.mkdir(os.path.join(storageFolder, str(sessionId))) | |
| self.storageFolder = os.path.join(storageFolder, str(sessionId)) | |
| # File Name to be used | |
| self.logFileName = os.path.join(self.storageFolder, "log.csv") | |
| self.summaryFileName = os.path.join(self.storageFolder, "summary.csv") | |
| # names of the output files | |
| self.logName = log_name | |
| self.summaryName = summary_name | |
| self.sessionId = sessionId | |
| self.curTime = 0 # current time unit (same as the other classes) | |
| self.dddState = dddState | |
| self.clientToRouter = bandwidths[0] | |
| self.routerToClient = bandwidths[1] | |
| self.routerToMServer = bandwidths[2] | |
| self.routerToNServer = bandwidths[3] | |
| self.NServerToRouter = bandwidths[4] | |
| self.MServerToRouter = bandwidths[5] | |
| self.attackerToReflector = bandwidths[6] | |
| self.packetSize = packetSize | |
| self.resendSynAckTime = resendSynAckTime | |
| self.numbSynAckResends = numbSynAckResends | |
| self.MaxQueueSize = MaxQueueSize | |
| self.dddMappingDelay = DDDMappingDelay | |
| self.PropDelay = PropDelay | |
| self.NumbDDDPortsOpen = NumbDDDPortsOpen | |
| self.timeUntilNextDDDChange = timeUntilNextDDDChange | |
| self.overlapTime = overlapTime | |
| if (attackerType == 0): | |
| self.attackerType = "Ignorant" | |
| else: | |
| self.attackerType = "Smart" | |
| if (isAmplification == 0): | |
| self.isAmplification = "No Amplification" | |
| else: | |
| self.isAmplification = "Amplification" | |
| if (self.makeAnimation): | |
| self.initializeAnimationInstructions() | |
| if (self.makeSummary): | |
| self.initializeSummary() | |
| if (self.makeLog): | |
| self.initializeLog() | |
| # 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 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 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 Sent (Reflection Server)', 'Packets Received (Reflection Server)', | |
| 'Packets Dropped (Reflection Server)', | |
| 'Average Number of Packets Received per ms (Reflection Server)', | |
| 'Average Number of Packets Dropped per ms (Reflection 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-Reflection Server)', | |
| 'Packets Dropped (Connection: Attacker-Reflection Server)', | |
| 'Packets Delivered (Connection: Attacker-Reflection Server)', | |
| 'Average Number of Packets Received per ms (Connection: Attacker-Reflection Server)', | |
| 'Average Number of Packets Dropped per ms (Connection: Attacker-Reflection Server)', | |
| 'Packets Accepted (Connection: Router-Reflection Server)', | |
| 'Packets Dropped (Connection: Router-Reflection Server)', | |
| 'Packets Delivered (Connection: Router-Reflection Server)', | |
| 'Average Number of Packets Received per ms (Connection: Router-Reflection Server)', | |
| 'Average Number of Packets Dropped per ms (Connection: Router-Reflection Server)', | |
| 'Packets Accepted (Connection: Reflection Server-Router)', | |
| 'Packets Dropped (Connection: Reflection Server-Router)', | |
| 'Packets Delivered (Connection: Reflection Server-Router)', | |
| 'Average Number of Packets Received per ms (Connection: Reflection Server-Router)', | |
| 'Average Number of Packets Dropped per ms (Connection: Reflection Server-Router)', | |
| 'Packets Accepted (Connection: Router-Normal Server)', | |
| 'Packets Dropped (Connection: Router-Normal Server)', | |
| 'Packets Delivered (Connection: Router-Normal Server)', | |
| 'Average Number of Packets Received per ms (Connection: Router-Normal Server)', | |
| 'Average Number of Packets Dropped per ms (Connection: Router-Normal Server)', | |
| '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: Client-NAT)', | |
| 'Packets Dropped (Connection: Client-NAT)', | |
| 'Packets Delivered (Connection: Client-NAT)', | |
| 'Average Number of Packets Received per ms (Connection: Client-NAT)', | |
| 'Average Number of Packets Dropped per ms (Connection: Client-NAT)', | |
| 'Packets Accepted (Connection: NAT-Client)', | |
| 'Packets Dropped (Connection: NAT-Client)', | |
| 'Packets Delivered (Connection: NAT-Client)', | |
| 'Average Number of Packets Received per ms (Connection: NAT-Client)', | |
| 'Average Number of Packets Dropped per ms (Connection: NAT-Client)', | |
| 'Packets Accepted (Connection: Attacker-Router)', | |
| 'Packets Dropped (Connection: Attacker-Router)', | |
| 'Packets Delivered (Connection: Attacker-Router)', | |
| 'Average Number of Packets Received per ms (Connection: Attacker-Router)', | |
| 'Average Number of Packets Dropped per ms (Connection: Attacker-Router)', | |
| 'Packets Accepted (Connection: Router-Attacker)', | |
| 'Packets Dropped (Connection: Router-Attacker)', | |
| 'Packets Delivered (Connection: Router-Attacker)', | |
| 'Average Number of Packets Received per ms (Connection: Router-Attacker)', | |
| 'Average Number of Packets Dropped per ms (Connection: Router-Attacker)', | |
| 'Packets Accepted (Connection: NAT-Router)', | |
| 'Packets Dropped (Connection: NAT-Router)', | |
| 'Packets Delivered (Connection: NAT-Router)', | |
| 'Average Number of Packets Received per ms (Connection: NAT-Router)', | |
| 'Average Number of Packets Dropped per ms (Connection: NAT-Router)', | |
| 'Packets Accepted (Connection: Router-NAT)', | |
| 'Packets Dropped (Connection: Router-NAT)', | |
| 'Packets Delivered (Connection: Router-NAT)', | |
| 'Average Number of Packets Received per ms (Connection: Router-NAT)', | |
| 'Average Number of Packets Dropped per ms (Connection: Router-NAT)', | |
| 'Packets Sent (NAT)', 'Packets Received (NAT)','Packets Dropped (NAT)', | |
| 'Average Number of Packets Received per ms (NAT)','Average Number of Packets Dropped per ms (NAT)']: # [:37] | |
| 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 | |
| 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.lengthLongestEntry = len(self.packetDictionary[packetID]) | |
| def addSummaryDataToLog(self, client, attacker, MServer, | |
| NServer, router, NAT, | |
| connectionClientNat, connectionNatClient, | |
| connectionRouterMServer, connectionMServerRouter, | |
| connectionRouterNServer, connectionNServerRouter, | |
| connectionRouterNat, connectionNatRouter, | |
| connectionAttackerMServer, | |
| connectionAttackerRouter, connectionRouterAttacker): | |
| if(self.makeLog): | |
| self.packetDictionary['S: ' + ' Step'].append(self.curTime) | |
| # #self.packetDictionary['S: ' + 'Packets Generated (Attacker)'].append(attacker.packetsGenerated) | |
| self.packetDictionary['S: ' + 'Packets Sent (Attacker)'].append(attacker.packetsSent) | |
| self.packetDictionary['S: ' + 'Packets Received (Attacker)'].append(attacker.packetsReceived) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Attacker)'].append(attacker.packetsDropped) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Attacker)'].append(attacker.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Attacker)'].append(attacker.packetsDropped/self.curTime) | |
| # #self.packetDictionary['S: ' + 'Packets Generated (Client)'].append(client.packetsGenerated) | |
| self.packetDictionary['S: ' + 'Packets Sent (Client)'].append(client.packetsSent) | |
| self.packetDictionary['S: ' + 'Packets Received (Client)'].append(client.packetsReceived) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Client)'].append(client.packetsDropped) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Client)'].append(client.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Client)'].append(client.packetsDropped/self.curTime) | |
| self.packetDictionary['S: ' + 'Packets Sent (Router)'].append(router.packetsSent) | |
| self.packetDictionary['S: ' + 'Packets Received (Router)'].append(router.packetsReceived) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Router)'].append(router.packetsDropped) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Router)'].append(router.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Router)'].append(router.packetsDropped/self.curTime) | |
| # | |
| # #self.packetDictionary['S: ' + 'Packets Generated (Reflection Server)'].append(MServer.packetsGenerated) | |
| self.packetDictionary['S: ' + 'Packets Sent (Reflection Server)'].append(MServer.packetsSent) | |
| self.packetDictionary['S: ' + 'Packets Received (Reflection Server)'].append(MServer.packetsReceived) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Reflection Server)'].append(MServer.packetsDropped) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Reflection Server)'].append(MServer.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Reflection 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) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Normal Server)'].append(NServer.packetsDropped) | |
| 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 Sent (NAT)'].append(NAT.packetsSent) | |
| self.packetDictionary['S: ' + 'Packets Received (NAT)'].append(NAT.packetsReceived) | |
| self.packetDictionary['S: ' + 'Packets Dropped (NAT)'].append(NAT.packetsDropped) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (NAT)'].append(NAT.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (NAT)'].append(NAT.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: Attacker-Reflection Server)'].append(connectionAttackerMServer.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: Attacker-Reflection Server)'].append(connectionAttackerMServer.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: Attacker-Reflection Server)'].append(connectionAttackerMServer.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: Attacker-Reflection Server)'].append(connectionAttackerMServer.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: Attacker-Reflection Server)'].append(connectionAttackerMServer.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: Router-Reflection Server)'].append(connectionRouterMServer.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: Router-Reflection Server)'].append(connectionRouterMServer.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: Router-Reflection Server)'].append(connectionRouterMServer.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: Router-Reflection Server)'].append(connectionRouterMServer.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: Router-Reflection Server)'].append(connectionRouterMServer.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: Reflection Server-Router)'].append(connectionMServerRouter.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: Reflection Server-Router)'].append(connectionMServerRouter.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: Reflection Server-Router)'].append(connectionMServerRouter.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: Reflection Server-Router)'].append(connectionMServerRouter.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: Reflection Server-Router)'].append(connectionMServerRouter.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: Router-Normal Server)'].append(connectionRouterNServer.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: Router-Normal Server)'].append(connectionRouterNServer.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: Router-Normal Server)'].append(connectionRouterNServer.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: Router-Normal Server)'].append(connectionRouterNServer.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: Router-Normal Server)'].append(connectionRouterNServer.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: Normal Server-Router)'].append(connectionNServerRouter.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: Normal Server-Router)'].append(connectionNServerRouter.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: Normal Server-Router)'].append(connectionNServerRouter.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: Normal Server-Router)'].append(connectionNServerRouter.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: Normal Server-Router)'].append(connectionNServerRouter.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: Client-NAT)'].append(connectionClientNat.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: Client-NAT)'].append(connectionClientNat.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: Client-NAT)'].append(connectionClientNat.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: Client-NAT)'].append(connectionClientNat.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: Client-NAT)'].append(connectionClientNat.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: NAT-Client)'].append(connectionNatClient.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: NAT-Client)'].append(connectionNatClient.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: NAT-Client)'].append(connectionNatClient.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: NAT-Client)'].append(connectionNatClient.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: NAT-Client)'].append(connectionNatClient.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: Attacker-Router)'].append(connectionAttackerRouter.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: Attacker-Router)'].append(connectionAttackerRouter.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: Attacker-Router)'].append(connectionAttackerRouter.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: Attacker-Router)'].append(connectionAttackerRouter.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: Attacker-Router)'].append(connectionAttackerRouter.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: Router-Attacker)'].append(connectionRouterAttacker.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: Router-Attacker)'].append(connectionRouterAttacker.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: Router-Attacker)'].append(connectionRouterAttacker.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: Router-Attacker)'].append(connectionRouterAttacker.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: Router-Attacker)'].append(connectionRouterAttacker.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: NAT-Router)'].append(connectionNatRouter.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: NAT-Router)'].append(connectionNatRouter.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: NAT-Router)'].append(connectionNatRouter.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: NAT-Router)'].append(connectionNatRouter.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: NAT-Router)'].append(connectionNatRouter.packetsDropped/self.curTime) | |
| # | |
| self.packetDictionary['S: ' + 'Packets Accepted (Connection: Router-NAT)'].append(connectionRouterNat.packetsAccepted) | |
| self.packetDictionary['S: ' + 'Packets Dropped (Connection: Router-NAT)'].append(connectionRouterNat.packetsDropped) | |
| self.packetDictionary['S: ' + 'Packets Delivered (Connection: Router-NAT)'].append(connectionRouterNat.packetsDelivered) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Received per ms (Connection: Router-NAT)'].append(connectionRouterNat.packetsReceived/self.curTime) | |
| self.packetDictionary['S: ' + 'Average Number of Packets Dropped per ms (Connection: Router-NAT)'].append(connectionRouterNat.packetsDropped/self.curTime) | |
| # | |
| if (len(self.packetDictionary['S: ' + ' Step']) > self.lengthLongestEntry): | |
| self.lengthLongestEntry = len(self.packetDictionary["S: " + ' Step']) | |
| def initializeSummary(self): # initializer for the summary file | |
| self.summaryFile = open(self.summaryFileName, "w") | |
| self.headerGen(self.summaryFile) | |
| def initializeAnimationInstructions(self): | |
| # 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', 'T': 'nat'} | |
| self.instructions = [] | |
| self.tempInstructions = [] | |
| def updateTime(self): | |
| self.curTime += 1 | |
| if (self.makeAnimation): | |
| # 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): | |
| 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.tempInstructions.append(instruction) | |
| 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) + "]" | |
| 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, natData): # 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, NAT, | |
| connectionClientNat, connectionNatClient, | |
| connectionRouterMServer, connectionMServerRouter, | |
| connectionRouterNServer, connectionNServerRouter, | |
| connectionRouterNat, connectionNatRouter, | |
| connectionAttackerMServer, | |
| connectionAttackerRouter, connectionRouterAttacker): | |
| 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(NAT.packetsSent) | |
| + ',' + str(NAT.packetsReceived) | |
| + ',' + str(NAT.packetsDropped) | |
| + ',' + str(NAT.packetsReceived/self.curTime) | |
| + ',' + str(NAT.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(connectionMServerRouter.packetsAccepted) | |
| + ',' + str(connectionMServerRouter.packetsDropped) | |
| + ',' + str(connectionMServerRouter.packetsDelivered) | |
| + ',' + str(connectionMServerRouter.packetsReceived/self.curTime) | |
| + ',' + str(connectionMServerRouter.packetsDropped/self.curTime) | |
| + ',' + str(connectionRouterNServer.packetsAccepted) | |
| + ',' + str(connectionRouterNServer.packetsDropped) | |
| + ',' + str(connectionRouterNServer.packetsDelivered) | |
| + ',' + str(connectionRouterNServer.packetsReceived/self.curTime) | |
| + ',' + str(connectionRouterNServer.packetsDropped/self.curTime) | |
| + ',' + str(connectionNServerRouter.packetsAccepted) | |
| + ',' + str(connectionNServerRouter.packetsDropped) | |
| + ',' + str(connectionNServerRouter.packetsDelivered) | |
| + ',' + str(connectionNServerRouter.packetsReceived/self.curTime) | |
| + ',' + str(connectionNServerRouter.packetsDropped/self.curTime) | |
| + ',' + str(connectionClientNat.packetsAccepted) | |
| + ',' + str(connectionClientNat.packetsDropped) | |
| + ',' + str(connectionClientNat.packetsDelivered) | |
| + ',' + str(connectionClientNat.packetsReceived/self.curTime) | |
| + ',' + str(connectionClientNat.packetsDropped/self.curTime) | |
| + ',' + str(connectionNatClient.packetsAccepted) | |
| + ',' + str(connectionNatClient.packetsDropped) | |
| + ',' + str(connectionNatClient.packetsDelivered) | |
| + ',' + str(connectionNatClient.packetsReceived/self.curTime) | |
| + ',' + str(connectionNatClient.packetsDropped/self.curTime) | |
| + ',' + str(connectionAttackerRouter.packetsAccepted) | |
| + ',' + str(connectionAttackerRouter.packetsDropped) | |
| + ',' + str(connectionAttackerRouter.packetsDelivered) | |
| + ',' + str(connectionAttackerRouter.packetsReceived/self.curTime) | |
| + ',' + str(connectionAttackerRouter.packetsDropped/self.curTime) | |
| + ',' + str(connectionRouterAttacker.packetsAccepted) | |
| + ',' + str(connectionRouterAttacker.packetsDropped) | |
| + ',' + str(connectionRouterAttacker.packetsDelivered) | |
| + ',' + str(connectionRouterAttacker.packetsReceived/self.curTime) | |
| + ',' + str(connectionRouterAttacker.packetsDropped/self.curTime) | |
| + ',' + str(connectionNatRouter.packetsAccepted) | |
| + ',' + str(connectionNatRouter.packetsDropped) | |
| + ',' + str(connectionNatRouter.packetsDelivered) | |
| + ',' + str(connectionNatRouter.packetsReceived/self.curTime) | |
| + ',' + str(connectionNatRouter.packetsDropped/self.curTime) | |
| + ',' + str(connectionRouterNat.packetsAccepted) | |
| + ',' + str(connectionRouterNat.packetsDropped) | |
| + ',' + str(connectionRouterNat.packetsDelivered) | |
| + ',' + str(connectionRouterNat.packetsReceived/self.curTime) | |
| + ',' + str(connectionRouterNat.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') | |
| def outputFile(self): | |
| # if(self.makeAnimation): | |
| # #instructionFile = open("animationInstructions.txt", "w") | |
| # #instructionFile.write(self.currentAnimations) | |
| # #instructionFile.close() | |
| # | |
| # with open("animationInstructions2.json", 'w') as fp: | |
| # json.dump(self.instructions, fp, indent=4) | |
| if(self.makeSummary): | |
| self.summaryFile.close() | |
| self.initalizePlot() | |
| self.genPlot("Sent", 1) | |
| self.genPlot("Received", 2) | |
| self.genPlot("Dropped", 3) | |
| self.genPlot("Dropped on Average", 4) | |
| self.genPlot("Received on Average", 5) | |
| self.genPlotPage() | |
| if (self.makeLog): | |
| # 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 | |
| while (len(self.packetDictionary.get(key)) < self.lengthLongestEntry): | |
| self.packetDictionary.get(key).append("") | |
| sortedKeys = sorted(self.packetDictionary.keys(), key=self.sortHelper) | |
| outputLogFile = open(self.logFileName, "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 genPlotPage(self): | |
| fp = open(os.path.join("templates", "temp_graph.html"),"rt") | |
| html_code = fp.read() | |
| fp.close() | |
| fp = open(os.path.join(self.storageFolder, "Graph.html"),"w") | |
| code_part = html_code.split("<h2></h2>") | |
| html_code = "{0}<h2>Session {1}</h2>{2}".format(code_part[0], str(self.sessionId), code_part[1]) | |
| fp.write(html_code) | |
| fp.close() | |
| def sortHelper(self, string): | |
| if ("Input" in string) or ("Program" in string): | |
| return ("A", -1) | |
| elif ("Packets" in string) or ("Step" in string): | |
| return ("Z", -1) | |
| 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. | |
| 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 | |
| file.write(line) | |
| self.header.close() | |
| def initalizePlot(self): | |
| summary = open(self.summaryFileName) | |
| self.masterLst = list() | |
| for line in summary: | |
| self.masterLst.append(line.split(",")) | |
| summary.close() | |
| def genPlot(self, name, start): | |
| time = [float(self.masterLst[i][0]) for i in range(19, len(self.masterLst))] | |
| aCol = [float(self.masterLst[i][start]) for i in range(19, len(self.masterLst))] | |
| cCol = [float(self.masterLst[i][start+5]) for i in range(19, len(self.masterLst))] | |
| rCol = [float(self.masterLst[i][start+10]) for i in range(19, len(self.masterLst))] | |
| mCol = [float(self.masterLst[i][start+15]) for i in range(19, len(self.masterLst))] | |
| nCol = [float(self.masterLst[i][start+20]) for i in range(19, len(self.masterLst))] | |
| tCol = [float(self.masterLst[i][start+25]) for i in range(19, len(self.masterLst))] | |
| print("T: ", time) | |
| print("A: ", aCol) | |
| print("C: ", cCol) | |
| print("R: ", rCol) | |
| print("M: ", mCol) | |
| print("N: ", nCol) | |
| print("T: ", tCol) | |
| plt.plot(time, aCol, label="Attacker") | |
| plt.plot(time, cCol, label="Client") | |
| plt.plot(time, rCol, label="Router") | |
| plt.plot(time, mCol, label="Amplifying Server") | |
| plt.plot(time, nCol, label="Normal Server") | |
| plt.plot(time, tCol, label="NAT") | |
| plt.xlabel("Time (ms)") | |
| plt.ylabel("Packets " + name) | |
| plt.title("Packets " + name + " vs. Time") | |
| plt.legend() | |
| plt.savefig(os.path.join(self.storageFolder, name + ".svg")) | |
| plt.close() |