Grasscutters/mitmproxy
3
0
Fork 0
mirror of https://github.com/Grasscutters/mitmproxy.git synced 2025-02-01 15:55:28 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #86 from Kriechi/http2-wip

Browse Source 
http2: fix TODOs
This commit is contained in:
Thomas Kriechbaumer 2015-08-18 22:19:30 +02:00
commit 57c56d8917
3 changed files with 167 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
netlib/http/cookies.py
View File

@ -23,8 +23,7 @@ variants. Serialization follows RFC6265.
http://tools.ietf.org/html/rfc2965
"""
# TODO
# - Disallow LHS-only Cookie values
# TODO: Disallow LHS-only Cookie values
def _read_until(s, start, term):

89
netlib/http/http2/protocol.py
View File

@ -80,13 +80,39 @@ class HTTP2Protocol(semantics.ProtocolMixin):
timestamp_end = time.time()
authority = headers.get_first(':authority', '')
method = headers.get_first(':method', 'GET')
scheme = headers.get_first(':scheme', 'https')
path = headers.get_first(':path', '/')
host = None
port = None
if path == '*' or path.startswith("/"):
form_in = "relative"
elif method == 'CONNECT':
form_in = "authority"
if ":" in authority:
host, port = authority.split(":", 1)
else:
host = authority
else:
form_in = "absolute"
# FIXME: verify if path or :host contains what we need
scheme, host, port, _ = utils.parse_url(path)
if host is None:
host = 'localhost'
if port is None:
port = 80 if scheme == 'http' else 443
port = int(port)
request = http.Request(
"relative", # TODO: use the correct value
headers.get_first(':method', 'GET'),
headers.get_first(':scheme', 'https'),
headers.get_first(':host', 'localhost'),
443, # TODO: parse port number from host?
headers.get_first(':path', '/'),
form_in,
method,
scheme,
host,
port,
path,
(2, 0),
headers,
body,
@ -274,44 +300,57 @@ class HTTP2Protocol(semantics.ProtocolMixin):
# to be more strict use: self._read_settings_ack(hide)
def _create_headers(self, headers, stream_id, end_stream=True):
# TODO: implement max frame size checks and sending in chunks
flags = frame.Frame.FLAG_END_HEADERS
if end_stream:
flags |= frame.Frame.FLAG_END_STREAM
def frame_cls(chunks):
for i in chunks:
if i == 0:
yield frame.HeadersFrame, i
else:
yield frame.ContinuationFrame, i
header_block_fragment = self.encoder.encode(headers)
frm = frame.HeadersFrame(
chunk_size = self.http2_settings[frame.SettingsFrame.SETTINGS.SETTINGS_MAX_FRAME_SIZE]
chunks = range(0, len(header_block_fragment), chunk_size)
frms = [frm_cls(
state=self,
flags=flags,
flags=frame.Frame.FLAG_NO_FLAGS,
stream_id=stream_id,
header_block_fragment=header_block_fragment)
header_block_fragment=header_block_fragment[i:i+chunk_size]) for frm_cls, i in frame_cls(chunks)]
last_flags = frame.Frame.FLAG_END_HEADERS
if end_stream:
last_flags |= frame.Frame.FLAG_END_STREAM
frms[-1].flags = last_flags
if self.dump_frames: # pragma no cover
print(frm.human_readable(">>"))
for frm in frms:
print(frm.human_readable(">>"))
return [frm.to_bytes()]
return [frm.to_bytes() for frm in frms]
def _create_body(self, body, stream_id):
if body is None or len(body) == 0:
return b''
# TODO: implement max frame size checks and sending in chunks
chunk_size = self.http2_settings[frame.SettingsFrame.SETTINGS.SETTINGS_MAX_FRAME_SIZE]
chunks = range(0, len(body), chunk_size)
frms = [frame.DataFrame(
state=self,
flags=frame.Frame.FLAG_NO_FLAGS,
stream_id=stream_id,
payload=body[i:i+chunk_size]) for i in chunks]
frms[-1].flags = frame.Frame.FLAG_END_STREAM
# TODO: implement flow-control window
frm = frame.DataFrame(
state=self,
flags=frame.Frame.FLAG_END_STREAM,
stream_id=stream_id,
payload=body)
if self.dump_frames: # pragma no cover
print(frm.human_readable(">>"))
for frm in frms:
print(frm.human_readable(">>"))
return [frm.to_bytes()]
return [frm.to_bytes() for frm in frms]
def _receive_transmission(self, include_body=True):
# TODO: include_body is not respected
body_expected = True
stream_id = 0

114
test/http/http2/test_protocol.py
View File

@ -247,30 +247,48 @@ class TestCreateHeaders():
'000014010400000001824488355217caf3a69a3f87408294e7838c767f'\
.decode('hex')
# TODO: add test for too large header_block_fragments
def test_create_headers_multiple_frames(self):
headers = [
(b':method', b'GET'),
(b':path', b'/'),
(b':scheme', b'https'),
(b'foo', b'bar'),
(b'server', b'version')]
protocol = HTTP2Protocol(self.c)
protocol.http2_settings[SettingsFrame.SETTINGS.SETTINGS_MAX_FRAME_SIZE] = 8
bytes = protocol._create_headers(headers, 1, end_stream=True)
assert len(bytes) == 3
assert bytes[0] == '000008010000000001828487408294e783'.decode('hex')
assert bytes[1] == '0000080900000000018c767f7685ee5b10'.decode('hex')
assert bytes[2] == '00000209050000000163d5'.decode('hex')
class TestCreateBody():
c = tcp.TCPClient(("127.0.0.1", 0))
protocol = HTTP2Protocol(c)
def test_create_body_empty(self):
bytes = self.protocol._create_body(b'', 1)
protocol = HTTP2Protocol(self.c)
bytes = protocol._create_body(b'', 1)
assert b''.join(bytes) == ''.decode('hex')
def test_create_body_single_frame(self):
bytes = self.protocol._create_body('foobar', 1)
protocol = HTTP2Protocol(self.c)
bytes = protocol._create_body('foobar', 1)
assert b''.join(bytes) == '000006000100000001666f6f626172'.decode('hex')
def test_create_body_multiple_frames(self):
pass
# bytes = self.protocol._create_body('foobar' * 3000, 1)
# TODO: add test for too large frames
protocol = HTTP2Protocol(self.c)
protocol.http2_settings[SettingsFrame.SETTINGS.SETTINGS_MAX_FRAME_SIZE] = 5
bytes = protocol._create_body('foobarmehm42', 1)
assert len(bytes) == 3
assert bytes[0] == '000005000000000001666f6f6261'.decode('hex')
assert bytes[1] == '000005000000000001726d65686d'.decode('hex')
assert bytes[2] == '0000020001000000013432'.decode('hex')
class TestReadRequest(tservers.ServerTestBase):
class handler(tcp.BaseHandler):
def handle(self):
self.wfile.write(
b'000003010400000001828487'.decode('hex'))
@ -287,11 +305,83 @@ class TestReadRequest(tservers.ServerTestBase):
protocol = HTTP2Protocol(c, is_server=True)
protocol.connection_preface_performed = True
resp = protocol.read_request()
req = protocol.read_request()
assert resp.stream_id
assert resp.headers.lst == [[u':method', u'GET'], [u':path', u'/'], [u':scheme', u'https']]
assert resp.body == b'foobar'
assert req.stream_id
assert req.headers.lst == [[u':method', u'GET'], [u':path', u'/'], [u':scheme', u'https']]
assert req.body == b'foobar'
class TestReadRequestRelative(tservers.ServerTestBase):
class handler(tcp.BaseHandler):
def handle(self):
self.wfile.write(
b'00000c0105000000014287d5af7e4d5a777f4481f9'.decode('hex'))
self.wfile.flush()
ssl = True
def test_asterisk_form_in(self):
c = tcp.TCPClient(("127.0.0.1", self.port))
c.connect()
c.convert_to_ssl()
protocol = HTTP2Protocol(c, is_server=True)
protocol.connection_preface_performed = True
"OPTIONS *"
req = protocol.read_request()
assert req.form_in == "relative"
assert req.method == "OPTIONS"
assert req.path == "*"
class TestReadRequestAbsolute(tservers.ServerTestBase):
class handler(tcp.BaseHandler):
def handle(self):
self.wfile.write(
b'00001901050000000182448d9d29aee30c0e492c2a1170426366871c92585422e085'.decode('hex'))
self.wfile.flush()
ssl = True
def test_absolute_form_in(self):
c = tcp.TCPClient(("127.0.0.1", self.port))
c.connect()
c.convert_to_ssl()
protocol = HTTP2Protocol(c, is_server=True)
protocol.connection_preface_performed = True
req = protocol.read_request()
assert req.form_in == "absolute"
assert req.scheme == "http"
assert req.host == "address"
assert req.port == 22
class TestReadRequestConnect(tservers.ServerTestBase):
class handler(tcp.BaseHandler):
def handle(self):
self.wfile.write(
b'00001b0105000000014287bdab4e9c17b7ff44871c92585422e08541871c92585422e085'.decode('hex'))
self.wfile.flush()
ssl = True
def test_connect(self):
c = tcp.TCPClient(("127.0.0.1", self.port))
c.connect()
c.convert_to_ssl()
protocol = HTTP2Protocol(c, is_server=True)
protocol.connection_preface_performed = True
req = protocol.read_request()
assert req.form_in == "authority"
assert req.method == "CONNECT"
assert req.host == "address"
assert req.port == 22
class TestReadResponse(tservers.ServerTestBase):