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 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
class Proxy(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
opts = options.Options(listen_host='127.0.0.1', listen_port=8080)
opts.add_option("body_size_limit", int, 0, "")
pconf = proxy.config.ProxyConfig(opts)
self.m = DumpMaster(None, with_termlog=False, with_dumper=False)
self.m.server = proxy.server.ProxyServer(pconf)
if self.m.server.channel.loop.is_closed():
self.m.server.channel.loop = asyncio.new_event_loop()
self.m.addons.add(Github_Proxy())
self.m.addons.add(wsgiapp.WSGIApp(app, "gitty.local", 443))
def run(self):
try:
asyncio.set_event_loop(self.m.server.channel.loop)
self.m.run()
except Exception as e:
print(e)
def stop_proxy(self):
try:
self.m.shutdown()
except Exception as e:
print(e)
class ProxyWrapper(threading.Thread):
"""Runs an mitmproxy in a separate thread."""
def __init__(self, host: str, port: int, **kwargs: typing.Any) -> None:
self.host = host
self.port = port
self.options = kwargs
super().__init__()
self.notify = RunNotify()
def run(self) -> None:
# mitmproxy uses asyncio internally but the default loop policy
# will only create event loops for the main thread, create one
# as part of the thread startup
asyncio.set_event_loop(asyncio.new_event_loop())
opts = options.Options(listen_host=self.host,
listen_port=self.port,
**self.options)
pconf = proxy.config.ProxyConfig(opts)
self.master = DumpMaster(opts)
self.master.server = proxy.server.ProxyServer(pconf)
self.master.addons.add(self.notify)
self.master.run()
def join(self, timeout: float = None) -> None:
self.master.shutdown()
super().join()
def run(self):
try:
self.logger.info("Starting Proxy. Press Ctrl+C to Stop")
DumpMaster.run(self)
except KeyboardInterrupt:
self.logger.info("Stopping Proxy Server")
self.shutdown()
def runProxyServerOnce(codeRewriter, pathTracer, networkErrorTracer,
resultQueue):
from mitmproxy import proxy, options
from mitmproxy.tools.dump import DumpMaster
import mitmproxy.exceptions
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
# We have a retry mechanism here because it may take multiple attempts to get a free port
while True:
try:
port = ProxyProcess.findFreePort()
opts = options.Options(listen_port=port,
http2=False,
ssl_insecure=True)
pconf = proxy.config.ProxyConfig(opts)
m = DumpMaster(opts, with_termlog=False, with_dumper=False)
m.server = proxy.server.ProxyServer(pconf)
m.addons.add(codeRewriter)
m.addons.add(pathTracer)
m.addons.add(networkErrorTracer)
break
except mitmproxy.exceptions.ServerException:
getLogger().warning(
f"Had to restart the mitmproxy due to an exception: {traceback.format_exc()}"
)
resultQueue.put(port)
m.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
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()
class minecraftProxy(QThread):
def __init__(self, doSkinFix, doSoundFix, doCapeFix, loop):
super().__init__()
self.doSkinFix = doSkinFix
self.doCapeFix = doCapeFix
self.doSoundFix = doSoundFix
self.loop = loop
def getHeader(self):
class AddHeader:
def __init__(self, parent):
self.parent = parent
def request(self, flow):
if flow.request.pretty_host == "s3.amazonaws.com" or flow.request.pretty_host == "skins.minecraft.net" or flow.request.pretty_host == "www.minecraft.net":
if self.parent.doSoundFix:
if flow.request.path.__contains__("MinecraftResources") or flow.request.path.__contains__("/resources/"):
flow.request.host = "resourceproxy.pymcl.net"
flow.request.path = "/MinecraftResources/"
if self.parent.doSkinFix:
if flow.request.path.__contains__("MinecraftSkins"):
flow.request.host = "resourceproxy.pymcl.net"
flow.request.path = "/skinapi.php?user="******"/")[2].split(".")[0]
if self.parent.doCapeFix:
if flow.request.path.__contains__("MinecraftCloaks"):
flow.request.host = "resourceproxy.pymcl.net"
flow.request.path = "/capeapi.php?user="******"/")[2].split(".")[0]
if flow.request.pretty_host.__contains__("minecraft.net"):
if self.parent.doSkinFix:
if flow.request.path.__contains__("skin"):
flow.request.host = "resourceproxy.pymcl.net"
flow.request.path = "/skinapi.php?user="******"/")[2].split(".")[0]
if self.parent.doCapeFix:
if flow.request.path.__contains__("cloak"):
flow.request.host = "resourceproxy.pymcl.net"
flow.request.path = "/capeapi.php?user="******"=")[1]
return AddHeader(self)
def run(self):
asyncio.set_event_loop(self.loop)
myaddon = self.getHeader()
opts = options.Options(listen_host="0.0.0.0", listen_port=25560)
pconf = proxy.config.ProxyConfig(opts)
self.m = DumpMaster(opts)
self.m.server = proxy.server.ProxyServer(pconf)
self.m.addons.add(myaddon)
self.m.run()
def stop(self):
self.m.shutdown()
def run(self):
asyncio.set_event_loop(self.loop)
myaddon = self.getHeader()
opts = options.Options(listen_host="0.0.0.0", listen_port=25560)
pconf = proxy.config.ProxyConfig(opts)
self.m = DumpMaster(opts)
self.m.server = proxy.server.ProxyServer(pconf)
self.m.addons.add(myaddon)
self.m.run()
def create_proxy() -> Tuple[DumpMaster, CaptureAddon]:
# set default proxy options
opts = options.Options(listen_host="0.0.0.0", listen_port=8080)
config = proxy.config.ProxyConfig(opts)
# create addon
addon = CaptureAddon()
# create proxy
m = DumpMaster(opts, with_termlog=False, with_dumper=False)
m.server = proxy.server.ProxyServer(config)
m.addons.add(addon)
return m, addon
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 runProxy(port):
from mitmproxy import proxy, options
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
opts = options.Options(listen_port=port)
pconf = proxy.config.ProxyConfig(opts)
m = DumpMaster(opts, with_termlog=False, with_dumper=False)
m.server = proxy.server.ProxyServer(pconf)
m.run()
def _wrapper(url_list):
asyncio.set_event_loop(asyncio.new_event_loop())
opts = options.Options(listen_host=PROXY_HOST,
listen_port=PROXY_PORT)
opts.add_option('body_size_limit', int, 0, '')
pconf = proxy.config.ProxyConfig(opts)
dump_master = DumpMaster(None,
with_termlog=False,
with_dumper=False)
dump_master.server = proxy.server.ProxyServer(pconf)
dump_master.addons.add(_InjectScripts(url_list))
dump_master.run()
def run(self) -> None:
# mitmproxy uses asyncio internally but the default loop policy
# will only create event loops for the main thread, create one
# as part of the thread startup
asyncio.set_event_loop(asyncio.new_event_loop())
opts = options.Options(listen_host=self.host,
listen_port=self.port,
**self.options)
pconf = proxy.config.ProxyConfig(opts)
self.master = DumpMaster(opts)
self.master.server = proxy.server.ProxyServer(pconf)
self.master.addons.add(self.notify)
self.master.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 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(self):
opts = options.Options(listen_host='0.0.0.0', listen_port=8080)
pconf = proxy.config.ProxyConfig(opts)
self.mitmweb = DumpMaster(opts)
self.mitmweb.server = proxy.server.ProxyServer(pconf)
self.mitmweb.addons.add(addon)
self.mitmweb.addons.add(tls_passthrough1)
loop = asyncio.get_event_loop()
self.thread = threading.Thread(target=self.loop_in_thread,
args=(loop, self.mitmweb))
try:
self.thread.start()
except KeyboardInterrupt:
self.mitmweb.shutdown()
def run(self):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(
loop
)
p_conf = proxy.config.ProxyConfig(
self._options
)
self._master = (
DumpMaster(None)
)
self._master.server = (
proxy.server.ProxyServer(p_conf)
)
self._master.addons.get('core').load(
self._options
)
for addon in self._addons:
self._master.addons.add(
addon
)
self._master.run(loop)
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 runSolitude(solitudeProcess):
# This is to prevent connection errors as the it seems like the web app tries to connect to the db before it's been created
time.sleep(30)
# We do this import here because it loads the db on import before the settings from the command line arg can be configured
from solitude import Solitude
solitudeAddon = Solitude()
if os.getenv("DB_HOSTNAME") == 'database':
opts = options.Options(listen_host='0.0.0.0',
listen_port=8080,
mode='transparent')
else:
opts = options.Options(listen_host='0.0.0.0',
listen_port=8080,
ignore_hosts=['safebrowsing.googleapis.com'])
pconf = proxy.config.ProxyConfig(opts)
m = DumpMaster(opts)
m.server = proxy.server.ProxyServer(pconf)
m.addons.add(solitudeAddon)
try:
m.run()
except KeyboardInterrupt:
solitudeProcess.kill()
m.shutdown()
def start():
lock = Lock()
q = queue.Queue()
addon = Addon(q, lock)
window = Window(q, lock, addon)
opts = options.Options(listen_host='0.0.0.0', listen_port=8080)
pconf = proxy.config.ProxyConfig(opts)
master = DumpMaster(opts)
master.server = proxy.server.ProxyServer(pconf)
master.addons.add(addon)
mitm_thread = Thread(target=start_mitm, args=(master,))
mitm_thread.daemon = True
mitm_thread.start()
window.run()
def __init__(self, host, port, addons):
self.options = Options(listen_host=str(host),
listen_port=int(port),
http2=True)
self.mitm = DumpMaster(self.options,
with_termlog=False,
with_dumper=False)
self.addons = addons
self.config_server()
def run_input_loop(m: DumpMaster, addon: CaptureAddon):
while True:
print(
"Select an option:\n"
"1. Start new site session\n"
"2. Finish capture and quit"
)
option = None
while option not in [1, 2]:
try:
option = int(input("> "))
except:
pass
if option == 1:
label = input("Enter label for session:\n> ")
addon.label = label
elif option == 2:
m.shutdown()
with open(f"dump-{time.strftime('%Y%m%d-%H.%M.%S')}.json", "w") as file:
json.dump(addon.captures, file)
break
def start():
myaddon = Joker()
opts = options.Options(listen_port=8080)
pconf = proxy.config.ProxyConfig(opts)
m = DumpMaster(opts)
m.server = proxy.server.ProxyServer(pconf)
m.addons.add(myaddon)
try:
m.run()
except KeyboardInterrupt:
m.shutdown()
def start():
myaddon = AddHeader()
opts = options.Options(listen_host='127.0.0.1', listen_port=8888)
pconf = proxy.config.ProxyConfig(opts)
m = DumpMaster(opts)
m.server = proxy.server.ProxyServer(pconf)
m.addons.add(myaddon)
try:
m.run()
except KeyboardInterrupt:
m.shutdown()
def l11ll_wcplus_():
l1ll1llll11_wcplus_ = l1lll111l1l_wcplus_()
opts = options.Options(listen_host='0.0.0.0', listen_port=8080)
l1ll1lll1ll_wcplus_ = proxy.config.ProxyConfig(opts)
m = DumpMaster(opts)
m.server = proxy.server.ProxyServer(l1ll1lll1ll_wcplus_)
m.addons.add(l1ll1llll11_wcplus_)
try:
m.run()
except KeyboardInterrupt:
print('')
m.shutdown()
def proxyMaster():
flow_instance = ParseFlow()
opts = options.Options(listen_host='0.0.0.0', listen_port=8080)
proxy_config = proxy.config.ProxyConfig(opts)
m = DumpMaster(opts)
m.server = proxy.server.ProxyServer(proxy_config)
m.addons.add(flow_instance)
try:
m.run()
except KeyboardInterrupt:
print('')
m.shutdown()
def startDumpMaster(self,
bind="0.0.0.0",
port=8866,
mitmproxyId=str(uuid.uuid4()),
callbackServerAddr=None,
callbackServerPort=None,
upstream=None,
upstreamAuth=None):
print("start........", bind, port)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
opts = options.Options(listen_host=bind, listen_port=port)
#upstream = "http://http-dyn.abuyun.com:9020"
#upstreamAuth = "H88QO221HIVO10MD:62769571795BDB48"
if upstream:
opts.add_option("mode", str, "upstream:" + upstream, "") #设置上游代理
print("set upstream", upstream)
opts.add_option("ssl_insecure", bool, True, "") #不验证上游代理证书
pconf = proxy.config.ProxyConfig(opts)
mDumpMaster = DumpMaster(opts)
mDumpMaster.server = proxy.server.ProxyServer(pconf)
try:
self.locker.acquire()
self.mitmproxies[mitmproxyId] = mDumpMaster
print("save mitmproxies", mitmproxyId)
finally:
self.locker.release()
if upstream and upstreamAuth: #坑啊
upstreamAuthAddon: upstream_auth.UpstreamAuth = mDumpMaster.addons.get(
"upstreamauth")
upstreamAuthAddon.auth = upstream_auth.parse_upstream_auth(
upstreamAuth)
print("set upstreamAuth", upstreamAuthAddon.auth)
mDumpMaster.addons.add(
MitmproxyFlower(callbackServerAddr, callbackServerPort,
mitmproxyId))
mDumpMaster.run() #is blocking
print("finished mitmproxy", mitmproxyId)
def start_proxy():
self_addon = SelfAddon()
opts = options.Options(listen_host='0.0.0.0', listen_port=8080)
pconf = proxy.config.ProxyConfig(opts)
m = DumpMaster(opts)
m.server = proxy.server.ProxyServer(pconf)
m.addons.add(self_addon)
try:
m.run()
except KeyboardInterrupt:
print('')
m.shutdown()
def start(url, output):
webcopy = WebCopy(url, output)
opts = options.Options()
pconf = proxy.config.ProxyConfig(opts)
m = DumpMaster(opts)
m.server = proxy.server.ProxyServer(pconf)
m.addons.add(webcopy)
try:
m.run()
except KeyboardInterrupt:
m.shutdown()
