def mitmdump(args=None): # pragma: no cover
from . import dump
check_pyopenssl_version()
parser = cmdline.mitmdump()
options = parser.parse_args(args)
if options.quiet:
options.verbose = 0
options.flow_detail = 0
proxy_config = process_proxy_options(parser, options)
dump_options = dump.Options(**cmdline.get_common_options(options))
dump_options.flow_detail = options.flow_detail
dump_options.keepserving = options.keepserving
dump_options.filtstr = " ".join(options.args) if options.args else None
server = get_server(dump_options.no_server, proxy_config)
try:
master = dump.DumpMaster(server, dump_options)
def cleankill(*args, **kwargs):
master.shutdown()
signal.signal(signal.SIGTERM, cleankill)
master.run()
except dump.DumpError as e:
print("mitmdump: %s" % e, file=sys.stderr)
sys.exit(1)
except (KeyboardInterrupt, _thread.error):
pass
def mitmweb(args=None): # pragma: nocover
from . import web
check_pyopenssl_version()
check_mitmproxy_version(version.IVERSION)
parser = cmdline.mitmweb()
options = parser.parse_args(args)
if options.quiet:
options.verbose = 0
proxy_config = process_proxy_options(parser, options)
web_options = web.Options(**cmdline.get_common_options(options))
web_options.intercept = options.intercept
web_options.wdebug = options.wdebug
web_options.wiface = options.wiface
web_options.wport = options.wport
server = get_server(web_options.no_server, proxy_config)
m = web.WebMaster(server, web_options)
try:
m.run()
except KeyboardInterrupt:
pass
def mitmweb(args=None): # pragma: nocover
from . import web
check_pyopenssl_version()
check_mitmproxy_version(version.IVERSION)
parser = cmdline.mitmweb()
options = parser.parse_args(args)
if options.quiet:
options.verbose = 0
proxy_config = process_proxy_options(parser, options)
web_options = web.Options(**cmdline.get_common_options(options))
web_options.intercept = options.intercept
web_options.wdebug = options.wdebug
web_options.wiface = options.wiface
web_options.wport = options.wport
server = get_server(web_options.no_server, proxy_config)
m = web.WebMaster(server, web_options)
try:
m.run()
except KeyboardInterrupt:
pass
def mitmproxy(args=None): # pragma: nocover
from . import console
check_pyopenssl_version()
check_mitmproxy_version(version.IVERSION)
assert_utf8_env()
parser = cmdline.mitmproxy()
options = parser.parse_args(args)
if options.quiet:
options.verbose = 0
proxy_config = process_proxy_options(parser, options)
console_options = console.Options(**cmdline.get_common_options(options))
console_options.palette = options.palette
console_options.palette_transparent = options.palette_transparent
console_options.eventlog = options.eventlog
console_options.intercept = options.intercept
console_options.limit = options.limit
console_options.no_mouse = options.no_mouse
server = get_server(console_options.no_server, proxy_config)
m = console.ConsoleMaster(server, console_options)
try:
m.run()
except KeyboardInterrupt:
pass
def mitmdump(args=None): # pragma: no cover
from . import dump
version_check.check_pyopenssl_version()
parser = cmdline.mitmdump()
args = parser.parse_args(args)
if args.quiet:
args.flow_detail = 0
master = None
try:
dump_options = dump.Options(**cmdline.get_common_options(args))
dump_options.flow_detail = args.flow_detail
dump_options.keepserving = args.keepserving
dump_options.filtstr = " ".join(args.args) if args.args else None
server = process_options(parser, dump_options, args)
master = dump.DumpMaster(server, dump_options)
def cleankill(*args, **kwargs):
master.shutdown()
signal.signal(signal.SIGTERM, cleankill)
master.run()
except (dump.DumpError, exceptions.OptionsError) as e:
print("mitmdump: %s" % e, file=sys.stderr)
sys.exit(1)
except (KeyboardInterrupt, RuntimeError):
pass
if master is None or master.has_errored:
print("mitmdump: errors occurred during run", file=sys.stderr)
sys.exit(1)
def mitmproxy(args=None): # pragma: no cover
if os.name == "nt":
print(
"Error: mitmproxy's console interface is not supported on Windows. "
"You can run mitmdump or mitmweb instead.",
file=sys.stderr)
sys.exit(1)
from . import console
version_check.check_pyopenssl_version()
assert_utf8_env()
parser = cmdline.mitmproxy()
args = parser.parse_args(args)
try:
console_options = console.master.Options(
**cmdline.get_common_options(args))
console_options.palette = args.palette
console_options.palette_transparent = args.palette_transparent
console_options.eventlog = args.eventlog
console_options.follow = args.follow
console_options.intercept = args.intercept
console_options.filter = args.filter
console_options.no_mouse = args.no_mouse
server = process_options(parser, console_options, args)
m = console.master.ConsoleMaster(server, console_options)
except exceptions.OptionsError as e:
print("mitmproxy: %s" % e, file=sys.stderr)
sys.exit(1)
try:
m.run()
except (KeyboardInterrupt, RuntimeError):
pass
def mitmweb(args=None): # pragma: no cover
from . import web
version_check.check_pyopenssl_version()
parser = cmdline.mitmweb()
args = parser.parse_args(args)
try:
web_options = web.master.Options(**cmdline.get_common_options(args))
web_options.intercept = args.intercept
web_options.wdebug = args.wdebug
web_options.wiface = args.wiface
web_options.wport = args.wport
web_options.wsingleuser = args.wsingleuser
web_options.whtpasswd = args.whtpasswd
web_options.process_web_options(parser)
server = process_options(parser, web_options, args)
m = web.master.WebMaster(server, web_options)
except exceptions.OptionsError as e:
print("mitmweb: %s" % e, file=sys.stderr)
sys.exit(1)
try:
m.run()
except (KeyboardInterrupt, RuntimeError):
pass
def mitmweb(args=None): # pragma: no cover
from . import web
check_pyopenssl_version()
parser = cmdline.mitmweb()
options = parser.parse_args(args)
if options.quiet:
options.verbose = 0
proxy_config = process_proxy_options(parser, options)
web_options = web.Options(**cmdline.get_common_options(options))
web_options.intercept = options.intercept
web_options.wdebug = options.wdebug
web_options.wiface = options.wiface
web_options.wport = options.wport
web_options.wsingleuser = options.wsingleuser
web_options.whtpasswd = options.whtpasswd
web_options.process_web_options(parser)
server = get_server(web_options.no_server, proxy_config)
m = web.WebMaster(server, web_options)
try:
m.run()
except (KeyboardInterrupt, _thread.error):
pass
def mitmproxy(args=None): # pragma: no cover
if os.name == "nt":
print("Error: mitmproxy's console interface is not supported on Windows. "
"You can run mitmdump or mitmweb instead.", file=sys.stderr)
sys.exit(1)
from . import console
check_pyopenssl_version()
check_mitmproxy_version(version.IVERSION)
assert_utf8_env()
parser = cmdline.mitmproxy()
options = parser.parse_args(args)
if options.quiet:
options.verbose = 0
proxy_config = process_proxy_options(parser, options)
console_options = console.Options(**cmdline.get_common_options(options))
console_options.palette = options.palette
console_options.palette_transparent = options.palette_transparent
console_options.eventlog = options.eventlog
console_options.follow = options.follow
console_options.intercept = options.intercept
console_options.limit = options.limit
console_options.no_mouse = options.no_mouse
server = get_server(console_options.no_server, proxy_config)
m = console.ConsoleMaster(server, console_options)
try:
m.run()
except (KeyboardInterrupt, thread.error):
pass
def mitmweb(args=None): # pragma: no cover
from . import web
version_check.check_pyopenssl_version()
parser = cmdline.mitmweb()
args = parser.parse_args(args)
try:
web_options = web.master.Options(**cmdline.get_common_options(args))
web_options.intercept = args.intercept
web_options.wdebug = args.wdebug
web_options.wiface = args.wiface
web_options.wport = args.wport
web_options.wsingleuser = args.wsingleuser
web_options.whtpasswd = args.whtpasswd
web_options.process_web_options(parser)
proxy_config = process_options(parser, web_options, args)
server = get_server(web_options.no_server, proxy_config)
m = web.master.WebMaster(server, web_options)
except exceptions.OptionsError as e:
print("mitmweb: %s" % e, file=sys.stderr)
sys.exit(1)
try:
m.run()
except (KeyboardInterrupt, _thread.error):
pass
def mitmdump(args=None): # pragma: nocover
from . import dump
check_pyopenssl_version()
check_mitmproxy_version(version.IVERSION)
parser = cmdline.mitmdump()
options = parser.parse_args(args)
if options.quiet:
options.verbose = 0
options.flow_detail = 0
proxy_config = process_proxy_options(parser, options)
dump_options = dump.Options(**cmdline.get_common_options(options))
dump_options.flow_detail = options.flow_detail
dump_options.keepserving = options.keepserving
dump_options.filtstr = " ".join(options.args) if options.args else None
server = get_server(dump_options.no_server, proxy_config)
try:
master = dump.DumpMaster(server, dump_options)
def cleankill(*args, **kwargs):
master.shutdown()
signal.signal(signal.SIGTERM, cleankill)
master.run()
except dump.DumpError as e:
print("mitmdump: %s" % e, file=sys.stderr)
sys.exit(1)
except KeyboardInterrupt:
pass
def mitmproxy(args=None): # pragma: no cover
if os.name == "nt":
print("Error: mitmproxy's console interface is not supported on Windows. "
"You can run mitmdump or mitmweb instead.", file=sys.stderr)
sys.exit(1)
from . import console
check_pyopenssl_version()
check_mitmproxy_version(version.IVERSION)
assert_utf8_env()
parser = cmdline.mitmproxy()
options = parser.parse_args(args)
if options.quiet:
options.verbose = 0
proxy_config = process_proxy_options(parser, options)
console_options = console.Options(**cmdline.get_common_options(options))
console_options.palette = options.palette
console_options.palette_transparent = options.palette_transparent
console_options.eventlog = options.eventlog
console_options.follow = options.follow
console_options.intercept = options.intercept
console_options.limit = options.limit
console_options.no_mouse = options.no_mouse
server = get_server(console_options.no_server, proxy_config)
m = console.ConsoleMaster(server, console_options)
try:
m.run()
except (KeyboardInterrupt, _thread.error):
pass
def mitmproxy(args=None): # pragma: nocover
from . import console
check_pyopenssl_version()
check_mitmproxy_version(version.IVERSION)
assert_utf8_env()
parser = cmdline.mitmproxy()
options = parser.parse_args(args)
if options.quiet:
options.verbose = 0
proxy_config = process_proxy_options(parser, options)
console_options = console.Options(**cmdline.get_common_options(options))
console_options.palette = options.palette
console_options.palette_transparent = options.palette_transparent
console_options.eventlog = options.eventlog
console_options.intercept = options.intercept
console_options.limit = options.limit
server = get_server(console_options.no_server, proxy_config)
m = console.ConsoleMaster(server, console_options)
try:
m.run()
except KeyboardInterrupt:
pass
def mitmdump(args=None): # pragma: no cover
from . import dump
version_check.check_pyopenssl_version()
parser = cmdline.mitmdump()
args = parser.parse_args(args)
if args.quiet:
args.flow_detail = 0
try:
dump_options = dump.Options(**cmdline.get_common_options(args))
dump_options.flow_detail = args.flow_detail
dump_options.keepserving = args.keepserving
dump_options.filtstr = " ".join(args.args) if args.args else None
proxy_config = process_options(parser, dump_options, args)
server = get_server(dump_options.no_server, proxy_config)
master = dump.DumpMaster(server, dump_options)
def cleankill(*args, **kwargs):
master.shutdown()
signal.signal(signal.SIGTERM, cleankill)
master.run()
except (dump.DumpError, exceptions.OptionsError) as e:
print("mitmdump: %s" % e, file=sys.stderr)
sys.exit(1)
except (KeyboardInterrupt, _thread.error):
pass
if master.has_errored:
print("mitmdump: errors occurred during run", file=sys.stderr)
sys.exit(1)
def mitmproxy(args=None): # pragma: no cover
if os.name == "nt":
print("Error: mitmproxy's console interface is not supported on Windows. "
"You can run mitmdump or mitmweb instead.", file=sys.stderr)
sys.exit(1)
from . import console
version_check.check_pyopenssl_version()
assert_utf8_env()
parser = cmdline.mitmproxy()
args = parser.parse_args(args)
try:
console_options = console.master.Options(
**cmdline.get_common_options(args)
)
console_options.palette = args.palette
console_options.palette_transparent = args.palette_transparent
console_options.eventlog = args.eventlog
console_options.follow = args.follow
console_options.intercept = args.intercept
console_options.limit = args.limit
console_options.no_mouse = args.no_mouse
proxy_config = process_options(parser, console_options, args)
server = get_server(console_options.no_server, proxy_config)
m = console.master.ConsoleMaster(server, console_options)
except exceptions.OptionsError as e:
print("mitmproxy: %s" % e, file=sys.stderr)
sys.exit(1)
try:
m.run()
except (KeyboardInterrupt, _thread.error):
pass
def mitmweb(args=None): # pragma: no cover
from . import web
version_check.check_pyopenssl_version()
parser = cmdline.mitmweb()
options = parser.parse_args(args)
if options.quiet:
options.verbose = 0
proxy_config = config.process_proxy_options(parser, options)
web_options = web.master.Options(**cmdline.get_common_options(options))
web_options.intercept = options.intercept
web_options.wdebug = options.wdebug
web_options.wiface = options.wiface
web_options.wport = options.wport
web_options.wsingleuser = options.wsingleuser
web_options.whtpasswd = options.whtpasswd
web_options.process_web_options(parser)
server = get_server(web_options.no_server, proxy_config)
m = web.master.WebMaster(server, web_options)
try:
m.run()
except (KeyboardInterrupt, _thread.error):
pass
def test_check_pyopenssl_version(sexit):
fp = cStringIO.StringIO()
version_check.check_pyopenssl_version(fp=fp)
assert not fp.getvalue()
assert not sexit.called
version_check.check_pyopenssl_version((9999, ), fp=fp)
assert "outdated" in fp.getvalue()
assert sexit.called
def test_check_pyopenssl_version(sexit):
fp = StringIO()
version_check.check_pyopenssl_version(fp=fp)
assert not fp.getvalue()
assert not sexit.called
version_check.check_pyopenssl_version((9999,), fp=fp)
assert "outdated" in fp.getvalue()
assert sexit.called
import certifi
from backports import ssl_match_hostname
import six
import OpenSSL
from OpenSSL import SSL
from netlib import certutils
from netlib import version_check
from netlib import basetypes
from netlib import exceptions
from netlib import basethread
# This is a rather hackish way to make sure that
# the latest version of pyOpenSSL is actually installed.
version_check.check_pyopenssl_version()
if six.PY2:
socket_fileobject = socket._fileobject
else:
socket_fileobject = socket.SocketIO
EINTR = 4
if os.environ.get("NO_ALPN"):
HAS_ALPN = False
else:
HAS_ALPN = SSL._lib.Cryptography_HAS_ALPN
# To enable all SSL methods use: SSLv23
# then add options to disable certain methods
# https://bugs.launchpad.net/pyopenssl/+bug/1020632/comments/3
def test_unparseable_pyopenssl_version(version, sexit):
version.split.return_value = ["foo", "bar"]
fp = cStringIO.StringIO()
version_check.check_pyopenssl_version(fp=fp)
assert "Cannot parse" in fp.getvalue()
assert not sexit.called
import certifi
from backports import ssl_match_hostname
import six
import OpenSSL
from OpenSSL import SSL
from netlib import certutils
from netlib import version_check
from netlib import basetypes
from netlib import exceptions
from netlib import basethread
# This is a rather hackish way to make sure that
# the latest version of pyOpenSSL is actually installed.
version_check.check_pyopenssl_version()
if six.PY2:
socket_fileobject = socket._fileobject
else:
socket_fileobject = socket.SocketIO
EINTR = 4
if os.environ.get("NO_ALPN"):
HAS_ALPN = False
else:
HAS_ALPN = SSL._lib.Cryptography_HAS_ALPN
# To enable all SSL methods use: SSLv23
# then add options to disable certain methods
# https://bugs.launchpad.net/pyopenssl/+bug/1020632/comments/3
def test_unparseable_pyopenssl_version(version, sexit):
version.split.return_value = ["foo", "bar"]
fp = StringIO()
version_check.check_pyopenssl_version(fp=fp)
assert "Cannot parse" in fp.getvalue()
assert not sexit.called
def run(self):
"""
start one proxy in background with specific port
:param port:
:param addon:
:return:
"""
args = ['-p', '%s' % self.port, '--stream', '100k']
print('proxy arguments: %s' % ' '.join(args))
def process_options(parser, options, args):
from mitmproxy.proxy import server
if args.sysinfo:
print(debug.sysinfo())
try:
debug.register_info_dumpers()
except Exception as e:
print(str(e))
pconf = config.ProxyConfig(options)
if options.no_server:
return server.DummyServer(pconf)
else:
try:
return server.ProxyServer(pconf)
except exceptions.ServerException as v:
print(str(v))
return
version_check.check_pyopenssl_version()
parser = cmdline.mitmdump()
args = parser.parse_args(args)
# if args.quiet:
args.flow_detail = 0
self.master = None
try:
dump_options = dump.Options(**cmdline.get_common_options(args))
dump_options.flow_detail = args.flow_detail
dump_options.keepserving = args.keepserving
dump_options.filtstr = " ".join(args.args) if args.args else None
server = process_options(parser, dump_options, args)
self.master = FileDumpMaster(server, dump_options)
for add_on in self.addon:
self.master.addons.add(add_on)
def cleankill(*args, **kwargs):
self.master.shutdown()
# signal.signal(signal.SIGTERM, cleankill)
global_config.PROXY = self.master
self.master.run()
except (dump.DumpError, exceptions.OptionsError) as e:
print("mitmdump: %s" % e)
return
# except (KeyboardInterrupt, _thread.error):
# pass
if self.master is None or self.master.has_errored:
print("mitmdump: errors occurred during run")
return
