def test_kill_stream(tctx):
"""Test that we can kill individual streams."""
playbook, cff = start_h2_client(tctx)
flow1 = Placeholder(HTTPFlow)
flow2 = Placeholder(HTTPFlow)
req_headers_hook_1 = http.HttpRequestHeadersHook(flow1)
def kill(flow: HTTPFlow):
# Can't use flow.kill() here because that currently still depends on a reply object.
flow.error = Error(Error.KILLED_MESSAGE)
server = Placeholder(Server)
data_req1 = Placeholder(bytes)
assert (playbook >> DataReceived(
tctx.client,
cff.build_headers_frame(
example_request_headers, flags=["END_STREAM"],
stream_id=1).serialize() + cff.build_headers_frame(
example_request_headers, flags=["END_STREAM"],
stream_id=3).serialize()) << req_headers_hook_1 <<
http.HttpRequestHeadersHook(flow2) >> reply(side_effect=kill) <<
http.HttpErrorHook(flow2) >> reply() << SendData(
tctx.client,
cff.build_rst_stream_frame(
3, error_code=ErrorCodes.INTERNAL_ERROR).serialize()) >>
reply(to=req_headers_hook_1) << http.HttpRequestHook(flow1) >>
reply() << OpenConnection(server) >> reply(
None, side_effect=make_h2) << SendData(server, data_req1))
frames = decode_frames(data_req1())
assert [type(x) for x in frames] == [
hyperframe.frame.SettingsFrame,
hyperframe.frame.HeadersFrame,
]
def test_simple(tctx):
playbook, cff = start_h2_client(tctx)
flow = Placeholder(HTTPFlow)
server = Placeholder(Server)
initial = Placeholder(bytes)
assert (playbook >> DataReceived(
tctx.client,
cff.build_headers_frame(example_request_headers, flags=[
"END_STREAM"
]).serialize()) << http.HttpRequestHeadersHook(flow) >> reply() <<
http.HttpRequestHook(flow) >> reply() << OpenConnection(server) >>
reply(None, side_effect=make_h2) << SendData(server, initial))
frames = decode_frames(initial())
assert [type(x) for x in frames] == [
hyperframe.frame.SettingsFrame,
hyperframe.frame.HeadersFrame,
]
sff = FrameFactory()
assert (
playbook
# a conforming h2 server would send settings first, we disregard this for now.
>> DataReceived(
server,
sff.build_headers_frame(example_response_headers).serialize()) <<
http.HttpResponseHeadersHook(flow) >> reply() >> DataReceived(
server,
sff.build_data_frame(b"Hello, World!", flags=["END_STREAM"
]).serialize()) <<
http.HttpResponseHook(flow) >> reply() << SendData(
tctx.client,
cff.build_headers_frame(example_response_headers).serialize() +
cff.build_data_frame(b"Hello, World!").serialize() +
cff.build_data_frame(b"", flags=["END_STREAM"]).serialize()))
assert flow().request.url == "http://example.com/"
assert flow().response.text == "Hello, World!"
def test_cancel_during_response_hook(tctx):
"""
Test that we properly handle the case of the following event sequence:
- we receive a server response
- we trigger the response hook
- the client cancels the stream
- the response hook completes
Given that we have already triggered the response hook, we don't want to trigger the error hook.
"""
playbook, cff = start_h2_client(tctx)
flow = Placeholder(HTTPFlow)
server = Placeholder(Server)
assert (playbook >> DataReceived(
tctx.client,
cff.build_headers_frame(example_request_headers, flags=[
"END_STREAM"
]).serialize()) << http.HttpRequestHeadersHook(flow) >> reply() <<
http.HttpRequestHook(flow) >> reply() << OpenConnection(server) >>
reply(None) << SendData(
server, b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n') >>
DataReceived(server, b"HTTP/1.1 204 No Content\r\n\r\n") <<
http.HttpResponseHeadersHook(flow) << CloseConnection(server) >>
reply(to=-2) << http.HttpResponseHook(flow) >> DataReceived(
tctx.client,
cff.build_rst_stream_frame(
1, ErrorCodes.CANCEL).serialize()) >> reply(to=-2))
def test_disconnect_while_intercept(tctx):
"""Test a server disconnect while a request is intercepted."""
tctx.options.connection_strategy = "eager"
server1 = Placeholder(Server)
server2 = Placeholder(Server)
flow = Placeholder(HTTPFlow)
assert (
Playbook(http.HttpLayer(tctx, HTTPMode.regular), hooks=False) >>
DataReceived(tctx.client, b"CONNECT example.com:80 HTTP/1.1\r\n\r\n")
<< http.HttpConnectHook(Placeholder(HTTPFlow)) >> reply() <<
OpenConnection(server1) >> reply(None) << SendData(
tctx.client,
b'HTTP/1.1 200 Connection established\r\n\r\n') >> DataReceived(
tctx.client, b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n") <<
layer.NextLayerHook(Placeholder()) >>
reply_next_layer(lambda ctx: http.HttpLayer(ctx, HTTPMode.transparent))
<< http.HttpRequestHook(flow) >> ConnectionClosed(server1) <<
CloseConnection(server1) >> reply(to=-3) << OpenConnection(server2) >>
reply(None) << SendData(
server2,
b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n") >> DataReceived(
server2, b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n") <<
SendData(tctx.client, b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"))
assert server1() != server2()
assert flow().server_conn == server2()
def test_rst_then_close(tctx):
"""
Test that we properly handle the case of a client that first causes protocol errors and then disconnects.
Adapted from h2spec http2/5.1/5.
"""
playbook, cff = start_h2_client(tctx)
flow = Placeholder(HTTPFlow)
server = Placeholder(Server)
assert (playbook >> DataReceived(
tctx.client,
cff.build_headers_frame(example_request_headers, flags=[
"END_STREAM"
]).serialize()) << http.HttpRequestHeadersHook(flow) >> reply() <<
http.HttpRequestHook(flow) >> reply() << OpenConnection(server) >>
DataReceived(
tctx.client,
cff.build_data_frame(b"unexpected data frame").serialize()) <<
SendData(
tctx.client,
cff.build_rst_stream_frame(
1, ErrorCodes.STREAM_CLOSED).serialize()) >>
ConnectionClosed(tctx.client) << CloseConnection(
tctx.client) >> reply("connection cancelled", to=-5) <<
http.HttpErrorHook(flow) >> reply())
assert flow().error.msg == "connection cancelled"
def assert_kill(err_hook: bool = True):
playbook >> reply(side_effect=kill)
if err_hook:
playbook << http.HttpErrorHook(flow)
playbook >> reply()
playbook << CloseConnection(tctx.client)
assert playbook
def test_server_unreachable(tctx, connect):
"""Test the scenario where the target server is unreachable."""
tctx.options.connection_strategy = "eager"
server = Placeholder(Server)
flow = Placeholder(HTTPFlow)
err = Placeholder(bytes)
playbook = Playbook(http.HttpLayer(tctx, HTTPMode.regular), hooks=False)
if connect:
playbook >> DataReceived(tctx.client,
b"CONNECT example.com:443 HTTP/1.1\r\n\r\n")
else:
playbook >> DataReceived(tctx.client,
b"GET http://example.com/ HTTP/1.1\r\n\r\n")
playbook << OpenConnection(server)
playbook >> reply("Connection failed")
if not connect:
# Our API isn't ideal here, there is no error hook for CONNECT requests currently.
# We could fix this either by having CONNECT request go through all our regular hooks,
# or by adding dedicated ok/error hooks.
playbook << http.HttpErrorHook(flow)
playbook >> reply()
playbook << SendData(tctx.client, err)
if not connect:
playbook << CloseConnection(tctx.client)
assert playbook
if not connect:
assert flow().error
assert b"502 Bad Gateway" in err()
assert b"Connection failed" in err()
def test_h2_to_h1(tctx):
"""Test HTTP/2 -> HTTP/1 request translation"""
server = Placeholder(Server)
flow = Placeholder(HTTPFlow)
conn, playbook = h2_client(tctx)
conn.send_headers(1, example_request_headers, end_stream=True)
response = Placeholder(bytes)
assert (
playbook >> DataReceived(tctx.client, conn.data_to_send()) <<
http.HttpRequestHeadersHook(flow) >> reply() <<
http.HttpRequestHook(flow) >> reply() << OpenConnection(server) >>
reply(None) << SendData(
server, b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n") >>
DataReceived(server, b"HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\n")
<< http.HttpResponseHeadersHook(flow) >> reply() >> DataReceived(
server, b"Hello World!") << http.HttpResponseHook(flow) <<
CloseConnection(server) >> reply(to=-2) << SendData(
tctx.client, response))
events = conn.receive_data(response())
assert event_types(events) == [
h2.events.ResponseReceived, h2.events.DataReceived,
h2.events.DataReceived, h2.events.StreamEnded
]
resp: h2.events.ResponseReceived = events[0]
body: h2.events.DataReceived = events[1]
assert resp.headers == [(b':status', b'200'), (b'content-length', b'12')]
assert body.data == b"Hello World!"
def test_cancel_then_server_disconnect(tctx):
"""
Test that we properly handle the case of the following event sequence:
- client cancels a stream
- we start an error hook
- server disconnects
- error hook completes.
"""
playbook, cff = start_h2_client(tctx)
flow = Placeholder(HTTPFlow)
server = Placeholder(Server)
assert (playbook >> DataReceived(
tctx.client,
cff.build_headers_frame(example_request_headers, flags=[
"END_STREAM"
]).serialize()) << http.HttpRequestHeadersHook(flow) >> reply() <<
http.HttpRequestHook(flow) >> reply() << OpenConnection(server) >>
reply(None) << SendData(
server, b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n') >>
DataReceived(
tctx.client,
cff.build_rst_stream_frame(1, ErrorCodes.CANCEL).serialize())
<< CloseConnection(server) << http.HttpErrorHook(flow) >> reply()
>> ConnectionClosed(server) << None)
def test_http_client_aborts(tctx, stream):
"""Test handling of the case where a client aborts during request transmission."""
server = Placeholder(Server)
flow = Placeholder(HTTPFlow)
playbook = Playbook(http.HttpLayer(tctx, HTTPMode.regular), hooks=True)
def enable_streaming(flow: HTTPFlow):
flow.request.stream = True
assert (playbook >> DataReceived(
tctx.client, b"POST http://example.com/ HTTP/1.1\r\n"
b"Host: example.com\r\n"
b"Content-Length: 6\r\n"
b"\r\n"
b"abc") << http.HttpRequestHeadersHook(flow))
if stream:
assert (playbook >> reply(side_effect=enable_streaming) <<
http.HttpRequestHook(flow) >> reply() << OpenConnection(server)
>> reply(None) << SendData(
server, b"POST / HTTP/1.1\r\n"
b"Host: example.com\r\n"
b"Content-Length: 6\r\n"
b"\r\n"
b"abc"))
else:
assert playbook >> reply()
(playbook >> ConnectionClosed(tctx.client) << CloseConnection(tctx.client))
if stream:
playbook << CloseConnection(server)
assert (playbook << http.HttpErrorHook(flow) >> reply() << None)
assert "peer closed connection" in flow().error.msg
def test_h1_to_h2(tctx):
"""Test HTTP/1 -> HTTP/2 request translation"""
server = Placeholder(Server)
flow = Placeholder(HTTPFlow)
playbook = Playbook(http.HttpLayer(tctx, HTTPMode.regular))
conf = h2.config.H2Configuration(client_side=False)
conn = h2.connection.H2Connection(conf)
conn.initiate_connection()
request = Placeholder(bytes)
assert (playbook >> DataReceived(
tctx.client,
b"GET http://example.com/ HTTP/1.1\r\nHost: example.com\r\n\r\n") <<
http.HttpRequestHeadersHook(flow) >> reply() <<
http.HttpRequestHook(flow) >> reply() << OpenConnection(server) >>
reply(None, side_effect=make_h2) << SendData(server, request))
events = conn.receive_data(request())
assert event_types(events) == [
h2.events.RemoteSettingsChanged, h2.events.RequestReceived,
h2.events.StreamEnded
]
conn.send_headers(1, example_response_headers)
conn.send_data(1, b"Hello World!", end_stream=True)
settings_ack = Placeholder(bytes)
assert (
playbook >> DataReceived(server, conn.data_to_send()) <<
http.HttpResponseHeadersHook(flow) << SendData(server, settings_ack) >>
reply(to=-2) << http.HttpResponseHook(flow) >> reply() << SendData(
tctx.client, b"HTTP/1.1 200 OK\r\n\r\nHello World!") <<
CloseConnection(tctx.client))
assert settings_ack() == b'\x00\x00\x00\x04\x01\x00\x00\x00\x00'
def test_drop_message(ws_testdata):
tctx, playbook = ws_testdata
flow = Placeholder(WebSocketFlow)
assert (playbook << websocket.WebsocketStartHook(flow) >> reply() >>
DataReceived(tctx.server, b"\x81\x03foo") <<
websocket.WebsocketMessageHook(flow))
flow().messages[-1].content = ""
assert (playbook >> reply() << None)
def test_close_disconnect(ws_testdata):
tctx, playbook = ws_testdata
flow = Placeholder(WebSocketFlow)
assert (playbook << websocket.WebsocketStartHook(flow) >> reply() >>
ConnectionClosed(tctx.server) << CloseConnection(tctx.server) <<
SendData(tctx.client, b"\x88\x02\x03\xe8") << CloseConnection(
tctx.client) << websocket.WebsocketErrorHook(flow) >> reply()
>> ConnectionClosed(tctx.client))
assert "ABNORMAL_CLOSURE" in flow().error.msg
def test_modify_message(ws_testdata):
tctx, playbook = ws_testdata
flow = Placeholder(WebSocketFlow)
assert (playbook << websocket.WebsocketStartHook(flow) >> reply() >>
DataReceived(tctx.server, b"\x81\x03foo") <<
websocket.WebsocketMessageHook(flow))
flow().messages[-1].content = flow().messages[-1].content.replace(
"foo", "foobar")
assert (playbook >> reply() << SendData(tctx.client, b"\x81\x06foobar"))
def test_close_error(ws_testdata):
tctx, playbook = ws_testdata
flow = Placeholder(WebSocketFlow)
assert (playbook << websocket.WebsocketStartHook(flow) >> reply() >>
DataReceived(tctx.server, b"\x88\x02\x0f\xa0") << SendData(
tctx.server, masked(b"\x88\x02\x0f\xa0")) << CloseConnection(
tctx.server) << SendData(tctx.client, b"\x88\x02\x0f\xa0")
<< CloseConnection(
tctx.client) << websocket.WebsocketErrorHook(flow) >> reply())
assert "UNKNOWN_ERROR=4000" in flow().error.msg
def test_fragmented(ws_testdata):
tctx, playbook = ws_testdata
flow = Placeholder(WebSocketFlow)
assert (playbook << websocket.WebsocketStartHook(flow) >> reply() >>
DataReceived(tctx.server, b"\x01\x03foo") >> DataReceived(
tctx.server, b"\x80\x03bar") <<
websocket.WebsocketMessageHook(flow) >> reply() << SendData(
tctx.client, b"\x01\x03foo") << SendData(
tctx.client, b"\x80\x03bar"))
assert flow().messages[-1].content == "foobar"
def test_deflate(ws_testdata):
tctx, playbook = ws_testdata
flow = Placeholder(WebSocketFlow)
# noinspection PyUnresolvedReferences
http_flow: HTTPFlow = playbook.layer.flow.handshake_flow
http_flow.response.headers[
"Sec-WebSocket-Extensions"] = "permessage-deflate; server_max_window_bits=10"
assert (playbook << websocket.WebsocketStartHook(flow) >> reply()
# https://tools.ietf.org/html/rfc7692#section-7.2.3.1
>> DataReceived(tctx.server,
bytes.fromhex("c1 07 f2 48 cd c9 c9 07 00")) <<
websocket.WebsocketMessageHook(flow) >> reply() << SendData(
tctx.client, bytes.fromhex("c1 07 f2 48 cd c9 c9 07 00")))
assert flow().messages[0].content == "Hello"
def test_redirect(strategy, https_server, https_client, tctx, monkeypatch):
"""Test redirects between http:// and https:// in regular proxy mode."""
server = Placeholder(Server)
flow = Placeholder(HTTPFlow)
tctx.options.connection_strategy = strategy
p = Playbook(http.HttpLayer(tctx, HTTPMode.regular), hooks=False)
if https_server:
monkeypatch.setattr(tls, "ServerTLSLayer", tls.MockTLSLayer)
def redirect(flow: HTTPFlow):
if https_server:
flow.request.url = "https://redirected.site/"
else:
flow.request.url = "http://redirected.site/"
if https_client:
p >> DataReceived(tctx.client,
b"CONNECT example.com:80 HTTP/1.1\r\n\r\n")
if strategy == "eager":
p << OpenConnection(Placeholder())
p >> reply(None)
p << SendData(tctx.client,
b'HTTP/1.1 200 Connection established\r\n\r\n')
p >> DataReceived(tctx.client,
b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
p << layer.NextLayerHook(Placeholder())
p >> reply_next_layer(
lambda ctx: http.HttpLayer(ctx, HTTPMode.transparent))
else:
p >> DataReceived(
tctx.client,
b"GET http://example.com/ HTTP/1.1\r\nHost: example.com\r\n\r\n")
p << http.HttpRequestHook(flow)
p >> reply(side_effect=redirect)
p << OpenConnection(server)
p >> reply(None)
p << SendData(server, b"GET / HTTP/1.1\r\nHost: redirected.site\r\n\r\n")
p >> DataReceived(
server, b"HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World!")
p << SendData(
tctx.client,
b"HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World!")
assert p
if https_server:
assert server().address == ("redirected.site", 443)
else:
assert server().address == ("redirected.site", 80)
def test_proxy_chain(tctx, strategy):
server = Placeholder(Server)
tctx.options.connection_strategy = strategy
playbook = Playbook(http.HttpLayer(tctx, HTTPMode.regular), hooks=False)
playbook >> DataReceived(tctx.client,
b"CONNECT proxy:8080 HTTP/1.1\r\n\r\n")
if strategy == "eager":
playbook << OpenConnection(server)
playbook >> reply(None)
playbook << SendData(tctx.client,
b"HTTP/1.1 200 Connection established\r\n\r\n")
playbook >> DataReceived(tctx.client,
b"CONNECT second-proxy:8080 HTTP/1.1\r\n\r\n")
playbook << layer.NextLayerHook(Placeholder())
playbook >> reply_next_layer(
lambda ctx: http.HttpLayer(ctx, HTTPMode.transparent))
playbook << SendData(
tctx.client, b"HTTP/1.1 502 Bad Gateway\r\n"
b"content-length: 198\r\n"
b"\r\n"
b"mitmproxy received an HTTP CONNECT request even though it is not running in regular/upstream mode. "
b"This usually indicates a misconfiguration, please see the mitmproxy mode documentation for details."
)
assert playbook
def test_protocol_error(ws_testdata):
tctx, playbook = ws_testdata
flow = Placeholder(WebSocketFlow)
assert (
playbook << websocket.WebsocketStartHook(flow) >> reply() >>
DataReceived(tctx.server, b"\x01\x03foo") >>
DataReceived(tctx.server, b"\x02\x03bar") << SendData(
tctx.server,
masked(
b"\x88/\x03\xeaexpected CONTINUATION, got <Opcode.BINARY: 2>"))
<< CloseConnection(tctx.server) << SendData(
tctx.client,
b"\x88/\x03\xeaexpected CONTINUATION, got <Opcode.BINARY: 2>") <<
CloseConnection(
tctx.client) << websocket.WebsocketErrorHook(flow) >> reply())
assert not flow().messages
def test_close_normal(ws_testdata):
tctx, playbook = ws_testdata
flow = Placeholder(WebSocketFlow)
masked_close = Placeholder(bytes)
close = Placeholder(bytes)
assert (playbook << websocket.WebsocketStartHook(flow) >> reply() >>
DataReceived(tctx.client, masked_bytes(b"\x88\x00")) << SendData(
tctx.server, masked_close) << CloseConnection(tctx.server) <<
SendData(tctx.client, close) << CloseConnection(
tctx.client) << websocket.WebsocketEndHook(flow) >> reply())
# wsproto currently handles this inconsistently, see
# https://github.com/python-hyper/wsproto/pull/153/files
assert masked_close() == masked(
b"\x88\x02\x03\xe8") or masked_close() == masked(b"\x88\x00")
assert close() == b"\x88\x02\x03\xe8" or close() == b"\x88\x00"
assert flow().close_code == 1005
def test_https_proxy(strategy, tctx):
"""Test a CONNECT request, followed by a HTTP GET /"""
server = Placeholder(Server)
flow = Placeholder(HTTPFlow)
playbook = Playbook(http.HttpLayer(tctx, HTTPMode.regular))
tctx.options.connection_strategy = strategy
(playbook >> DataReceived(tctx.client,
b"CONNECT example.proxy:80 HTTP/1.1\r\n\r\n") <<
http.HttpConnectHook(Placeholder()) >> reply())
if strategy == "eager":
(playbook << OpenConnection(server) >> reply(None))
(playbook << SendData(tctx.client,
b'HTTP/1.1 200 Connection established\r\n\r\n') >>
DataReceived(tctx.client,
b"GET /foo?hello=1 HTTP/1.1\r\nHost: example.com\r\n\r\n") <<
layer.NextLayerHook(Placeholder()) >>
reply_next_layer(lambda ctx: http.HttpLayer(ctx, HTTPMode.transparent)) <<
http.HttpRequestHeadersHook(flow) >> reply() << http.HttpRequestHook(flow)
>> reply())
if strategy == "lazy":
(playbook << OpenConnection(server) >> reply(None))
(playbook << SendData(
server, b"GET /foo?hello=1 HTTP/1.1\r\nHost: example.com\r\n\r\n") >>
DataReceived(
server, b"HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World!")
<< http.HttpResponseHeadersHook(flow) >> reply() <<
http.HttpResponseHook(flow) >> reply() << SendData(
tctx.client,
b"HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World!"))
assert playbook
def test_close_during_connect_hook(tctx):
flow = Placeholder(HTTPFlow)
assert (Playbook(http.HttpLayer(tctx, HTTPMode.regular)) >> DataReceived(
tctx.client, b'CONNECT hi.ls:443 HTTP/1.1\r\n'
b'Proxy-Connection: keep-alive\r\n'
b'Connection: keep-alive\r\n'
b'Host: hi.ls:443\r\n\r\n') << http.HttpConnectHook(flow) >>
ConnectionClosed(tctx.client) << CloseConnection(
tctx.client) >> reply(to=-3))
def test_server_aborts(tctx, data):
"""Test the scenario where the server doesn't serve a response"""
server = Placeholder(Server)
flow = Placeholder(HTTPFlow)
err = Placeholder(bytes)
playbook = Playbook(http.HttpLayer(tctx, HTTPMode.regular), hooks=False)
assert (playbook >> DataReceived(
tctx.client,
b"GET http://example.com/ HTTP/1.1\r\nHost: example.com\r\n\r\n") <<
OpenConnection(server) >> reply(None) << SendData(
server, b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"))
if data:
playbook >> DataReceived(server, data)
assert (playbook >> ConnectionClosed(server) << CloseConnection(server)
<< http.HttpErrorHook(flow) >> reply() << SendData(
tctx.client, err) << CloseConnection(tctx.client))
assert flow().error
assert b"502 Bad Gateway" in err()
def test_unknown_ext(ws_testdata):
tctx, playbook = ws_testdata
flow = Placeholder(WebSocketFlow)
# noinspection PyUnresolvedReferences
http_flow: HTTPFlow = playbook.layer.flow.handshake_flow
http_flow.response.headers[
"Sec-WebSocket-Extensions"] = "funky-bits; param=42"
assert (
playbook << Log("Ignoring unknown WebSocket extension 'funky-bits'.")
<< websocket.WebsocketStartHook(flow) >> reply())
def test_http_proxy(tctx):
"""Test a simple HTTP GET / request"""
server = Placeholder(Server)
flow = Placeholder(HTTPFlow)
assert (Playbook(http.HttpLayer(tctx, HTTPMode.regular)) >> DataReceived(
tctx.client,
b"GET http://example.com/foo?hello=1 HTTP/1.1\r\nHost: example.com\r\n\r\n"
) << http.HttpRequestHeadersHook(flow) >> reply() << http.HttpRequestHook(
flow) >> reply() << OpenConnection(server) >> reply(None) << SendData(
server, b"GET /foo?hello=1 HTTP/1.1\r\nHost: example.com\r\n\r\n")
>> DataReceived(
server,
b"HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World") <<
http.HttpResponseHeadersHook(flow) >> reply() >> DataReceived(
server, b"!") << http.HttpResponseHook(flow) >> reply() <<
SendData(
tctx.client,
b"HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World!"))
assert server().address == ("example.com", 80)
def test_transparent_failure(tctx: Context, monkeypatch):
"""Test that we recover from a transparent mode resolve error."""
def raise_err(sock):
raise RuntimeError("platform-specific error")
monkeypatch.setattr(platform, "original_addr", raise_err)
assert (Playbook(modes.TransparentProxy(tctx), logs=True) << GetSocket(
tctx.client
) >> reply(object()) << Log(
"Transparent mode failure: RuntimeError('platform-specific error')",
"info"))
def test_no_headers(tctx):
"""Test that we can correctly reassemble requests/responses with no headers."""
server = Placeholder(Server)
assert (
Playbook(http.HttpLayer(tctx, HTTPMode.regular), hooks=False) >>
DataReceived(tctx.client, b"GET http://example.com/ HTTP/1.1\r\n\r\n")
<< OpenConnection(server) >> reply(None) << SendData(
server, b"GET / HTTP/1.1\r\n\r\n") >> DataReceived(
server, b"HTTP/1.1 204 No Content\r\n\r\n") << SendData(
tctx.client, b"HTTP/1.1 204 No Content\r\n\r\n"))
assert server().address == ("example.com", 80)
def test_http_proxy_relative_request(tctx):
"""Test handling of a relative-form "GET /" in regular proxy mode."""
server = Placeholder(Server)
assert (Playbook(http.HttpLayer(
tctx, HTTPMode.regular), hooks=False) >> DataReceived(
tctx.client, b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n") <<
OpenConnection(server) >> reply(None) << SendData(
server, b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n") >>
DataReceived(server, b"HTTP/1.1 204 No Content\r\n\r\n") <<
SendData(tctx.client, b"HTTP/1.1 204 No Content\r\n\r\n"))
assert server().address == ("example.com", 80)
def test_reverse_eager_connect_failure(tctx: Context):
"""
Test
client --TCP-- mitmproxy --TCP over TLS-- server
reverse proxying.
"""
tctx.options.mode = "reverse:https://localhost:8000"
tctx.options.connection_strategy = "eager"
playbook = Playbook(modes.ReverseProxy(tctx))
assert (playbook << OpenConnection(tctx.server) >> reply("IPoAC unstable")
<< CloseConnection(tctx.client) >> ConnectionClosed(tctx.client))