Fixed Smart Attacker

Python/attacker.py

@@ -5,7 +5,7 @@
 
 
 class attacker:
-    def __init__(self, connectionToServer, connectionToRouter, 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, 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
@@ -30,9 +30,9 @@ def __init__(self, connectionToServer, connectionToRouter, client_IP, server_IP,
         self.timeToNextIteration = 1
         self.attackType = attackType
         self.reflecting = reflecting
-        self.dddController = dddController
-        self.receiveBuffer = []
-
+
+        self.openPort = None
+        self.checkOpenPorts = 0
     def processPackets(self):
         if(self.sendingPacket == None):
             self.timeToNextIteration -= self.transmissionDelay
@@ -79,13 +79,30 @@ def generateSYN(self):
             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
+            if(self.openPort == None):
+                portNumber = random.randint(0, 500) #generate a random port number
+                npacket = packet.packet(self.ipAddress, portNumber,self.clientIP, 80, "PING", random.randint(0, 10000), 0, self.packetIDPrefix + str(self.packetsGenerated),self.packetSize, self.ipAddress)
+                self.fileGen.addToLog(npacket.packetID, "Generated at Attacker", npacket.sequenceNumber, npacket.ackNumber, npacket.packetType, self.curTime)
+                return npacket
+            elif(self.checkOpenPorts >= 10):
+                npacket = packet.packet(self.ipAddress, self.openPort,self.clientIP, 80, "PING", random.randint(0, 10000), 0, self.packetIDPrefix + str(self.packetsGenerated),self.packetSize, self.ipAddress)
+                self.fileGen.addToLog(npacket.packetID, "Generated at Attacker", npacket.sequenceNumber, npacket.ackNumber, npacket.packetType, self.curTime)
+                return npacket
+            else:
+                npacket = packet.packet(sourceIP, self.openPort, 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)
+                self.checkOpenPorts += 1
+                return npacket
+
+
 
     def receivePacket(self, packet):
-        self.receiveBuffer.append(packet)
+        if(packet.packetType == "PONG" and self.openPort != None):
+            self.openPorts.append(packet.srcPortNumber)
+        else:
+            self.openPort = None
+
+
 
     def updateTime(self):
         self.curTime += 1

Python/client.py

@@ -4,7 +4,7 @@
 
 
 class client:
-    def __init__(self, router_connection, client_IP, normal_Server_IP, reflector_ip, normal_traffic_rate, fileGen, packetSize, max_port_numb,queueLimit, bandwidthToRouter, packet_ID_prefix = "C-"):
+    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
@@ -81,29 +81,42 @@ def createResponses(self):
         i = 0
         while (i < len(self.receiveBuffer)): #iterate over the receive buffer
             curPacket = self.receiveBuffer[i]
-            if ( (curPacket.srcIP, curPacket.ackNumber) in self.expectedSYNACKs):
+            if(curPacket.packetType == "PING"):
                 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)
+                responsePacket = packet.packet(self.clientIP, curPacket.dstPortNumber, curPacket.srcIP, curPacket.srcPortNumber, "PONG", 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
-                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)
-                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
-            self.packetsInReceiveBuffer -= 1
-            self.fileGen.addToLog(curPacket.packetID, "Responded to by Client", curPacket.sequenceNumber, curPacket.ackNumber, curPacket.packetType, self.curTime)
+                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)
+            else:
+                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)
+                    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
+                    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)
+                    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
+                self.packetsInReceiveBuffer -= 1
+                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
     def createNormalTraffic(self):

Python/main.py

