mirror of
https://github.com/3proxy/3proxy.git
synced 2026-11-22 23:59:41 +08:00
Add tests
This commit is contained in:
1 parent
7f430ccc79
commit
73fbf9d262
16 files changed
+1304
-10
No files matched your search
@@ -0,0 +1,69 @@
|
||||
"""The admin interface, now a set of handlers on the HTTP server."""
|
||||
|
||||
|
||||
def run(t):
|
||||
adm = t.free_port()
|
||||
lim = t.free_port()
|
||||
t.start("admin", f"""
|
||||
log
|
||||
auth iponly
|
||||
allow *
|
||||
countin 1 D 100 * * *
|
||||
countin 2 D 200 * * *
|
||||
admin -p{adm}
|
||||
|
||||
flush
|
||||
auth iponly
|
||||
allow *
|
||||
admin -p{lim} -s1
|
||||
""", ports=[adm, lim])
|
||||
|
||||
url = f"http://127.0.0.1:{adm}"
|
||||
|
||||
# --- the predefined pages -----------------------------------------
|
||||
t.eq(200, t.http(url + "/").status, "the main page")
|
||||
t.eq(200, t.http(url + "/C").status, "the counters page")
|
||||
t.eq(200, t.http(url + "/R").status, "the reload page")
|
||||
t.eq(200, t.http(url + "/S").status, "the services page")
|
||||
|
||||
counters = t.http(url + "/C")
|
||||
t.contains(counters, "countin", "the counters page names the counter type")
|
||||
t.contains(counters, "<tr>", "the counters page renders a table")
|
||||
t.contains(t.http(url + "/R"), "Reload", "the reload page confirms the request")
|
||||
t.contains(t.http(url + "/S"), "<", "the services page returns markup")
|
||||
|
||||
# --- the menu no longer offers the removed config editor -----------
|
||||
main = t.http(url + "/")
|
||||
t.contains(main, "HREF='/C'", "the menu links to the counters")
|
||||
t.contains(main, "HREF='/R'", "the menu links to reload")
|
||||
t.contains(main, "HREF='/S'", "the menu links to the services")
|
||||
t.not_contains(main, "HREF='/F'",
|
||||
"the menu no longer links to the config editor")
|
||||
|
||||
# /F and /U are gone, so they fall through to the catch-all rule
|
||||
t.eq(200, t.http(url + "/F").status, "the removed /F falls through")
|
||||
t.eq(200, t.http(url + "/U").status, "the removed /U falls through")
|
||||
t.contains(t.http(url + "/F"), "configuration", "/F yields the main page")
|
||||
|
||||
# --- counter control through the glob ------------------------------
|
||||
# /C<action><number> is routed by the /C* rule, the action arriving as
|
||||
# the glob
|
||||
t.http(url + "/CD0")
|
||||
t.contains(t.http(url + "/C"), ">NO<", "a counter can be disabled")
|
||||
t.http(url + "/CS0")
|
||||
t.contains(t.http(url + "/C"), ">YES<", "a counter can be enabled again")
|
||||
|
||||
# --- limited mode ---------------------------------------------------
|
||||
limited = f"http://127.0.0.1:{lim}"
|
||||
t.eq(200, t.http(limited + "/").status, "limited mode serves the main page")
|
||||
t.eq(200, t.http(limited + "/C").status, "limited mode serves the counters")
|
||||
t.not_contains(t.http(limited + "/R"), "Reload scheduled",
|
||||
"limited mode refuses a reload")
|
||||
|
||||
# --- the writable command is gone ------------------------------------
|
||||
output = t.run_config("writable", f"""
|
||||
log
|
||||
writable
|
||||
admin -p{t.free_port()}
|
||||
""")
|
||||
t.contains(output, "Unknown command", "the writable command is rejected")
|
||||
@@ -0,0 +1,49 @@
|
||||
"""Authentication and access rules in front of the HTTP server."""
|
||||
|
||||
|
||||
def run(t):
|
||||
srv = t.free_port()
|
||||
openport = t.free_port()
|
||||
t.start("httpsrv_auth", f"""
|
||||
log
|
||||
http * /echo echo
|
||||
auth strong
|
||||
users alice:CL:secret bob:CL:hunter2
|
||||
allow alice
|
||||
httpsrv -p{srv}
|
||||
|
||||
flush
|
||||
http * /echo echo
|
||||
auth iponly
|
||||
allow *
|
||||
httpsrv -p{openport}
|
||||
""", ports=[srv, openport])
|
||||
|
||||
url = f"http://127.0.0.1:{srv}"
|
||||
|
||||
r = t.http(url + "/echo")
|
||||
t.eq(401, r.status, "no credentials gives 401")
|
||||
t.ne(None, r.header("WWW-Authenticate"),
|
||||
"the 401 carries a WWW-Authenticate header")
|
||||
|
||||
t.eq(200, t.http(url + "/echo", auth=("alice", "secret")).status,
|
||||
"valid credentials pass")
|
||||
t.eq(401, t.http(url + "/echo", auth=("alice", "wrong")).status,
|
||||
"a wrong password gives 401")
|
||||
t.eq(401, t.http(url + "/echo", auth=("nobody", "secret")).status,
|
||||
"an unknown user gives 401")
|
||||
|
||||
# bob authenticates, but no rule admits him
|
||||
t.eq(403, t.http(url + "/echo", auth=("bob", "hunter2")).status,
|
||||
"authenticated but not allowed gives 403")
|
||||
|
||||
# authentication comes before dispatch, so an unmatched URL still needs it
|
||||
t.eq(401, t.http(url + "/nosuchpath").status,
|
||||
"authentication precedes the rule lookup")
|
||||
|
||||
# the second service kept its own iponly authentication
|
||||
t.eq(200, t.http(f"http://127.0.0.1:{openport}/echo").status,
|
||||
"the open service needs no credentials")
|
||||
|
||||
t.contains(t.http(url + "/echo", auth=("alice", "secret")), "path=/echo",
|
||||
"an authenticated request is dispatched")
|
||||
@@ -0,0 +1,78 @@
|
||||
"""The built-in HTTP server: the echo and data operations."""
|
||||
|
||||
import time
|
||||
|
||||
|
||||
def run(t):
|
||||
srv = t.free_port()
|
||||
t.start("httpsrv_ops", f"""
|
||||
log
|
||||
auth iponly
|
||||
allow *
|
||||
http * /echo* echo
|
||||
http * /data data
|
||||
http * /small data size=64
|
||||
httpsrv -p{srv}
|
||||
""", ports=[srv])
|
||||
|
||||
url = f"http://127.0.0.1:{srv}"
|
||||
|
||||
# --- echo: request introspection ---------------------------------
|
||||
r = t.http(url + "/echo?a=1")
|
||||
t.eq(200, r.status, "echo answers 200")
|
||||
t.contains(r, "method=GET", "echo reports the method")
|
||||
t.contains(r, "path=/echo", "echo reports the path")
|
||||
t.contains(r, "query=a=1", "echo reports the query")
|
||||
t.contains(r, "peer.addr=127.0.0.1", "echo reports the peer address")
|
||||
t.contains(r, f"host=127.0.0.1:{srv}", "echo reports the Host header")
|
||||
|
||||
# the glob is the wildcard-matched tail, which is how admin routes its
|
||||
# sub-pages
|
||||
r = t.http(url + "/echoXYZ")
|
||||
t.contains(r, "glob=XYZ", "echo reports the glob text")
|
||||
t.contains(r, "glob.len=3", "echo reports the glob length")
|
||||
|
||||
# --- data: generated payload -------------------------------------
|
||||
t.eq(1000, t.http(url + "/data?size=1000").length, "data honours size")
|
||||
t.eq(0, t.http(url + "/data?size=0").length, "data size=0 sends an empty body")
|
||||
t.eq(64, t.http(url + "/small").length, "data takes its size from the rule")
|
||||
t.eq(1000, t.http(url + "/small?size=1000").length,
|
||||
"the query overrides the rule parameters")
|
||||
|
||||
# a size past one block exercises the send loop
|
||||
t.eq(70000, t.http(url + "/data?size=70000").length,
|
||||
"data spans several blocks")
|
||||
t.eq(70000, t.http(url + "/data?size=70000&block=1024").length,
|
||||
"data honours the block size")
|
||||
|
||||
# --- status and framing ------------------------------------------
|
||||
t.eq(404, t.http(url + "/data?size=10&status=404").status,
|
||||
"data honours the status")
|
||||
t.eq(503, t.http(url + "/data?size=10&status=503").status,
|
||||
"data returns 503 when asked")
|
||||
t.eq(200, t.http(url + "/data?size=10&status=99").status,
|
||||
"an out-of-range status falls back to 200")
|
||||
|
||||
r = t.http(url + "/data?size=100")
|
||||
t.eq("100", r.header("Content-Length"), "an identity reply sets Content-Length")
|
||||
|
||||
r = t.http(url + "/data?size=100&chunked=1")
|
||||
t.eq("chunked", r.header("Transfer-Encoding"),
|
||||
"a chunked reply sets Transfer-Encoding")
|
||||
t.eq(None, r.header("Content-Length"),
|
||||
"a chunked reply omits Content-Length")
|
||||
t.eq(100, r.length, "a chunked body decodes to the size asked for")
|
||||
t.eq(70000, t.http(url + "/data?size=70000&chunked=1").length,
|
||||
"a chunked body spans several blocks")
|
||||
|
||||
# --- delay --------------------------------------------------------
|
||||
start = time.time()
|
||||
t.http(url + "/data?size=4096&block=1024&delay=100")
|
||||
elapsed = time.time() - start
|
||||
if elapsed >= 0.3:
|
||||
t.ok("delay slows the transfer")
|
||||
else:
|
||||
t.fail("delay slows the transfer", ">=0.3s", f"{elapsed:.2f}s")
|
||||
|
||||
# --- unmatched ----------------------------------------------------
|
||||
t.eq(404, t.http(url + "/nosuchthing").status, "an unmatched URL gives 404")
|
||||
@@ -0,0 +1,64 @@
|
||||
"""Request parsing: decoding, path safety, malformed and oversized input.
|
||||
|
||||
These go over a raw socket, because a well-behaved client would normalise
|
||||
most of them away before they ever reached the server.
|
||||
"""
|
||||
|
||||
|
||||
def run(t):
|
||||
srv = t.free_port()
|
||||
t.start("httpsrv_parsing", f"""
|
||||
log
|
||||
auth iponly
|
||||
allow *
|
||||
http * /echo* echo
|
||||
http * /safe/* echo
|
||||
httpsrv -p{srv}
|
||||
""", ports=[srv])
|
||||
|
||||
def request(path, host="t", extra=""):
|
||||
return t.raw(srv, f"GET {path} HTTP/1.0\r\nHost: {host}\r\n{extra}\r\n")
|
||||
|
||||
# --- percent-decoding ---------------------------------------------
|
||||
reply = request("/%65cho")
|
||||
t.contains(reply, "200 OK", "a percent-encoded path is decoded before matching")
|
||||
t.contains(reply, "path=/echo", "the decoded path is what gets reported")
|
||||
t.contains(request("/echo%20space"), "glob= space",
|
||||
"an encoded space decodes into the glob")
|
||||
|
||||
# --- traversal -----------------------------------------------------
|
||||
for path in ("/safe/../etc/passwd", "/safe/%2e%2e/etc", "/safe/..%2fetc",
|
||||
"/echo/../../x"):
|
||||
t.not_contains(request(path), "200 OK", f"traversal is refused: {path}")
|
||||
|
||||
t.contains(request("/safe/./ok"), "200 OK",
|
||||
"a harmless dot segment is still served")
|
||||
|
||||
# --- injection ------------------------------------------------------
|
||||
t.not_contains(request("/echo%0d%0aInjected:%20yes"), "Injected: yes",
|
||||
"an encoded CRLF cannot inject a header")
|
||||
t.not_contains(request("/echo%00cut"), "200 OK", "an encoded NUL is refused")
|
||||
|
||||
# a header value cannot smuggle a newline into the echoed output
|
||||
reply = request("/echo", host="evil", extra="X-Injected: yes\r\n")
|
||||
t.not_contains(reply, "host=evil\nX-Injected",
|
||||
"header values stay in their own fields")
|
||||
|
||||
# --- malformed ------------------------------------------------------
|
||||
t.not_contains(t.raw(srv, "GARBAGE\r\n\r\n"), "200 OK",
|
||||
"a malformed request line is not served")
|
||||
t.not_contains(t.raw(srv, "GET\r\n\r\n"), "200 OK",
|
||||
"a request line with no URL is not served")
|
||||
|
||||
# an over-long path has to be refused rather than quietly truncated to
|
||||
# something shorter that might match another rule
|
||||
t.not_contains(request("/echo" + "a" * 9000), "200 OK",
|
||||
"an over-long path is refused, not truncated")
|
||||
|
||||
# --- methods --------------------------------------------------------
|
||||
url = f"http://127.0.0.1:{srv}"
|
||||
t.eq(200, t.http(url + "/echo", method="HEAD").status, "HEAD is accepted")
|
||||
r = t.http(url + "/echo", method="POST", body="payload=1",
|
||||
headers={"Content-Type": "application/x-www-form-urlencoded"})
|
||||
t.contains(r, "method=POST", "POST reaches the handler")
|
||||
t.contains(r, "content.length=9", "the POST content length is parsed")
|
||||
@@ -0,0 +1,69 @@
|
||||
"""Rule dispatch: host and URL patterns, and per-service rule sets."""
|
||||
|
||||
|
||||
def run(t):
|
||||
srv = t.free_port()
|
||||
srv2 = t.free_port()
|
||||
t.start("httpsrv_rules", f"""
|
||||
log
|
||||
auth iponly
|
||||
allow *
|
||||
http * /exact echo
|
||||
http * /pre* echo
|
||||
http * *.suffix echo
|
||||
http * *mid* echo
|
||||
http host.example.com /byhost echo
|
||||
http *.wild.example.com /bywild echo
|
||||
http * /only-first echo
|
||||
httpsrv -p{srv}
|
||||
|
||||
flush
|
||||
auth iponly
|
||||
allow *
|
||||
http * /only-second echo
|
||||
httpsrv -p{srv2}
|
||||
""", ports=[srv, srv2])
|
||||
|
||||
url = f"http://127.0.0.1:{srv}"
|
||||
|
||||
# --- URL patterns -------------------------------------------------
|
||||
t.eq(200, t.http(url + "/exact").status, "an exact URL matches")
|
||||
t.eq(404, t.http(url + "/exactly").status,
|
||||
"an exact URL does not match a longer path")
|
||||
t.eq(200, t.http(url + "/pre").status, "a prefix matches the bare prefix")
|
||||
t.eq(200, t.http(url + "/pretty/deep").status,
|
||||
"a prefix matches a longer path")
|
||||
t.eq(200, t.http(url + "/any.suffix").status, "a suffix matches")
|
||||
t.eq(404, t.http(url + "/any.suffixx").status,
|
||||
"a suffix is anchored at the end")
|
||||
t.eq(200, t.http(url + "/xxmidxx").status, "a substring matches")
|
||||
t.eq(404, t.http(url + "/nomatch").status, "an unmatched URL gives 404")
|
||||
|
||||
# --- host patterns ------------------------------------------------
|
||||
def with_host(path, host):
|
||||
return t.http(url + path, headers={"Host": host})
|
||||
|
||||
t.eq(200, with_host("/byhost", "host.example.com").status,
|
||||
"an exact host matches")
|
||||
t.eq(404, with_host("/byhost", "other.example.com").status,
|
||||
"another host does not match")
|
||||
t.eq(200, with_host("/bywild", "a.wild.example.com").status,
|
||||
"a wildcard host matches")
|
||||
t.eq(404, with_host("/bywild", "a.other.example.com").status,
|
||||
"a wildcard host rejects another domain")
|
||||
|
||||
# the rules are ordered, and the first match wins
|
||||
t.contains(t.http(url + "/exact"), "path=/exact",
|
||||
"the first matching rule handles the request")
|
||||
|
||||
# --- per-service rule sets ----------------------------------------
|
||||
# Rules accumulate until a service starts, which takes them; later rules
|
||||
# belong to the next service only.
|
||||
t.eq(200, t.http(f"http://127.0.0.1:{srv}/only-first").status,
|
||||
"the first service has its own rules")
|
||||
t.eq(404, t.http(f"http://127.0.0.1:{srv}/only-second").status,
|
||||
"the first service does not have the later rules")
|
||||
t.eq(200, t.http(f"http://127.0.0.1:{srv2}/only-second").status,
|
||||
"the second service has its own rules")
|
||||
t.eq(404, t.http(f"http://127.0.0.1:{srv2}/only-first").status,
|
||||
"the second service does not have the earlier rules")
|
||||
@@ -0,0 +1,131 @@
|
||||
"""extport and intport: binding the local side of a connection to a range.
|
||||
|
||||
Access rules accumulate until "flush": without it an earlier "allow *"
|
||||
matches first and the rule carrying the range is never reached.
|
||||
"""
|
||||
|
||||
from harness import int_field
|
||||
|
||||
LOW = 21400
|
||||
HIGH = 21449
|
||||
ILOW = 21500
|
||||
IHIGH = 21549
|
||||
|
||||
|
||||
def run(t):
|
||||
srv = t.free_port()
|
||||
prx = t.free_port()
|
||||
sks = t.free_port()
|
||||
meth = t.free_port()
|
||||
|
||||
t.start("parent_ports", f"""
|
||||
log
|
||||
auth iponly
|
||||
allow *
|
||||
http * /echo* echo
|
||||
httpsrv -p{srv}
|
||||
|
||||
# every outgoing connection binds inside the range
|
||||
flush
|
||||
auth iponly
|
||||
allow *
|
||||
parent 1000 extport 0.0.0.0 {LOW}-{HIGH}
|
||||
proxy -p{prx}
|
||||
|
||||
# the range applies only to CONNECT: an HTTP proxy CONNECT is
|
||||
# HTTP_CONNECT, the bare CONNECT operation being the SOCKS one
|
||||
flush
|
||||
auth iponly
|
||||
allow * * * * HTTP_CONNECT
|
||||
parent 1000 extport 0.0.0.0 {LOW}-{HIGH}
|
||||
allow *
|
||||
proxy -p{meth}
|
||||
|
||||
# socks, for the same setting on another service
|
||||
flush
|
||||
auth iponly
|
||||
allow *
|
||||
parent 1000 extport 0.0.0.0 {LOW}-{HIGH}
|
||||
socks -p{sks}
|
||||
""", ports=[srv, prx, sks, meth])
|
||||
|
||||
origin = f"http://127.0.0.1:{srv}"
|
||||
proxy = f"127.0.0.1:{prx}"
|
||||
|
||||
# --- extport ---------------------------------------------------------
|
||||
# the origin reports the source port it actually saw
|
||||
port = int_field(t.http(origin + "/echo", proxy=proxy), "peer.port")
|
||||
t.in_range(port, LOW, HIGH, "the outgoing connection binds inside the range")
|
||||
|
||||
seen = []
|
||||
for _ in range(5):
|
||||
seen.append(int_field(t.http(origin + "/echo", proxy=proxy), "peer.port"))
|
||||
outside = [p for p in seen if p is None or not LOW <= p <= HIGH]
|
||||
t.eq([], outside, "repeated connections all bind inside the range")
|
||||
|
||||
port = int_field(t.socks_http(f"127.0.0.1:{sks}", origin + "/echo"),
|
||||
"peer.port")
|
||||
t.in_range(port, LOW, HIGH,
|
||||
"socks binds the outgoing connection inside the range")
|
||||
|
||||
# --- per-method scoping ------------------------------------------------
|
||||
method_proxy = f"127.0.0.1:{meth}"
|
||||
port = int_field(t.http(origin + "/echo", proxy=method_proxy, tunnel=True),
|
||||
"peer.port")
|
||||
t.in_range(port, LOW, HIGH, "CONNECT uses the range its rule sets")
|
||||
|
||||
# a plain GET matches the later rule, which sets no range
|
||||
port = int_field(t.http(origin + "/echo", proxy=method_proxy), "peer.port")
|
||||
t.not_in_range(port, LOW, HIGH,
|
||||
"a method outside that rule keeps an ephemeral port")
|
||||
|
||||
# --- intport -----------------------------------------------------------
|
||||
# A UDP association allocates its socket after the destination is known,
|
||||
# so the range has to be applied when the rule matches rather than when
|
||||
# the chain is walked.
|
||||
udps = t.free_port()
|
||||
t.start("parent_intport", f"""
|
||||
log
|
||||
flush
|
||||
auth iponly
|
||||
allow *
|
||||
parent 1000 intport 0.0.0.0 {ILOW}-{IHIGH}
|
||||
socks -p{udps}
|
||||
""", ports=[udps])
|
||||
t.in_range(t.socks_udp_associate(udps), ILOW, IHIGH,
|
||||
"UDP ASSOCIATE binds inside the internal range")
|
||||
|
||||
# without a range the association still works, on an ephemeral port
|
||||
udps2 = t.free_port()
|
||||
t.start("parent_intport_none", f"""
|
||||
log
|
||||
flush
|
||||
auth iponly
|
||||
allow *
|
||||
socks -p{udps2}
|
||||
""", ports=[udps2])
|
||||
t.ne(None, t.socks_udp_associate(udps2),
|
||||
"UDP ASSOCIATE works without a range")
|
||||
|
||||
# --- configuration errors ------------------------------------------------
|
||||
dead = t.free_port()
|
||||
t.contains(t.run_config("badaddr", f"""
|
||||
log
|
||||
allow *
|
||||
parent 1000 extport 127.0.0.1 {LOW}-{HIGH}
|
||||
proxy -p{dead}
|
||||
"""), "requires 0.0.0.0", "a non-zero address with extport is rejected")
|
||||
|
||||
t.contains(t.run_config("badrange", f"""
|
||||
log
|
||||
allow *
|
||||
parent 1000 extport 0.0.0.0 notaport
|
||||
proxy -p{dead}
|
||||
"""), "bad port range", "a malformed range is rejected")
|
||||
|
||||
t.contains(t.run_config("badorder", f"""
|
||||
log
|
||||
allow *
|
||||
parent 1000 extport 0.0.0.0 {HIGH}-{LOW}
|
||||
proxy -p{dead}
|
||||
"""), "bad port range", "a reversed range is rejected")
|
||||
@@ -0,0 +1,108 @@
|
||||
"""The HTTP proxy, with the built-in server as the origin.
|
||||
|
||||
Access rules accumulate until "flush", so each service section here starts
|
||||
from a clean list.
|
||||
"""
|
||||
|
||||
|
||||
def run(t):
|
||||
srv = t.free_port()
|
||||
other = t.free_port()
|
||||
prx = t.free_port()
|
||||
deny = t.free_port()
|
||||
auth = t.free_port()
|
||||
|
||||
t.start("proxy_http", f"""
|
||||
log
|
||||
auth iponly
|
||||
allow *
|
||||
http * /echo* echo
|
||||
http * /data data
|
||||
httpsrv -p{srv}
|
||||
|
||||
# a second origin, used as a destination the rules must keep out
|
||||
flush
|
||||
auth iponly
|
||||
allow *
|
||||
http * /echo* echo
|
||||
httpsrv -p{other}
|
||||
|
||||
# an open proxy
|
||||
flush
|
||||
auth iponly
|
||||
allow *
|
||||
proxy -p{prx}
|
||||
|
||||
# only the first origin is reachable
|
||||
flush
|
||||
auth iponly
|
||||
allow * * * {srv}
|
||||
proxy -p{deny}
|
||||
|
||||
# credentials required
|
||||
flush
|
||||
auth strong
|
||||
users alice:CL:secret
|
||||
allow alice
|
||||
proxy -p{auth}
|
||||
""", ports=[srv, other, prx, deny, auth])
|
||||
|
||||
origin = f"http://127.0.0.1:{srv}"
|
||||
second = f"http://127.0.0.1:{other}"
|
||||
open_proxy = f"127.0.0.1:{prx}"
|
||||
|
||||
# --- plain proxying -------------------------------------------------
|
||||
r = t.http(origin + "/echo", proxy=open_proxy)
|
||||
t.eq(200, r.status, "a GET through the proxy")
|
||||
t.contains(r, "path=/echo", "the origin sees the proxied path")
|
||||
t.contains(r, "peer.addr=127.0.0.1", "the origin sees the proxy as the peer")
|
||||
|
||||
t.eq(10000, t.http(origin + "/data?size=10000", proxy=open_proxy).length,
|
||||
"a sized body survives proxying")
|
||||
t.eq(10000,
|
||||
t.http(origin + "/data?size=10000&chunked=1", proxy=open_proxy).length,
|
||||
"a chunked body survives proxying")
|
||||
t.eq(503, t.http(origin + "/data?size=5&status=503", proxy=open_proxy).status,
|
||||
"the origin status is relayed")
|
||||
|
||||
# --- POST and keep-alive ---------------------------------------------
|
||||
r = t.http(origin + "/echo", proxy=open_proxy, method="POST", body="x=1")
|
||||
t.contains(r, "method=POST", "POST is proxied")
|
||||
|
||||
# two requests on one connection, which may carry different methods
|
||||
conn = t.connection("127.0.0.1", srv, proxy=open_proxy)
|
||||
try:
|
||||
first = t.http(origin + "/echo", proxy=open_proxy, method="POST",
|
||||
body="x=1", conn=conn)
|
||||
second_reply = t.http(origin + "/echo", proxy=open_proxy, conn=conn)
|
||||
t.eq((200, 200), (first.status, second_reply.status),
|
||||
"two requests on one proxied connection")
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
# --- CONNECT ----------------------------------------------------------
|
||||
t.eq(200, t.http(origin + "/echo", proxy=open_proxy, tunnel=True).status,
|
||||
"CONNECT tunnels to the origin")
|
||||
|
||||
# --- access control ----------------------------------------------------
|
||||
denying = f"127.0.0.1:{deny}"
|
||||
t.eq(200, t.http(origin + "/echo", proxy=denying).status,
|
||||
"the permitted destination is reachable")
|
||||
t.ne(200, t.http(second + "/echo", proxy=denying).status,
|
||||
"a destination outside the rules is refused")
|
||||
t.ne(200, t.http(second + "/echo", proxy=denying, tunnel=True).status,
|
||||
"CONNECT to a destination outside the rules is refused")
|
||||
# the open proxy still reaches it, so the refusal came from the rules
|
||||
t.eq(200, t.http(second + "/echo", proxy=open_proxy).status,
|
||||
"the same destination is reachable through the open proxy")
|
||||
|
||||
# --- proxy authentication -----------------------------------------------
|
||||
needs_auth = f"127.0.0.1:{auth}"
|
||||
t.eq(407, t.http(origin + "/echo", proxy=needs_auth).status,
|
||||
"the proxy demands credentials")
|
||||
t.eq(200, t.http(origin + "/echo", proxy=needs_auth,
|
||||
proxy_auth=("alice", "secret")).status,
|
||||
"valid proxy credentials pass")
|
||||
t.eq(407, t.http(origin + "/echo", proxy=needs_auth,
|
||||
proxy_auth=("alice", "wrong")).status,
|
||||
"wrong proxy credentials are refused")
|
||||
@@ -0,0 +1,57 @@
|
||||
"""The SOCKS proxy, reaching the built-in server."""
|
||||
|
||||
|
||||
def run(t):
|
||||
srv = t.free_port()
|
||||
sks = t.free_port()
|
||||
sauth = t.free_port()
|
||||
|
||||
t.start("socks", f"""
|
||||
log
|
||||
auth iponly
|
||||
allow *
|
||||
http * /echo* echo
|
||||
http * /data data
|
||||
httpsrv -p{srv}
|
||||
|
||||
flush
|
||||
auth iponly
|
||||
allow *
|
||||
socks -p{sks}
|
||||
|
||||
flush
|
||||
auth strong
|
||||
users alice:CL:secret
|
||||
allow alice
|
||||
socks -p{sauth}
|
||||
""", ports=[srv, sks, sauth])
|
||||
|
||||
origin = f"http://127.0.0.1:{srv}"
|
||||
plain = f"127.0.0.1:{sks}"
|
||||
guarded = f"127.0.0.1:{sauth}"
|
||||
|
||||
# --- SOCKS5 ---------------------------------------------------------
|
||||
r = t.socks_http(plain, origin + "/echo")
|
||||
t.eq(200, r.status, "a SOCKS5 connection")
|
||||
t.contains(r, "path=/echo", "the origin sees the request made over SOCKS5")
|
||||
t.eq(10000, t.socks_http(plain, origin + "/data?size=10000").length,
|
||||
"a body survives SOCKS5")
|
||||
|
||||
# resolution delegated to the proxy
|
||||
t.eq(200, t.socks_http(plain, f"http://localhost:{srv}/echo",
|
||||
remote_dns=True).status,
|
||||
"SOCKS5 resolves the hostname itself")
|
||||
|
||||
# --- SOCKS4 -----------------------------------------------------------
|
||||
t.eq(200, t.socks_http(plain, origin + "/echo", socks4=True).status,
|
||||
"a SOCKS4 connection")
|
||||
|
||||
# --- authentication ----------------------------------------------------
|
||||
t.eq(200, t.socks_http(guarded, origin + "/echo",
|
||||
auth=("alice", "secret")).status,
|
||||
"valid SOCKS5 credentials pass")
|
||||
t.ne(None, t.socks_connect(guarded, "127.0.0.1", srv,
|
||||
auth=("alice", "wrong")),
|
||||
"wrong SOCKS5 credentials are refused")
|
||||
t.ne(None, t.socks_connect(guarded, "127.0.0.1", srv),
|
||||
"SOCKS5 without credentials is refused")
|
||||
Reference in new issue
Block a user