def start(self):
config = proxy.ProxyConfig(port=8080, mode='transparent')
print "[*] Pumpkin-Proxy running on port:8080 \n"
server = ProxyServer(config)
server.allow_reuse_address = True
self.m = MasterHandler(server, self.session)
self.m.run(self.send)
def start(self):
print "[*] Pumpkin-Proxy running on port:8080 \n"
opts = options.Options(listen_port=8080,mode="transparent")
config = proxy.ProxyConfig(opts)
state = flow.State()
server = ProxyServer(config)
server.allow_reuse_address = True
self.m = MasterHandler(opts,server,state,self.session)
self.m.run(self.send)
def start(self):
print "[*] Pumpkin-Proxy running on port:8080 \n"
opts = options.Options(listen_port=8080, mode="transparent")
config = proxy.ProxyConfig(opts)
state = flow.State()
server = ProxyServer(config)
server.allow_reuse_address = True
self.m = MasterHandler(opts, server, state, self.session)
self.m.run(self.send)
def start_server(proxy_port, proxy_mode):
LOGO = r'''
____ _ ____ ____ ___ __ __ __ __
| __ )| |_ _ ___ | _ \ | _ \ / _ \ \ \/ / \ \ / /
| _ \| | | | |/ _ \ | |_) | | |_) | | | | | \ / \ V /
| |_) | | |_| | __/ | __/ | _ < | |_| | / \ | |
|____/|_|\__,_|\___| |_| |_| \_\ \___/ /_/\_\ |_|
'''
cprint(LOGO, 'cyan')
cprint('[+] Starting Proxy On 0.0.0.0:{0}'.format(proxy_port), 'cyan')
cprint('[+] Starting Proxy Mode: {0}'.format(proxy_mode), 'cyan')
port = int(proxy_port)
if proxy_mode == 'http':
mode = 'regular'
else:
mode = proxy_mode
opts = options.Options(
listen_port=port,
mode=mode,
cadir="./ssl/",
ssl_insecure=True,
)
config = proxy.ProxyConfig(opts)
server = ProxyServer(config)
state = flow.State()
m = BlueProxy(opts, server, state)
m.run()
def start_proxy():
opts = options.Options(listen_host=PROXY_LISTEN_HOST,
listen_port=PROXY_LISTEN_PORT,
confdir=os.path.join(BASE_DIR, "ssl"),
ssl_insecure=True)
opts.add_option("body_size_limit", int, 0, "")
pconf = ProxyConfig(opts)
#There is no current event loop in thread 'Thread-1'错误
#解决方法：到mitmproxy的master.py修改Master类的init函数，
# loop = asyncio.new_event_loop()
# asyncio.set_event_loop(loop)
# self.should_exit = threading.Event()
# self.channel = controller.Channel(
# self,
# loop,
# self.should_exit,
# )
try:
m = DumpMaster(opts, with_termlog=False, with_dumper=False)
m.server = ProxyServer(pconf)
m.addons.add(Capture())
print("监听地址：{}，监听端口：{}".format(PROXY_LISTEN_HOST, PROXY_LISTEN_PORT))
m.run()
except:
pass
def _run_proxy(event, namespace, service, listen_host, listen_port, verbose):
# Run mitmproxy as a reverse-proxy to the Kubernetes ApiServer under the
# subpath /api/v1/namespaces/{namespace}/services/{service}/proxy. See
# https://k8s.io/docs/tasks/administer-cluster/access-cluster-services.
client = kubernetes.config.new_client_from_config()
prefix = f"/api/v1/namespaces/{namespace}/services/{service}/proxy"
options = Options(listen_host=listen_host,
listen_port=listen_port,
mode=f"reverse:{client.configuration.host}")
master = DumpMaster(options, with_termlog=verbose, with_dumper=verbose)
options.keep_host_header = True
options.ssl_insecure = True
with NamedTemporaryFile() as cert_file:
# If Kubernetes client has a client-certificate set up, then configure
# mitmproxy to use it. Kubernetes stores the cert and key in separate
# files, while mitmproxy expects a single file. So append the two file
# contents into a new file and pass it to mitmproxy.
if client.configuration.cert_file and client.configuration.key_file:
with open(client.configuration.cert_file, "rb") as f:
cert_file.write(f.read())
with open(client.configuration.key_file, "rb") as f:
cert_file.write(f.read())
cert_file.flush()
options.client_certs = cert_file.name
master.server = ProxyServer(ProxyConfig(options))
master.addons.add(_Addon(client, prefix))
event.set() # Port is bound by this time, unblock parent process.
master.run()
def start_cachebrowser_server(context):
logger.debug("Initializing IPC")
ipc = IPCManager(context)
ipc.register_rpc_handlers(api_routes)
context.ipc = ipc
config = ProxyConfig(context)
server = ProxyServer(config)
m = ProxyController(server, ipc)
# logger.debug("Adding WebsiteFilter Pipe")
# m.add_pipe(WebsiteFilterPipe(context))
logger.debug("Adding 'Resolver' pipe")
m.add_pipe(ResolverPipe(context))
logger.debug("Adding Scrambler Pipe")
m.add_pipe(ScramblerPipe(context))
logger.debug("Adding 'SNI' pipe")
m.add_pipe(SNIPipe(context))
logger.debug("Adding 'Publisher' pipe")
m.add_pipe(PublisherPipe(context))
try:
logger.info("Listening for proxy connections on port {}".format(
context.settings.port))
return m.run()
except KeyboardInterrupt:
m.shutdown()
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(options=moptions.Options(app_port=8080, app_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 capture():
from mitmproxy.options import Options
from mitmproxy.proxy.config import ProxyConfig
from mitmproxy.proxy.server import ProxyServer
from mitmproxy.tools.dump import DumpMaster
import asyncio
import signal
try:
options = Options(listen_host="0.0.0.0", listen_port=8889, http2=True)
config = ProxyConfig(options)
global m
m = DumpMaster(options, with_termlog=False, with_dumper=False)
m.server = ProxyServer(config)
m.addons.add(Addon())
loop = asyncio.get_event_loop()
try:
loop.add_signal_handler(signal.SIGINT,
getattr(m, "prompt_for_exit", m.shutdown))
loop.add_signal_handler(signal.SIGTERM, m.shutdown)
except NotImplementedError:
pass
async def wakeup():
while True:
await asyncio.sleep(0.2)
asyncio.ensure_future(wakeup())
m.run()
except KeyboardInterrupt:
pressAnyKeyExitWithDisableProxy()
except TypeError:
pass
except Exception as e:
print("抓包模块出错:", e)
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 __init__(self, config):
config.port = 0
s = ProxyServer(config)
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 __init__(self, server, tasks, results, args):
super(ClickProxy, self).__init__()
self.tasks = tasks
self.results = results
self.server = server
proxy_server = ProxyServer(ProxyConfig(port=int(args['port'])))
self.cproxy = MasterOfProxy(proxy_server, Queue(), args)
def __init__(self, opts, config):
s = ProxyServer(config)
state = flow.State()
flow.FlowMaster.__init__(self, opts, s, state)
self.addons.add(*builtins.default_addons())
self.apps.add(testapp, "testapp", 80)
self.apps.add(errapp, "errapp", 80)
self.clear_log()
def __init__(self, option, obj):
self.opts = options.Options()
for i in option:
self.__addOption(i)
self.cf = config.ProxyConfig(self.opts)
self.server = ProxyServer(config=self.cf)
self.master = Master(opts=self.opts)
self.master.server = self.server
self.master.addons.add(obj)
def __init__(self, options):
self.logger = logger
self.logger.info("Initializing MalwareProxyX")
self.pre_run_checks()
self.proxy_options = self.generate_proxy_options(options)
self.master = ProxyMaster(self.proxy_options,
with_termlog=False,
with_dumper=False)
self.master.server = ProxyServer(ProxyConfig(self.proxy_options))
self.master.addons.add(TrafficHandler(options))
self.master.run()
def __init__(self, host, port, options):
self.options = options
# Used to stored captured requests
self.storage = RequestStorage(
base_dir=options.pop('request_storage_base_dir', None))
# Used to modify requests/responses passing through the server
# Deprecated. Will be superceded by request/response interceptors.
self.modifier = RequestModifier()
# The scope of requests we're interested in capturing.
self.scopes = []
self.request_interceptor = None
self.response_interceptor = None
try:
self._event_loop = asyncio.get_event_loop()
if self._event_loop.is_closed():
# The event loop may be closed if the server had previously
# been shutdown and then spun up again
self._event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self._event_loop)
except:
self._event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self._event_loop)
# mitmproxy specific options
mitmproxy_opts = Options(
listen_host=host,
listen_port=port,
)
# Create an instance of the mitmproxy server
self._master = Master(mitmproxy_opts)
self._master.server = ProxyServer(ProxyConfig(mitmproxy_opts))
self._master.addons.add(*addons.default_addons())
self._master.addons.add(SendToLogger())
self._master.addons.add(MitmProxyRequestHandler(self))
# Update the options now all addons have been added
mitmproxy_opts.update(
confdir=DEFAULT_CONFDIR,
ssl_insecure=options.get('verify_ssl', True),
upstream_cert=DEFAULT_UPSTREAM_CERT,
stream_websockets=DEFAULT_STREAM_WEBSOCKETS,
**self._get_upstream_proxy_args(),
)
# Options that are prefixed mitm_ are passed through to mitmproxy
mitmproxy_opts.update(
**{k[5:]: v
for k, v in options.items() if k.startswith('mitm_')})
def shutdown_proxy():
opts = options.Options(listen_host=PROXY_LISTEN_HOST,
listen_port=PROXY_LISTEN_PORT,
confdir=BASE_DIR + "/ssl/",
ssl_insecure=True)
opts.add_option("body_size_limit", int, 0, "")
pconf = ProxyConfig(opts)
m = DumpMaster(opts, with_termlog=False, with_dumper=False)
m.server = ProxyServer(pconf)
m.addons.add(Capture())
m.shutdown()
def shutdown_proxy():
opts = options.Options(
listen_host=PROXY_LISTEN_HOST,
listen_port=PROXY_LISTEN_PORT,
mode=PROXY_LISTEN_MODE,
cadir=PROXY_CACER_DIR,
)
config = proxy.ProxyConfig(opts)
server = ProxyServer(config)
m = master.Master(opts, server)
m.shutdown()
def start():
arguments = docopt(__doc__, version='dev')
if arguments['--filter'] not in ('NONE', 'LOW', 'HIGH'):
print "--filter should set to (NONE|LOW|HIGH)"
print __doc__
exit()
config = proxy.ProxyConfig(port=PORT)
server = ProxyServer(config)
flow_filter = FlowFilter(arguments['--filter'], arguments['-p'], arguments['-d'], arguments['--blacklist'])
flow_handler = FlowHandler(arguments['-u'], arguments['--debug'])
m = Master(server, flow_filter, flow_handler)
m.run()
def _run(port, outfile, mode, cadir):
opts = options.Options(listen_port=port, mode=mode, cadir=cadir)
config = proxy.ProxyConfig(opts)
server = ProxyServer(config)
m = dump.DumpMaster(server, dump.Options(outfile=[outfile,'wb'], verbosity=0))
# Define a handler for the shutdown signal so the parent process knows how to stop me
def cleankill(*args, **kwargs):
m.shutdown()
signal.signal(signal.SIGTERM, cleankill)
# Now start the server. This operation will block.
m.run()
def main():
option = options.Options(listen_host='0.0.0.0', listen_port=18088, http2=True, mode="regular") #代理地址
m = DumpMaster(option, with_termlog=False, with_dumper=False)
config = ProxyConfig(option)
m.server = ProxyServer(config)
m.addons.add(Addon())
loop = asyncio.get_event_loop()
t = threading.Thread(target=loop_in_thread, args=(loop,m) )
try:
t.start()
except:
m.shutdown()
sys.exit(0)
def capture(request):
port = request.GET.get('port', 8888) #
mode = request.GET.get('mode', 'regular') #mode=regular
opts = options.Options(
listen_port=int(port),
mode=mode,
cadir="./ssl/",
)
unsave_data = False
config = proxy.ProxyConfig(opts)
state = flow.State()
server = ProxyServer(config)
m = WSProxy(opts, server, state, unsave_data)
m.run()
def start_mitm(self):
asyncio.set_event_loop(asyncio.new_event_loop())
print('[*] Starting mitmproxy on 127.0.0.1:8080')
options = Options(listen_host='127.0.0.1', listen_port=8080, http2=True)
m = DumpMaster(options, with_termlog=False, with_dumper=False)
config = ProxyConfig(options)
m.server = ProxyServer(config)
addon = MitmAddon(self.ext_id)
m.addons.add(addon)
# run mitmproxy in backgroud
loop = asyncio.get_event_loop()
t = threading.Thread( target=loop_in_thread, args=(loop,m) )
t.start()
return m
def start_proxy(self, port, mode, flow_file_name):
"""
Start Proxy
Capture / Intercept
"""
self.mitm_proxy_opts.keepserving = True
self.mitm_proxy_opts.listen_port = port
self.mitm_proxy_opts.cadir = settings.CA_DIR
if settings.UPSTREAM_PROXY:
self.mitm_proxy_opts.mode = settings.UPSTREAM_PROXY_CONF
self.mitm_proxy_opts.ssl_insecure = settings.UPSTREAM_PROXY_SSL_INSECURE
self.app_server = ProxyHandler(self.mitm_proxy_opts, mode,
flow_file_name)
self.app_server.server = ProxyServer(ProxyConfig(self.mitm_proxy_opts))
self.app_server.run()
def _run_proxy(event, namespace, service, listen_host, listen_port, verbose):
# Run mitmproxy as a reverse-proxy to the Kubernetes ApiServer under the
# subpath /api/v1/namespaces/{namespace}/services/{service}/proxy. See
# https://k8s.io/docs/tasks/administer-cluster/access-cluster-services.
client = kubernetes.config.new_client_from_config()
prefix = f"/api/v1/namespaces/{namespace}/services/{service}/proxy"
options = Options(listen_host=listen_host,
listen_port=listen_port,
mode=f"reverse:{client.configuration.host}")
master = DumpMaster(options, with_termlog=verbose, with_dumper=verbose)
options.keep_host_header = True
options.ssl_insecure = True
master.server = ProxyServer(ProxyConfig(options))
master.addons.add(_Addon(client, prefix))
event.set() # Port is bound by this time, unblock parent process.
master.run()
def start_proxy():
opts = options.Options(
listen_host=PROXY_LISTEN_HOST,
listen_port=PROXY_LISTEN_PORT,
mode=PROXY_LISTEN_MODE,
cadir=BASE_DIR+"/ssl/",
)
config = proxy.ProxyConfig(opts)
try:
server = ProxyServer(config)
m = ProxyMaster(opts, server)
m.run()
except:
pass
def start_server(proxy_port, proxy_mode):
port = int(proxy_port) if proxy_port else 8090
mode = proxy_mode if proxy_mode else 'regular'
if proxy_mode == 'http':
mode = 'regular'
opts = options.Options(
listen_port=port,
mode=mode,
cadir="~/.mitmproxy/",
)
config = proxy.ProxyConfig(opts)
state = flow.State()
server = ProxyServer(config)
m = ProxyClass(opts, server, state)
m.run()
def start_server(proxy_port, proxy_mode, unsave_data):
port = int(proxy_port) if proxy_port else 8080
mode = proxy_mode if proxy_mode else 'regular'
if proxy_mode == 'http':
mode = 'regular'
config = proxy.ProxyConfig(
port=port,
mode=mode,
cadir="./ssl/",
)
state = flow.State()
server = ProxyServer(config)
m = WYProxy(server, state, unsave_data)
m.run()
def start_server(proxy_port, proxy_mode, unsave_data):
port = int(proxy_port) if proxy_port else 8080
mode = proxy_mode if proxy_mode else 'regular'
if proxy_mode == 'http':
mode = 'regular'
opts = options.Options(
listen_port=port,
mode=mode,
# cadir="./ssl/",
)
config = proxy.ProxyConfig(opts)
state = flow.State()
server = ProxyServer(config)
m = WYProxy(opts, server, state, unsave_data)
m.run()
def _prepare_handler(self):
proxy_opts = options.Options(
clientcerts=self.client_cert,
certs=self.certs,
#listen_host=self.listen_host,
listen_port=self.listen_port,
mode='transparent',
)
proxy_config = proxy.ProxyConfig(proxy_opts)
proxy_server = ProxyServer(proxy_config)
self.master_handler = EvilInTheMiddleHandler(proxy_opts, proxy_server)
# Initialize plugins. Same method as in WiFi-Pumpkin
for plugin in MITMPlugin.__subclasses__():
plugin_instance = plugin()
if plugin_instance.name in self.plugins:
self.master_handler.plugins.append(plugin_instance)
plugin_instance.setup()
print "[+] Successfully loaded '{}' plugin.".format(plugin_instance.name)
def start_server(proxy_port, proxy_mode):
port = int(proxy_port) if proxy_port else 8080
mode = proxy_mode if proxy_mode else 'regular'
if proxy_mode == 'http':
mode = 'regular'
opts = options.Options(
listen_port=port,
mode=mode,
cadir="/data/MingDao/ssl/",
)
config = proxy.ProxyConfig(opts)
state = flow.State()
server = ProxyServer(config)
m = mingdaoproxy(opts, server, state)
m.run()