@@ -32,15 +32,15 @@ def runSimulation(dddState,skipsim, sumOut, logOut, packetSize, resendSynAckTime
     connectionAttackerMServer = connectionObject.connectionObject(attackertoReflector, PropDelay,None, "5.0.0.0", None, "3.0.0.0", fileGen, "A-R")
     connectionRouterAttacker = connectionObject.connectionObject(routertoReflector, PropDelay, None, "3.0.0.0", None, "5.0.0.0", fileGen, "R-A")
 
-    simClient = client.client(connectionClientRouter, "1.0.0.0", "4.0.0.0", "5.0.0.0", 2,  fileGen, packetSize, NumbDDDPortsOpen, queueLimit, clienttoRouter, "C-")
+    simClient = client.client(connectionClientRouter, "1.0.0.0", "4.0.0.0", "3.0.0.0", "5.0.0.0", 2,  fileGen, packetSize, NumbDDDPortsOpen, queueLimit, clienttoRouter, "C-")
     simDddController = dddController.dddController(timeUntilNextDDDChange, overlapTime, NumbDDDPortsOpen, fileGen)
-    simRouter = router.router(1000,dddState, "2.0.0.0", 0, DDDMappingDelay, connectionRouterClient, connectionRouterNServer, connectionRouterMServer,connectionRouterAttacker, simDddController, simDddController.dddPortMapper, fileGen, queueLimit, routertoClient, routertoNormal, routertoReflector, "R-")
+    simRouter = router.router(1000,dddState, "2.0.0.0", 0, DDDMappingDelay, connectionRouterClient, connectionRouterNServer, connectionRouterMServer,connectionRouterAttacker, simDddController, simDddController.dddPortMapper, fileGen, queueLimit, routertoClient, routertoNormal, routertoReflector,packetSize, "R-")
     simNServer = server.Server(connectionNServerRouter, "4.0.0.0", MaxQueueSize, resendSynAckTime, numbSynAckResends, fileGen, packetSize, queueLimit, normaltoRouter, "N-",)
     simMServer = server.Server(connectionMServerRouter, "3.0.0.0", MaxQueueSize, resendSynAckTime, numbSynAckResends, fileGen, packetSize, queueLimit, reflectortoRouter, "M-")
     if(amplification == 1):
-        simAttacker = attacker.attacker(connectionAttackerMServer,connectionAttackerRouter, "1.0.0.0", "4.0.0.0", fileGen, packetSize, attackertoReflector,simDddController, "5.0.0.0", "A-",attackerType, 1)
+        simAttacker = attacker.attacker(connectionAttackerMServer,connectionAttackerRouter, "1.0.0.0", "4.0.0.0", fileGen, packetSize, attackertoReflector, "5.0.0.0", "A-",attackerType, 1)
     else:
-        simAttacker = attacker.attacker(connectionAttackerMServer,connectionAttackerRouter, "1.0.0.0", "4.0.0.0", fileGen, packetSize, attackertoReflector,simDddController, "5.0.0.0", "A-", attackerType, 0)
+        simAttacker = attacker.attacker(connectionAttackerMServer,connectionAttackerRouter, "1.0.0.0", "4.0.0.0", fileGen, packetSize, attackertoReflector, "5.0.0.0", "A-", attackerType, 0)
 
     #self,connectionToServer, client_IP, server_IP, fileGen,  packetSize, bandwidthToMserver, ipAddress="", packet_ID_prefix = "A-"):
     connectionClientRouter.device1 = simClient
@@ -161,9 +161,11 @@ def runSimulation(dddState,skipsim, sumOut, logOut, packetSize, resendSynAckTime
             print(simRouter.queueClient)
             print(simRouter.queueNServer)
             print(simRouter.queueMServer)
+            print(simRouter.queueAttacker)
             print(simRouter.sendClient)
             print(simRouter.sendNServer)
             print(simRouter.sendMServer)
+            print(simRouter.sendAttacker)
             print("-----------------------------------------")
             print("N SERVER: Queue, Sending Packet")
             print(simNServer.queue)

Python/router.py

@@ -3,7 +3,7 @@
 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, attackerConnection, 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,packetSize, packet_ID_prefix = "R-"):
         self.queueSize = queueBufferSize #MB's
         self.clientConnection = clientConnection
         self.clientIP = "1.0.0.0"
@@ -62,6 +62,7 @@ def __init__(self, queueBufferSize, dddState, ipAddress, dddFilterDelay, dddMapp
         self.timeToNextIterationMServer = 1
         self.timeToNextIterationAttacker = 1
 
+        self.packetSize = packetSize
 
     #Receive packets coming from different connections. Add to receive buffer, drop if receive buffer is full.
     def receivePacket(self, synPacket):
@@ -115,24 +116,27 @@ def addToQueues(self):
                 self.receiveBuffer.remove(i)
 
 
-    def filterPackets(self, packet):
+    def filterPackets(self, packetT):
         allow = False
         for j in self.dddController.currentUsablePorts:
-            if(packet.dstPortNumber == j):
+            if(packetT.dstPortNumber == j):
                 allow = True
                 return True
         #Check if the packets dst port number is listed as a current usable port.
         if(allow == False and len(self.dddController.oldPorts) != 0):
             for j in self.dddController.oldPorts:
-                if(packet.dstPortNumber == j):
+                if(packetT.dstPortNumber == j):
                     allow = True
                     print("This packet got past the filter")
                     return True
 		#If the packets dst port number is not found in either list, then drop the packet
         if(allow == False):
+            if(packetT.packetType == "PING"):
+                npacket = packet.packet(self.ipAddress,packetT.dstPortNumber,packetT.srcIP, packetT.srcPortNumber, "RST", random.randint(0, 10000), 0, "R" ,self.packetSize, self.ipAddress)
+                self.queueAttacker.append(npacket)
             print("Packet dropped at the DDD Filter")
-            self.fileGen.animateDrop(self.packetIDPrefix[0], packet.packetType, packet.sequenceNumber, packet.ackNumber, packet.dstPortNumber)###dw
-            self.fileGen.addToLog(packet.packetID, "Dropped at DDD Filter", packet.sequenceNumber, packet.ackNumber, packet.packetType, self.curTime)
+            self.fileGen.animateDrop(self.packetIDPrefix[0], packetT.packetType, packetT.sequenceNumber, packetT.ackNumber, packetT.dstPortNumber)###dw
+            self.fileGen.addToLog(packetT.packetID, "Dropped at DDD Filter", packetT.sequenceNumber, packetT.ackNumber, packetT.packetType, self.curTime)
             self.packetsDropped += 1
             return False
 
@@ -312,6 +316,9 @@ def sendPackets(self):
                         self.sendClient = None
                     else:
                         print("Packet Dropped at the Port Mapper")
+                        if(self.sendClient[0].packetType == "PING"):
+                            npacket = packet.packet(self.ipAddress,self.sendClient[0].dstPortNumber,self.sendClient[0].srcIP, self.sendClient[0].srcPortNumber, "RST", random.randint(0, 10000), 0, "R" ,self.packetSize, self.ipAddress)
+                            self.queueAttacker.append(npacket)
                         self.fileGen.animateDrop(self.packetIDPrefix[0], self.sendClient[0].packetType, self.sendClient[0].sequenceNumber, self.sendClient[0].ackNumber, self.sendClient[0].dstPortNumber)
                         self.fileGen.addToLog(self.sendClient[0].packetID, "Dropped at Port Mapper", self.sendClient[0].sequenceNumber, self.sendClient[0].ackNumber, self.sendClient[0].packetType, self.curTime)
                         self.sendClient = None