Attacker to router and router to attacker connection functionality

Python/attacker.py

@@ -5,12 +5,13 @@
 
 
 class attacker:
-    def __init__(self, connectionToServer, client_IP, server_IP, fileGen,packetSize, bandwidthToMserver,dddController, ipAddress = "", packet_ID_prefix = "A-", attackType = 0, reflecting = 1):
+    def __init__(self, connectionToServer, connectionToRouter, client_IP, server_IP, fileGen,packetSize, bandwidthToMserver,dddController, ipAddress = "", packet_ID_prefix = "A-", attackType = 0, reflecting = 1):
         self.clientIP = client_IP #client's IP, used for generating spoofed packetsDropped
         self.serverIP = server_IP #IP of server used for SYN-ACK Flood
         self.curTime = 0 #Tracks the current time of the simulation
         self.counterPacketsSent = 0 #Counter for the summary file
         self.connectionToServer = connectionToServer #stores the connectionObject connecting the attacker to the server
+        self.connectionToRouter = connectionToRouter
         self.curTime = 0
         self.packetsSent = 0 #counter for logging purposes
         self.packetsReceived = 0 #counter for logging purposes (currently unused but it makes it easier for the log file to operate)
@@ -30,6 +31,7 @@ def __init__(self, connectionToServer, client_IP, server_IP, fileGen,packetSize,
         self.attackType = attackType
         self.reflecting = reflecting
         self.dddController = dddController
+        self.receiveBuffer = []
 
     def processPackets(self):
         if(self.sendingPacket == None):
@@ -53,31 +55,37 @@ def processPackets(self):
 
     def sendPackets(self): #Puts packets onto the connection
         if((self.sendingPacket[1] - self.curTime) < 1):
-            self.packetsSent += 1 #increment counter
-            self.connectionToServer.transferPacketOut(self.sendingPacket[0]) #place packet on connection
-            self.sendingPacket = None
+            if(self.sendingPacket[0].dstIP == self.serverIP):
+                print(self.sendingPacket[0].dstIP)
+                self.packetsSent += 1 #increment counter
+                self.connectionToServer.transferPacketOut(self.sendingPacket[0]) #place packet on connection
+                self.sendingPacket = None
+            else:
+                self.packetsSent += 1 #increment counter
+                self.connectionToRouter.transferPacketOut(self.sendingPacket[0]) #place packet on connection
+                self.sendingPacket = None
 
     def generateSYN(self):
         packetType = "SYN"
         destinationIP = self.serverIP
         sourceIP = self.clientIP
         if (self.reflecting == 0):
-            packetType = "SYN-ACK"
+            packetType = "SYN"
             destinationIP = self.clientIP
-            sourceIP = self.serverIP
+            sourceIP = self.ipAddress
         if(self.attackType == 0):
-            portNumber = random.randint(0, 200) #generate a random port number
+            portNumber = random.randint(0, 500) #generate a random port number
             npacket = packet.packet(sourceIP, portNumber, destinationIP, 80, packetType, random.randint(0, 10000), 0, self.packetIDPrefix + str(self.packetsGenerated),self.packetSize, self.ipAddress) #return the packet
             self.fileGen.addToLog(npacket.packetID, "Generated at Attacker", npacket.sequenceNumber, npacket.ackNumber, npacket.packetType, self.curTime)
             return npacket
         else:
-
             portNumber = self.dddController.currentUsablePorts[random.randint(0,self.dddController.openNumbPorts-1)]
             npacket = packet.packet(sourceIP, portNumber, destinationIP, 80, packetType, random.randint(0, 10000), 0, self.packetIDPrefix + str(self.packetsGenerated),self.packetSize, self.ipAddress) #return the packet
             self.fileGen.addToLog(npacket.packetID, "Generated at Attacker", npacket.sequenceNumber, npacket.ackNumber, npacket.packetType, self.curTime)
             return npacket
 
-
+    def receivePacket(self, packet):
+        self.receiveBuffer.append(packet)
 
     def updateTime(self):
         self.curTime += 1

Python/router.py

@@ -3,14 +3,16 @@
 import random #need the random library to generate random port numbers
 from . import packet
 class router:
-    def __init__(self, queueBufferSize, dddState, ipAddress, dddFilterDelay, dddMappingDelay, clientConnection, remoteServerConnection, attackServerConnection, dddController, dddPortMapper, fileGen,queueLimit, bandwidthToClient, bandwidthToNServer, bandwidthToMserver, packet_ID_prefix = "R-"):
+    def __init__(self, queueBufferSize, dddState, ipAddress, dddFilterDelay, dddMappingDelay, clientConnection, remoteServerConnection, attackServerConnection, attackerConnection, dddController, dddPortMapper, fileGen,queueLimit, bandwidthToClient, bandwidthToNServer, bandwidthToMserver, packet_ID_prefix = "R-"):
         self.queueSize = queueBufferSize #MB's
         self.clientConnection = clientConnection
         self.clientIP = "1.0.0.0"
         self.remoteServerConnection = remoteServerConnection
         self.remoteServerIP = "4.0.0.0"
         self.attackServerConnection = attackServerConnection
-        self.attackServerIP = "5.0.0.0"
+        self.attackServerIP = "3.0.0.0"
+        self.attackerConnection = attackerConnection
+        self.attackerIP = "5.0.0.0"
         self.dddState = dddState
         self.ipAddress = ipAddress
         self.dddFilterDelay = dddFilterDelay
@@ -19,9 +21,12 @@ def __init__(self, queueBufferSize, dddState, ipAddress, dddFilterDelay, dddMapp
         self.queueClient = []
         self.queueNServer = []
         self.queueMServer = []
+        self.queueAttacker = []
         self.sendClient = None
         self.sendNServer = None
         self.sendMServer = None
+        self.sendAttacker = None
+
 
         self.receiveBuffer = []
         self.curTime = 0
@@ -30,11 +35,15 @@ def __init__(self, queueBufferSize, dddState, ipAddress, dddFilterDelay, dddMapp
         self.currentQueueLoadClient = 0
         self.currentQueueLoadNServer = 0
         self.currentQueueLoadMServer = 0
+        self.currentQueueLoadAttacker = 0
+
 
         #self.sendRate = sendRate #MB per sec
         self.bandwidthToClient = bandwidthToClient
         self.bandwidthToNServer = bandwidthToNServer
         self.bandwidthToMserver = bandwidthToMserver
+        self.bandwidthToAttacker = bandwidthToMserver
+
 
         self.dddController = dddController
         self.dddPortMapper = dddPortMapper
@@ -51,6 +60,8 @@ def __init__(self, queueBufferSize, dddState, ipAddress, dddFilterDelay, dddMapp
         self.timeToNextIterationClient = 1
         self.timeToNextIterationNServer = 1
         self.timeToNextIterationMServer = 1
+        self.timeToNextIterationAttacker = 1
+
 
     #Receive packets coming from different connections. Add to receive buffer, drop if receive buffer is full.
     def receivePacket(self, synPacket):
@@ -86,16 +97,24 @@ def addToQueues(self):
                     #Drop Packet
                 self.receiveBuffer.remove(i)
             #Add to clients queue
-            else:
-
+            elif(i.dstIP == self.clientIP):
                 self.currentQueueLoadClient += i.packetSize
                 if(self.currentQueueLoadClient <= self.queueLimit):
                     self.queueClient.append(i)
                 else:
                     self.currentQueueLoadClient -= i.packetSize
                     #Drop Packet
+                self.receiveBuffer.remove(i) 
+            else:
+                self.currentQueueLoadAttacker += i.packetSize
+                if(self.currentQueueLoadAttacker <= self.queueLimit):
+                    self.queueAttacker.append(i)
+                else:
+                    self.currentQueueLoadAttacker -= i.packetSize
+                    #Drop Packet
                 self.receiveBuffer.remove(i)
 
+
     def filterPackets(self, packet):
         allow = False
         for j in self.dddController.currentUsablePorts:
@@ -176,6 +195,24 @@ def processPackets(self):
             elif(self.sendMServer != None):
                 leftoverTime = self.sendMServer[1] - self.curTime
                 self.timeToNextIterationMServer -= leftoverTime
+            if(len(self.queueAttacker) > 0 and self.sendAttacker == None and self.timeToNextIterationAttacker >= 0): #send packet to remote server
+                curPacket = self.queueAttacker.pop(0)
+
+                transmissionDelay = (curPacket.packetSize / self.bandwidthToAttacker) * 1000
+                self.timeToNextIterationAttacker -= transmissionDelay
+                if(self.timeToNextIterationAttacker >= 0):
+                    self.packetsSent += 1
+                    self.sendAttacker = [curPacket, self.curTime + transmissionDelay + self.dddMappingDelay]
+                    self.currentQueueLoadAttacker -= curPacket.packetSize
+                else:
+                    self.timeToNextIterationAttacker += transmissionDelay
+                    self.packetsSent += 1
+                    self.sendAttacker = [curPacket, self.curTime + transmissionDelay + self.dddMappingDelay - (self.timeToNextIterationAttacker)]
+                    self.currentQueueLoadAttacker -= curPacket.packetSize
+                    self.timeToNextIterationAttacker -= transmissionDelay
+            elif(self.sendAttacker != None):
+                leftoverTime = self.sendAttacker[1] - self.curTime
+                self.timeToNextIterationAttacker -= leftoverTime
         else:
             if(len(self.queueClient) > 0 and self.sendClient == None and self.timeToNextIterationClient >= 0): #send packet to client
                 curPacket = self.queueClient.pop(0)
@@ -232,6 +269,24 @@ def processPackets(self):
             elif(self.sendMServer != None):
                 leftoverTime = self.sendMServer[1] - self.curTime
                 self.timeToNextIterationMServer -= leftoverTime
+            if(len(self.queueAttacker) > 0 and self.sendAttacker == None and self.timeToNextIterationAttacker >= 0): #send packet to remote server
+                curPacket = self.queueAttacker.pop(0)
+
+                transmissionDelay = (curPacket.packetSize / self.bandwidthToAttacker) * 1000
+                self.timeToNextIterationAttacker -= transmissionDelay
+                if(self.timeToNextIterationAttacker >= 0):
+                    self.packetsSent += 1
+                    self.sendAttacker = [curPacket, self.curTime + transmissionDelay]
+                    self.currentQueueLoadAttacker -= curPacket.packetSize
+                else:
+                    self.timeToNextIterationAttacker += transmissionDelay
+                    self.packetsSent += 1
+                    self.sendAttacker = [curPacket, self.curTime + transmissionDelay - (self.timeToNextIterationAttacker)]
+                    self.currentQueueLoadAttacker -= curPacket.packetSize
+                    self.timeToNextIterationAttacker -= transmissionDelay
+            elif(self.sendAttacker != None):
+                leftoverTime = self.sendAttacker[1] - self.curTime
+                self.timeToNextIterationAttacker -= leftoverTime
 
 
     #Takes each of the packets that the interfaces are sending and makes sure they are being filtered and/or mapped correctly.
@@ -320,6 +375,34 @@ def sendPackets(self):
                     self.remoteServerConnection.transferPacketOut(self.sendMServer[0])
                     self.packetsSent += 1
                     self.sendMServer = None
+            if(self.sendAttacker != None):
+                if((self.sendAttacker[1] - self.curTime) < 1):
+                    print("Mapping Ports----------------------------------------------------------------------------------------------------------------")
+                    #Check if packet's src port is already mapped.
+                    packetAlreadyMapped = False
+                    for j in self.dddPortMapper.portMappings:
+                        if(j[0] == self.sendAttacker[0].srcPortNumber):
+                            packetAlreadyMapped = True
+                            self.sendAttacker[0].srcPortNumber = j[1]
+                            if(self.sendAttacker[0].packetType == "ACK" or self.sendAttacker[0].packetType == "RST"):
+                                self.dddPortMapper.updateMappings(0, self.sendAttacker[0].srcPortNumber)
+                            break
+                    #If src port isn't already mapped, find open port to map and set that equal to the packets src port
+                    if(packetAlreadyMapped == False):
+                        openPort = self.dddPortMapper.getAvailableOpenPort()
+                        if(openPort == 0):
+                            print("No more ports open")
+                            pass
+                        else:
+                            originalSrcPort = self.sendAttacker[0].srcPortNumber
+                            self.sendAttacker[0].srcPortNumber = openPort
+                            self.dddPortMapper.updateMappings(originalSrcPort, openPort)
+
+                    #Send packet to the either the remote server or the remote attack server
+                    self.sendAttacker[0].sendingDevice = self.ipAddress
+                    self.attackerConnection.transferPacketOut(self.sendAttacker[0])
+                    self.packetsSent += 1
+                    self.sendAttacker = None
 
 	    #if ddd state is off, then send as many packets as possible within the time unit
         else:
@@ -343,6 +426,12 @@ def sendPackets(self):
                     self.attackServerConnection.transferPacketOut(self.sendMServer[0])
                     self.packetsSent += 1
                     self.sendMServer = None
+            if(self.sendAttacker != None):
+                if((self.sendAttacker[1] - self.curTime) < 1):
+                    self.sendAttacker[0].sendingDevice = self.ipAddress
+                    self.attackerConnection.transferPacketOut(self.sendAttacker[0])
+                    self.packetsSent += 1
+                    self.sendAttacker = None
 
 
     #Update time and send packets
@@ -351,8 +440,9 @@ def updateTime(self):
         self.timeToNextIterationClient = 1
         self.timeToNextIterationNServer = 1
         self.timeToNextIterationMServer = 1
+        self.timeToNextIterationAttacker = 1
         #self.numberOfPacketsReceived = 0
         self.addToQueues()
-        while((self.timeToNextIterationClient > 0 and (self.sendClient is not None or len(self.queueClient) > 0)) or (self.timeToNextIterationNServer > 0 and (self.sendNServer is not None or len(self.queueNServer) > 0)) or (self.timeToNextIterationMServer > 0 and (self.sendMServer is not None or len(self.queueMServer) > 0))):
+        while((self.timeToNextIterationClient > 0 and (self.sendClient is not None or len(self.queueClient) > 0)) or (self.timeToNextIterationNServer > 0 and (self.sendNServer is not None or len(self.queueNServer) > 0)) or (self.timeToNextIterationMServer > 0 and (self.sendMServer is not None or len(self.queueMServer) > 0)) or (self.timeToNextIterationAttacker > 0 and (self.sendAttacker is not None or len(self.queueAttacker) > 0))):
             self.processPackets()
             self.sendPackets()