diff options
Diffstat (limited to 'libmproxy')
| -rw-r--r-- | libmproxy/dump.py | 7 | ||||
| -rw-r--r-- | libmproxy/main.py | 165 | ||||
| -rw-r--r-- | libmproxy/protocol/http.py | 4 | ||||
| -rw-r--r-- | libmproxy/proxy/__init__.py | 2 | ||||
| -rw-r--r-- | libmproxy/proxy/config.py | 11 | ||||
| -rw-r--r-- | libmproxy/proxy/server.py | 13 |
6 files changed, 186 insertions, 16 deletions
diff --git a/libmproxy/dump.py b/libmproxy/dump.py index 72ab58a3..648a76ba 100644 --- a/libmproxy/dump.py +++ b/libmproxy/dump.py @@ -16,6 +16,7 @@ class Options(object): "anticache", "anticomp", "client_replay", + "filtstr", "flow_detail", "keepserving", "kill", @@ -62,7 +63,7 @@ def str_request(f, showhost): class DumpMaster(flow.FlowMaster): - def __init__(self, server, options, filtstr, outfile=sys.stdout): + def __init__(self, server, options, outfile=sys.stdout): flow.FlowMaster.__init__(self, server, flow.State()) self.outfile = outfile self.o = options @@ -73,8 +74,8 @@ class DumpMaster(flow.FlowMaster): self.set_stream_large_bodies(options.stream_large_bodies) - if filtstr: - self.filt = filt.parse(filtstr) + if options.filtstr: + self.filt = filt.parse(options.filtstr) else: self.filt = None diff --git a/libmproxy/main.py b/libmproxy/main.py new file mode 100644 index 00000000..e343bd75 --- /dev/null +++ b/libmproxy/main.py @@ -0,0 +1,165 @@ +from __future__ import print_function, absolute_import +import argparse +import os +import signal +import sys +import netlib.version +from . import version, cmdline +from .proxy import process_proxy_options, ProxyServerError +from .proxy.server import DummyServer, ProxyServer + + +def check_versions(): + """ + Having installed a wrong version of pyOpenSSL or netlib is unfortunately a very common source of error. + Check before every start that both versions are somewhat okay. + """ + # We don't introduce backward-incompatible changes in patch versions. Only consider major and minor version. + if netlib.version.IVERSION[:2] != version.IVERSION[:2]: + print( + "Warning: You are using mitmdump %s with netlib %s. " + "Most likely, that doesn't work - please upgrade!" % (version.VERSION, netlib.version.VERSION), + file=sys.stderr) + import OpenSSL, inspect + + v = [int(x) for x in OpenSSL.__version__.split(".")][:2] + if v < (0, 14): + print("You are using an outdated version of pyOpenSSL: mitmproxy requires pyOpenSSL 0.14 or greater.", + file=sys.stderr) + # Some users apparently have multiple versions of pyOpenSSL installed. Report which one we got. + pyopenssl_path = os.path.dirname(inspect.getfile(OpenSSL)) + print("Your pyOpenSSL %s installation is located at %s" % (OpenSSL.__version__, pyopenssl_path), + file=sys.stderr) + sys.exit(1) + + +def assert_utf8_env(): + spec = "" + for i in ["LANG", "LC_CTYPE", "LC_ALL"]: + spec += os.environ.get(i, "").lower() + if "utf" not in spec: + print("Error: mitmproxy requires a UTF console environment.", file=sys.stderr) + print("Set your LANG enviroment variable to something like en_US.UTF-8", file=sys.stderr) + sys.exit(1) + + +def get_server(dummy_server, options): + if dummy_server: + return DummyServer(options) + else: + try: + return ProxyServer(options) + except ProxyServerError, v: + print(str(v), file=sys.stderr) + sys.exit(1) + + +def mitmproxy_cmdline(): + # Don't import libmproxy.console for mitmdump, urwid is not available on all platforms. + from . import console + from .console import palettes + + parser = argparse.ArgumentParser(usage="%(prog)s [options]") + parser.add_argument('--version', action='version', version=version.NAMEVERSION) + cmdline.common_options(parser) + parser.add_argument( + "--palette", type=str, default="dark", + action="store", dest="palette", + help="Select color palette: " + ", ".join(palettes.palettes.keys()) + ) + parser.add_argument( + "-e", + action="store_true", dest="eventlog", + help="Show event log." + ) + group = parser.add_argument_group( + "Filters", + "See help in mitmproxy for filter expression syntax." + ) + group.add_argument( + "-i", "--intercept", action="store", + type=str, dest="intercept", default=None, + help="Intercept filter expression." + ) + + options = parser.parse_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.eventlog = options.eventlog + console_options.intercept = options.intercept + + return console_options, proxy_config + + +def mitmproxy(): # pragma: nocover + from . import console + + check_versions() + assert_utf8_env() + console_options, proxy_config = mitmproxy_cmdline() + server = get_server(console_options.no_server, proxy_config) + + m = console.ConsoleMaster(server, console_options) + try: + m.run() + except KeyboardInterrupt: + pass + + +def mitmdump_cmdline(): + from . import dump + + parser = argparse.ArgumentParser(usage="%(prog)s [options] [filter]") + parser.add_argument('--version', action='version', version="mitmdump" + " " + version.VERSION) + cmdline.common_options(parser) + parser.add_argument( + "--keepserving", + action="store_true", dest="keepserving", default=False, + help="Continue serving after client playback or file read. We exit by default." + ) + parser.add_argument( + "-d", + action="count", dest="flow_detail", default=1, + help="Increase flow detail display level. Can be passed multiple times." + ) + parser.add_argument('args', nargs=argparse.REMAINDER) + + options = parser.parse_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 + + return dump_options, proxy_config + + +def mitmdump(): # pragma: nocover + from . import dump + + check_versions() + dump_options, proxy_config = mitmdump_cmdline() + 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 + diff --git a/libmproxy/protocol/http.py b/libmproxy/protocol/http.py index 5579cb63..1109c753 100644 --- a/libmproxy/protocol/http.py +++ b/libmproxy/protocol/http.py @@ -1028,7 +1028,7 @@ class HTTPHandler(ProtocolHandler): html_content = '<html><head>\n<title>%d %s</title>\n</head>\n<body>\n%s\n</body>\n</html>' % \ (code, response, message) self.c.client_conn.wfile.write("HTTP/1.1 %s %s\r\n" % (code, response)) - self.c.client_conn.wfile.write("Server: %s\r\n" % self.c.server_version) + self.c.client_conn.wfile.write("Server: %s\r\n" % self.c.config.server_version) self.c.client_conn.wfile.write("Content-type: text/html\r\n") self.c.client_conn.wfile.write("Content-Length: %d\r\n" % len(html_content)) if headers: @@ -1079,7 +1079,7 @@ class HTTPHandler(ProtocolHandler): self.c.client_conn.send( 'HTTP/1.1 200 Connection established\r\n' + 'Content-Length: 0\r\n' + - ('Proxy-agent: %s\r\n' % self.c.server_version) + + ('Proxy-agent: %s\r\n' % self.c.config.server_version) + '\r\n' ) return self.process_connect_request(self.c.server_conn.address) diff --git a/libmproxy/proxy/__init__.py b/libmproxy/proxy/__init__.py index e4c20030..f33d323b 100644 --- a/libmproxy/proxy/__init__.py +++ b/libmproxy/proxy/__init__.py @@ -1,2 +1,2 @@ from .primitives import * -from .config import ProxyConfig +from .config import ProxyConfig, process_proxy_options diff --git a/libmproxy/proxy/config.py b/libmproxy/proxy/config.py index 441e05f1..62104a24 100644 --- a/libmproxy/proxy/config.py +++ b/libmproxy/proxy/config.py @@ -2,7 +2,7 @@ from __future__ import absolute_import import os import re from netlib import http_auth, certutils -from .. import utils, platform +from .. import utils, platform, version from .primitives import RegularProxyMode, TransparentProxyMode, UpstreamProxyMode, ReverseProxyMode TRANSPARENT_SSL_PORTS = [443, 8443] @@ -15,11 +15,15 @@ def parse_host_pattern(patterns): class ProxyConfig: - def __init__(self, confdir=CONF_DIR, ca_file=None, clientcerts=None, + def __init__(self, host='', port=8080, server_version=version.NAMEVERSION, + confdir=CONF_DIR, ca_file=None, clientcerts=None, no_upstream_cert=False, body_size_limit=None, mode=None, upstream_server=None, http_form_in=None, http_form_out=None, authenticator=None, ignore=[], ciphers=None, certs=[], certforward=False, ssl_ports=TRANSPARENT_SSL_PORTS): + self.host = host + self.port = port + self.server_version = server_version self.ciphers = ciphers self.clientcerts = clientcerts self.no_upstream_cert = no_upstream_cert @@ -34,6 +38,7 @@ class ProxyConfig: else: self.mode = RegularProxyMode() + # Handle manual overrides of the http forms self.mode.http_form_in = http_form_in or self.mode.http_form_in self.mode.http_form_out = http_form_out or self.mode.http_form_out @@ -105,6 +110,8 @@ def process_proxy_options(parser, options): certs.append(parts) return ProxyConfig( + host=options.addr, + port=options.port, confdir=options.confdir, clientcerts=options.clientcerts, no_upstream_cert=options.no_upstream_cert, diff --git a/libmproxy/proxy/server.py b/libmproxy/proxy/server.py index f4a978ca..307a4bcd 100644 --- a/libmproxy/proxy/server.py +++ b/libmproxy/proxy/server.py @@ -27,14 +27,13 @@ class ProxyServer(tcp.TCPServer): allow_reuse_address = True bound = True - def __init__(self, config, port, host='', server_version=version.NAMEVERSION): + def __init__(self, config): """ Raises ProxyServerError if there's a startup problem. """ self.config = config - self.server_version = server_version try: - tcp.TCPServer.__init__(self, (host, port)) + tcp.TCPServer.__init__(self, (config.host, config.port)) except socket.error, v: raise ProxyServerError('Error starting proxy server: ' + repr(v)) self.channel = None @@ -47,22 +46,20 @@ class ProxyServer(tcp.TCPServer): self.channel = channel def handle_client_connection(self, conn, client_address): - h = ConnectionHandler(self.config, conn, client_address, self, self.channel, - self.server_version) + h = ConnectionHandler(self.config, conn, client_address, self, self.channel) h.handle() h.finish() class ConnectionHandler: - def __init__(self, config, client_connection, client_address, server, channel, - server_version): + def __init__(self, config, client_connection, client_address, server, channel): self.config = config """@type: libmproxy.proxy.config.ProxyConfig""" self.client_conn = ClientConnection(client_connection, client_address, server) """@type: libmproxy.proxy.connection.ClientConnection""" self.server_conn = None """@type: libmproxy.proxy.connection.ServerConnection""" - self.channel, self.server_version = channel, server_version + self.channel = channel self.conntype = "http" self.sni = None |