def test_writer_flush_error(self): s = BytesIO() s = tcp.Writer(s) o = mock.MagicMock() o.flush = mock.MagicMock(side_effect=socket.error) s.o = o tutils.raises(TcpDisconnect, s.flush)
def test_client_greeting_assert_socks5(): raw = tutils.treader("\x00\x00") msg = socks.ClientGreeting.from_file(raw) tutils.raises(socks.SocksError, msg.assert_socks5) raw = tutils.treader("HTTP/1.1 200 OK" + " " * 100) msg = socks.ClientGreeting.from_file(raw) try: msg.assert_socks5() except socks.SocksError as e: assert "Invalid SOCKS version" in str(e) assert "HTTP" not in str(e) else: assert False raw = tutils.treader("GET / HTTP/1.1" + " " * 100) msg = socks.ClientGreeting.from_file(raw) try: msg.assert_socks5() except socks.SocksError as e: assert "Invalid SOCKS version" in str(e) assert "HTTP" in str(e) else: assert False raw = tutils.treader("XX") tutils.raises( socks.SocksError, socks.ClientGreeting.from_file, raw, fail_early=True)
def test_replay(self): o = dump.Options(server_replay=["nonexistent"], kill=True) tutils.raises(dump.DumpError, dump.DumpMaster, None, o) with tutils.tmpdir() as t: p = os.path.join(t, "rep") self.flowfile(p) o = dump.Options(server_replay=[p], kill=True) o.verbosity = 0 o.flow_detail = 0 m = dump.DumpMaster(None, o) self.cycle(m, b"content") self.cycle(m, b"content") o = dump.Options(server_replay=[p], kill=False) o.verbosity = 0 o.flow_detail = 0 m = dump.DumpMaster(None, o) self.cycle(m, b"nonexistent") o = dump.Options(client_replay=[p], kill=False) o.verbosity = 0 o.flow_detail = 0 m = dump.DumpMaster(None, o)
def test_legacy_first_line(self): req = tutils.treq() assert req.legacy_first_line('relative') == "GET /path HTTP/1.1" assert req.legacy_first_line('authority') == "GET address:22 HTTP/1.1" assert req.legacy_first_line('absolute') == "GET http://address:22/path HTTP/1.1" tutils.raises(http.HttpError, req.legacy_first_line, 'foobar')
def test_invalid_flags(): tutils.raises( ValueError, DataFrame, flags=ContinuationFrame.FLAG_END_HEADERS, stream_id=0x1234567, payload='foobar')
def test_settings_frame_to_bytes(): f = SettingsFrame( length=0, flags=Frame.FLAG_NO_FLAGS, stream_id=0x0) assert f.to_bytes().encode('hex') == '000000040000000000' f = SettingsFrame( length=0, flags=SettingsFrame.FLAG_ACK, stream_id=0x0) assert f.to_bytes().encode('hex') == '000000040100000000' f = SettingsFrame( length=6, flags=SettingsFrame.FLAG_ACK, stream_id=0x0, settings={ SettingsFrame.SETTINGS.SETTINGS_ENABLE_PUSH: 1}) assert f.to_bytes().encode('hex') == '000006040100000000000200000001' f = SettingsFrame( length=12, flags=Frame.FLAG_NO_FLAGS, stream_id=0x0, settings={ SettingsFrame.SETTINGS.SETTINGS_ENABLE_PUSH: 1, SettingsFrame.SETTINGS.SETTINGS_MAX_CONCURRENT_STREAMS: 0x12345678}) assert f.to_bytes().encode('hex') == '00000c040000000000000200000001000312345678' f = SettingsFrame( length=0, flags=Frame.FLAG_NO_FLAGS, stream_id=0x1234567) tutils.raises(ValueError, f.to_bytes)
def test_too_large_frames(): f = DataFrame( length=9000, flags=Frame.FLAG_END_STREAM, stream_id=0x1234567, payload='foobar' * 3000) tutils.raises(FrameSizeError, f.to_bytes)
def test_priority_frame_to_bytes(): f = PriorityFrame( length=5, flags=(Frame.FLAG_NO_FLAGS), stream_id=0x1234567, exclusive=True, stream_dependency=0x0, weight=42) assert_equal(f.to_bytes().encode('hex'), '000005020001234567800000002a') f = PriorityFrame( length=5, flags=(Frame.FLAG_NO_FLAGS), stream_id=0x1234567, exclusive=False, stream_dependency=0x7654321, weight=21) assert_equal(f.to_bytes().encode('hex'), '0000050200012345670765432115') f = PriorityFrame( length=5, flags=Frame.FLAG_NO_FLAGS, stream_id=0x0, stream_dependency=0x1234567) tutils.raises(ValueError, f.to_bytes)
def test_push_promise_frame_to_bytes(): f = PushPromiseFrame( length=10, flags=Frame.FLAG_NO_FLAGS, stream_id=0x1234567, promised_stream=0x7654321, header_block_fragment='foobar') assert_equal( f.to_bytes().encode('hex'), '00000a05000123456707654321666f6f626172') f = PushPromiseFrame( length=14, flags=HeadersFrame.FLAG_PADDED, stream_id=0x1234567, promised_stream=0x7654321, header_block_fragment='foobar', pad_length=3) assert_equal( f.to_bytes().encode('hex'), '00000e0508012345670307654321666f6f626172000000') f = PushPromiseFrame( length=4, flags=Frame.FLAG_NO_FLAGS, stream_id=0x0, promised_stream=0x1234567) tutils.raises(ValueError, f.to_bytes) f = PushPromiseFrame( length=4, flags=Frame.FLAG_NO_FLAGS, stream_id=0x1234567, promised_stream=0x0) tutils.raises(ValueError, f.to_bytes)
def test_too_large_frames(): f = DataFrame( length=9000, flags=Frame.FLAG_END_STREAM, stream_id=0x1234567, payload='foobar' * 3000) tutils.raises(HttpSyntaxException, f.to_bytes)
def test_options(): o = TO(two="three") assert o.keys() == set(["one", "two"]) assert o.one is None assert o.two == "three" o.one = "one" assert o.one == "one" with tutils.raises(TypeError): TO(nonexistent = "value") with tutils.raises("no such option"): o.nonexistent = "value" with tutils.raises("no such option"): o.update(nonexistent = "value") rec = [] def sub(opts, updated): rec.append(copy.copy(opts)) o.changed.connect(sub) o.one = "ninety" assert len(rec) == 1 assert rec[-1].one == "ninety" o.update(one="oink") assert len(rec) == 2 assert rec[-1].one == "oink"
def test_reader_read_error(self): s = cStringIO.StringIO("foobar\nfoobar") s = tcp.Reader(s) o = mock.MagicMock() o.read = mock.MagicMock(side_effect=socket.error) s.o = o tutils.raises(tcp.NetLibDisconnect, s.read, 10)
def test_ignore(self): spec = '304:h"Alternate-Protocol"="mitmproxy-will-remove-this"' n = self.pathod(spec) self._ignore_on() i = self.pathod(spec) i2 = self.pathod(spec) self._ignore_off() assert i.status_code == i2.status_code == n.status_code == 304 assert "Alternate-Protocol" in i.headers assert "Alternate-Protocol" in i2.headers assert "Alternate-Protocol" not in n.headers # Test that we get the original SSL cert if self.ssl: i_cert = SSLCert(i.sslinfo.certchain[0]) i2_cert = SSLCert(i2.sslinfo.certchain[0]) n_cert = SSLCert(n.sslinfo.certchain[0]) assert i_cert == i2_cert assert i_cert != n_cert # Test Non-HTTP traffic spec = "200:i0,@100:d0" # this results in just 100 random bytes # mitmproxy responds with bad gateway assert self.pathod(spec).status_code == 502 self._ignore_on() tutils.raises( "invalid server response", self.pathod, spec) # pathoc tries to parse answer as HTTP self._ignore_off()
def test_bidi(): b = utils.BiDi(a=1, b=2) assert b.a == 1 assert b.get_name(1) == "a" assert b.get_name(5) is None tutils.raises(AttributeError, getattr, b, "c") tutils.raises(ValueError, utils.BiDi, one=1, two=1)
def test_writer_flush_error(self): s = cStringIO.StringIO() s = tcp.Writer(s) o = mock.MagicMock() o.flush = mock.MagicMock(side_effect=socket.error) s.o = o tutils.raises(tcp.NetLibDisconnect, s.flush)
def test_goaway_frame_to_bytes(): f = GoAwayFrame( length=8, flags=Frame.FLAG_NO_FLAGS, stream_id=0x0, last_stream=0x1234567, error_code=0x87654321, data=b'') assert_equal( f.to_bytes().encode('hex'), '0000080700000000000123456787654321') f = GoAwayFrame( length=14, flags=Frame.FLAG_NO_FLAGS, stream_id=0x0, last_stream=0x1234567, error_code=0x87654321, data=b'foobar') assert_equal( f.to_bytes().encode('hex'), '00000e0700000000000123456787654321666f6f626172') f = GoAwayFrame( length=8, flags=Frame.FLAG_NO_FLAGS, stream_id=0x1234567, last_stream=0x1234567, error_code=0x87654321) tutils.raises(ValueError, f.to_bytes)
def test_read_chunked(): req = treq(content=None) req.headers["Transfer-Encoding"] = "chunked" data = b"1\r\na\r\n0\r\n" with raises(HttpSyntaxException): b"".join(_read_chunked(BytesIO(data))) data = b"1\r\na\r\n0\r\n\r\n" assert b"".join(_read_chunked(BytesIO(data))) == b"a" data = b"\r\n\r\n1\r\na\r\n1\r\nb\r\n0\r\n\r\n" assert b"".join(_read_chunked(BytesIO(data))) == b"ab" data = b"\r\n" with raises("closed prematurely"): b"".join(_read_chunked(BytesIO(data))) data = b"1\r\nfoo" with raises("malformed chunked body"): b"".join(_read_chunked(BytesIO(data))) data = b"foo\r\nfoo" with raises(HttpSyntaxException): b"".join(_read_chunked(BytesIO(data))) data = b"5\r\naaaaa\r\n0\r\n\r\n" with raises("too large"): b"".join(_read_chunked(BytesIO(data), limit=2))
def test_always_bytes(): assert strutils.always_bytes(bytes(bytearray(range(256)))) == bytes(bytearray(range(256))) assert strutils.always_bytes("foo") == b"foo" with tutils.raises(ValueError): strutils.always_bytes(u"\u2605", "ascii") with tutils.raises(TypeError): strutils.always_bytes(42, "ascii")
def test_reader_read_error(self): s = BytesIO(b"foobar\nfoobar") s = tcp.Reader(s) o = mock.MagicMock() o.read = mock.MagicMock(side_effect=socket.error) s.o = o tutils.raises(TcpDisconnect, s.read, 10)
def test_clientcert_err(self): c = tcp.TCPClient(("127.0.0.1", self.port)) c.connect() tutils.raises( TlsException, c.convert_to_ssl, cert=tutils.test_data.path("data/clientcert/make") )
def test_read(self): with tutils.tmpdir() as t: p = os.path.join(t, "read") self._flowfile(p) assert "GET" in self._dummy_cycle(0, None, "", flow_detail=1, rfile=p) tutils.raises(dump.DumpError, self._dummy_cycle, 0, None, "", verbosity=1, rfile="/nonexistent") tutils.raises(dump.DumpError, self._dummy_cycle, 0, None, "", verbosity=1, rfile="test_dump.py")
def test_echo(self): c = tcp.TCPClient(("127.0.0.1", self.port)) c.connect() tutils.raises( "cipher specification", c.convert_to_ssl, sni=b"foo.com", cipher_list="bogus")
def test_getitem(self): headers = Headers(Host="example.com") assert headers["Host"] == "example.com" assert headers["host"] == "example.com" tutils.raises(KeyError, headers.__getitem__, "Accept") headers = self._2host() assert headers["Host"] == "example.com, example.org"
def test_invalid_headers(self): data = """ HTTP/1.1 200 OK \tContent-Length: 3 foo """ tutils.raises("invalid headers", self.tst, data, "GET", None)
def test_echo(self): c = tcp.TCPClient(("127.0.0.1", self.port)) c.connect() c.convert_to_ssl() # Exercise SSL.SysCallError c.rfile.read(10) c.close() tutils.raises(TcpDisconnect, c.wfile.write, b"foo")
def test_echo(self): c = tcp.TCPClient(("127.0.0.1", self.port)) c.connect() c.convert_to_ssl() # Excercise SSL.ZeroReturnError c.rfile.read(10) c.close() tutils.raises(TcpDisconnect, c.wfile.write, b"foo") tutils.raises(queue.Empty, self.q.get_nowait)
def test_script(self): ret = self._dummy_cycle(1, None, "", scripts=[tutils.test_data.path("scripts/all.py")], verbosity=1) assert "XCLIENTCONNECT" in ret assert "XSERVERCONNECT" in ret assert "XREQUEST" in ret assert "XRESPONSE" in ret assert "XCLIENTDISCONNECT" in ret tutils.raises(dump.DumpError, self._dummy_cycle, 1, None, "", scripts=["nonexistent"]) tutils.raises(dump.DumpError, self._dummy_cycle, 1, None, "", scripts=["starterr.py"])
def test_parse_size(): assert human.parse_size("0") == 0 assert human.parse_size("0b") == 0 assert human.parse_size("1") == 1 assert human.parse_size("1k") == 1024 assert human.parse_size("1m") == 1024**2 assert human.parse_size("1g") == 1024**3 tutils.raises(ValueError, human.parse_size, "1f") tutils.raises(ValueError, human.parse_size, "ak")
def test_write_err(self): tutils.raises( dump.DumpError, self._dummy_cycle, 1, None, "", outfile = ("nonexistentdir/foo", "wb") )
def test_modify(self): md = TImmutableMultiDict() with tutils.raises(TypeError): md["foo"] = "bar" with tutils.raises(TypeError): del md["foo"] with tutils.raises(TypeError): md.add("foo", "bar")
def test_parse_authority_form(): assert _parse_authority_form(b"foo:42") == (b"foo", 42) with raises(HttpSyntaxException): _parse_authority_form(b"foo") with raises(HttpSyntaxException): _parse_authority_form(b"foo:bar") with raises(HttpSyntaxException): _parse_authority_form(b"foo:99999999") with raises(HttpSyntaxException): _parse_authority_form(b"f\x00oo:80")
def test_add_cv(self): class TestContentView(cv.View): name = "test" prompt = ("t", "test") tcv = TestContentView() cv.add(tcv) # repeated addition causes exception tutils.raises(ContentViewException, cv.add, tcv)
def test_check_http_version(): _check_http_version(b"HTTP/0.9") _check_http_version(b"HTTP/1.0") _check_http_version(b"HTTP/1.1") _check_http_version(b"HTTP/2.0") with raises(HttpSyntaxException): _check_http_version(b"WTF/1.0") with raises(HttpSyntaxException): _check_http_version(b"HTTP/1.10") with raises(HttpSyntaxException): _check_http_version(b"HTTP/1.b")
def test_connect_fail(self): to = ("foobar", 80) c = pathoc.Pathoc(("127.0.0.1", self.d.port), fp=None) c.rfile, c.wfile = StringIO(), StringIO() with raises("connect failed"): c.http_connect(to) c.rfile = StringIO("HTTP/1.1 500 OK\r\n") with raises("connect failed"): c.http_connect(to) c.rfile = StringIO("HTTP/1.1 200 OK\r\n") c.http_connect(to)
def test_absolute_form_in(self): tutils.raises( "Bad HTTP request line", self.tst, "GET oops-no-protocol.com HTTP/1.1" ) v = self.tst("GET http://address:22/ HTTP/1.1") assert v.form_in == "absolute" assert v.port == 22 assert v.host == "address" assert v.scheme == "http"
def test_connect(self): tutils.raises( "Bad HTTP request line", self.tst, "CONNECT oops-no-port.com HTTP/1.1" ) v = self.tst("CONNECT foo.com:443 HTTP/1.1") assert v.form_in == "authority" assert v.method == "CONNECT" assert v.port == 443 assert v.host == "foo.com"
def test_headers_frame_to_bytes(): f = HeadersFrame( length=6, flags=(Frame.FLAG_NO_FLAGS), stream_id=0x1234567, header_block_fragment='668594e75e31d9'.decode('hex')) assert f.to_bytes().encode('hex') == '000007010001234567668594e75e31d9' f = HeadersFrame( length=10, flags=(HeadersFrame.FLAG_PADDED), stream_id=0x1234567, header_block_fragment='668594e75e31d9'.decode('hex'), pad_length=3) assert f.to_bytes().encode('hex') == '00000b01080123456703668594e75e31d9000000' f = HeadersFrame( length=10, flags=(HeadersFrame.FLAG_PRIORITY), stream_id=0x1234567, header_block_fragment='668594e75e31d9'.decode('hex'), exclusive=True, stream_dependency=0x7654321, weight=42) assert f.to_bytes().encode('hex') == '00000c012001234567876543212a668594e75e31d9' f = HeadersFrame( length=14, flags=(HeadersFrame.FLAG_PADDED | HeadersFrame.FLAG_PRIORITY), stream_id=0x1234567, header_block_fragment='668594e75e31d9'.decode('hex'), pad_length=3, exclusive=True, stream_dependency=0x7654321, weight=42) assert f.to_bytes().encode('hex') == '00001001280123456703876543212a668594e75e31d9000000' f = HeadersFrame( length=14, flags=(HeadersFrame.FLAG_PADDED | HeadersFrame.FLAG_PRIORITY), stream_id=0x1234567, header_block_fragment='668594e75e31d9'.decode('hex'), pad_length=3, exclusive=False, stream_dependency=0x7654321, weight=42) assert f.to_bytes().encode('hex') == '00001001280123456703076543212a668594e75e31d9000000' f = HeadersFrame( length=6, flags=Frame.FLAG_NO_FLAGS, stream_id=0x0, header_block_fragment='668594e75e31d9'.decode('hex')) tutils.raises(ValueError, f.to_bytes)
def test_headers_odict(self): tutils.raises(AssertionError, semantics.Response, (1, 1), 200, headers='foobar', ) resp = semantics.Response( (1, 1), 200, ) assert isinstance(resp.headers, odict.ODictCaseless)
def test_perform_server_connection_preface(self): c = tcp.TCPClient(("127.0.0.1", self.port)) c.connect() protocol = HTTP2Protocol(c) assert not protocol.connection_preface_performed protocol.perform_server_connection_preface() assert protocol.connection_preface_performed tutils.raises(TcpDisconnect, protocol.perform_server_connection_preface, force=True)
def test_rst_stream_frame_to_bytes(): f = RstStreamFrame( length=4, flags=Frame.FLAG_NO_FLAGS, stream_id=0x1234567, error_code=0x7654321) assert_equal(f.to_bytes().encode('hex'), '00000403000123456707654321') f = RstStreamFrame( length=4, flags=Frame.FLAG_NO_FLAGS, stream_id=0x0) tutils.raises(ValueError, f.to_bytes)
def test_headers(self): tutils.raises( AssertionError, semantics.Response, (1, 1), 200, headers='foobar', ) resp = semantics.Response( (1, 1), 200, ) assert isinstance(resp.headers, http.Headers)
def test_continuation_frame_to_bytes(): f = ContinuationFrame( length=6, flags=ContinuationFrame.FLAG_END_HEADERS, stream_id=0x1234567, header_block_fragment='foobar') assert_equal(f.to_bytes().encode('hex'), '000006090401234567666f6f626172') f = ContinuationFrame( length=6, flags=ContinuationFrame.FLAG_END_HEADERS, stream_id=0x0, header_block_fragment='foobar') tutils.raises(ValueError, f.to_bytes)
def test_escaped_str_to_bytes(): assert strutils.escaped_str_to_bytes("foo") == b"foo" assert strutils.escaped_str_to_bytes("\x08") == b"\b" assert strutils.escaped_str_to_bytes("&!?=\\\\)") == br"&!?=\)" assert strutils.escaped_str_to_bytes(u"\\x08") == b"\b" assert strutils.escaped_str_to_bytes(u"&!?=\\\\)") == br"&!?=\)" assert strutils.escaped_str_to_bytes(u"\u00fc") == b'\xc3\xbc' if six.PY2: with tutils.raises(ValueError): strutils.escaped_str_to_bytes(42) else: with tutils.raises(ValueError): strutils.escaped_str_to_bytes(b"very byte")
def test_mode_strict_should_fail(self): c = tcp.TCPClient(("127.0.0.1", self.port)) c.connect() tutils.raises( InvalidCertificateException, c.convert_to_ssl, verify_options=SSL.VERIFY_PEER, ca_pemfile=tutils.test_data.path("data/verificationcerts/trusted.pem")) assert c.ssl_verification_error is not None # Unknown issuing certificate authority for first certificate assert c.ssl_verification_error['errno'] == 20 assert c.ssl_verification_error['depth'] == 0
def test_get_first_line(): rfile = BytesIO(b"foo\r\nbar") assert _get_first_line(rfile) == b"foo" rfile = BytesIO(b"\r\nfoo\r\nbar") assert _get_first_line(rfile) == b"foo" with raises(HttpReadDisconnect): rfile = BytesIO(b"") _get_first_line(rfile) with raises(HttpReadDisconnect): rfile = Mock() rfile.readline.side_effect = TcpDisconnect _get_first_line(rfile)
def test_setter(): o = TO(two="three") f = o.setter("two") f("xxx") assert o.two == "xxx" with tutils.raises("no such option"): o.setter("nonexistent")
def test_expected_http_body_size(): # Expect: 100-continue assert expected_http_body_size( treq(headers=Headers(expect="100-continue", content_length="42"))) == 0 # http://tools.ietf.org/html/rfc7230#section-3.3 assert expected_http_body_size( treq(method=b"HEAD"), tresp(headers=Headers(content_length="42"))) == 0 assert expected_http_body_size(treq(method=b"CONNECT"), tresp()) == 0 for code in (100, 204, 304): assert expected_http_body_size(treq(), tresp(status_code=code)) == 0 # chunked assert expected_http_body_size( treq(headers=Headers(transfer_encoding="chunked")), ) is None # explicit length for val in (b"foo", b"-7"): with raises(HttpSyntaxException): expected_http_body_size(treq(headers=Headers(content_length=val))) assert expected_http_body_size( treq(headers=Headers(content_length="42"))) == 42 # no length assert expected_http_body_size(treq(headers=Headers())) == 0 assert expected_http_body_size(treq(headers=Headers()), tresp(headers=Headers())) == -1
def test_bytes_to_escaped_str(): assert strutils.bytes_to_escaped_str(b"foo") == "foo" assert strutils.bytes_to_escaped_str(b"\b") == r"\x08" assert strutils.bytes_to_escaped_str(br"&!?=\)") == r"&!?=\\)" assert strutils.bytes_to_escaped_str(b'\xc3\xbc') == r"\xc3\xbc" assert strutils.bytes_to_escaped_str(b"'") == r"'" assert strutils.bytes_to_escaped_str(b'"') == r'"' assert strutils.bytes_to_escaped_str(b"'", escape_single_quotes=True) == r"\'" assert strutils.bytes_to_escaped_str(b'"', escape_single_quotes=True) == r'"' assert strutils.bytes_to_escaped_str(b"\r\n\t") == "\\r\\n\\t" assert strutils.bytes_to_escaped_str(b"\r\n\t", True) == "\r\n\t" assert strutils.bytes_to_escaped_str(b"\n", True) == "\n" assert strutils.bytes_to_escaped_str(b"\\n", True) == "\\ \\ n".replace(" ", "") assert strutils.bytes_to_escaped_str(b"\\\n", True) == "\\ \\ \n".replace(" ", "") assert strutils.bytes_to_escaped_str(b"\\\\n", True) == "\\ \\ \\ \\ n".replace( " ", "") with tutils.raises(ValueError): strutils.bytes_to_escaped_str(u"such unicode")
def test_ask_shutdown(self): q = queue.Queue() done = Event() done.set() channel = controller.Channel(q, done) with raises(Kill): channel.ask("test", Mock())
def test_check_alpn(self): c = tcp.TCPClient(("127.0.0.1", self.port)) c.connect() c.convert_to_ssl(alpn_protos=[b'h2']) protocol = HTTP2Protocol(c) with raises(NotImplementedError): protocol.check_alpn()
def test_deflate(): assert b"string" == encoding.decode(encoding.encode(b"string", "deflate"), "deflate") assert b"string" == encoding.decode( encoding.encode(b"string", "deflate")[2:-4], "deflate") with tutils.raises(ValueError): encoding.decode(b"bogus", "deflate")
def test_ignore(self): n = self.pathod("304") self._ignore_on() i = self.pathod("305") i2 = self.pathod("306") self._ignore_off() self.master.masterq.join() assert n.status_code == 304 assert i.status_code == 305 assert i2.status_code == 306 assert any(f.response.status_code == 304 for f in self.master.state.flows) assert not any(f.response.status_code == 305 for f in self.master.state.flows) assert not any(f.response.status_code == 306 for f in self.master.state.flows) # Test that we get the original SSL cert if self.ssl: i_cert = SSLCert(i.sslinfo.certchain[0]) i2_cert = SSLCert(i2.sslinfo.certchain[0]) n_cert = SSLCert(n.sslinfo.certchain[0]) assert i_cert == i2_cert assert i_cert != n_cert # Test Non-HTTP traffic spec = "200:i0,@100:d0" # this results in just 100 random bytes # mitmproxy responds with bad gateway assert self.pathod(spec).status_code == 502 self._ignore_on() with raises(HttpException): self.pathod(spec) # pathoc tries to parse answer as HTTP self._ignore_off()
def test_readlog(self): s = BytesIO(b"foobar\nfoobar") s = tcp.Reader(s) assert not s.is_logging() s.start_log() assert s.is_logging() s.readline() assert s.get_log() == b"foobar\n" s.read(1) assert s.get_log() == b"foobar\nf" s.start_log() assert s.get_log() == b"" s.read(1) assert s.get_log() == b"o" s.stop_log() tutils.raises(ValueError, s.get_log)
def test_unknown_ce(self): r = tresp() r.headers["content-type"] = "text/html; charset=wtf" r.raw_content = b"foo" with tutils.raises(ValueError): assert r.text == u"foo" assert r.get_text(strict=False) == u"foo"
def test_mode_strict_should_fail(self): c = tcp.TCPClient(("127.0.0.1", self.port)) c.connect() tutils.raises( "certificate verify failed", c.convert_to_ssl, verify_options=SSL.VERIFY_PEER, ca_pemfile=tutils.test_data.path("data/verificationcerts/trusted.pem")) assert c.ssl_verification_error is not None # Untrusted self-signed certificate at second position in certificate # chain assert c.ssl_verification_error['errno'] == 19 assert c.ssl_verification_error['depth'] == 1
def test_init(self): headers = Headers() assert len(headers) == 0 headers = Headers([[b"Host", b"example.com"]]) assert len(headers) == 1 assert headers["Host"] == "example.com" headers = Headers(Host="example.com") assert len(headers) == 1 assert headers["Host"] == "example.com" headers = Headers( [[b"Host", b"invalid"]], Host="example.com" ) assert len(headers) == 1 assert headers["Host"] == "example.com" headers = Headers( [[b"Host", b"invalid"], [b"Accept", b"text/plain"]], Host="example.com" ) assert len(headers) == 2 assert headers["Host"] == "example.com" assert headers["Accept"] == "text/plain" with raises(TypeError): Headers([[b"Host", u"not-bytes"]])
def test_should_fail_without_sni(self): c = tcp.TCPClient(("127.0.0.1", self.port)) with c.connect(): with tutils.raises(TlsException): c.convert_to_ssl( verify_options=SSL.VERIFY_PEER, ca_pemfile=tutils.test_data.path( "data/verificationcerts/trusted-root.crt"))
def test_cannot_decode(self): r = tresp() r.encode("gzip") r.raw_content = b"foo" with tutils.raises(ValueError): assert r.content assert r.headers["content-encoding"] assert r.get_content(strict=False) == b"foo" with tutils.raises(ValueError): r.decode() assert r.raw_content == b"foo" assert "content-encoding" in r.headers r.decode(strict=False) assert r.content == b"foo" assert "content-encoding" not in r.headers
def test_cannot_decode(self): r = tresp() r.headers["content-type"] = "text/html; charset=utf8" r.raw_content = b"\xFF" with tutils.raises(ValueError): assert r.text assert r.get_text(strict=False) == '\udcff'