Your scope check should parse targets, not compare strings
On an authorized engagement, the signed scope is usually a short list of CIDRs. The targets people type into tools are not: 203.0.113.0-100 copied from a client email, 10.0.0.* from someone's notes, a hostname that resol
On an authorized engagement, the signed scope is usually a short list of CIDRs. The targets people type into tools are not: 203.0.113.0-100 copied from a client email, 10.0.0.* from someone's notes, a hostname that resolved to something else last week. If "in scope" is a string comparison or a note in the report, those are exactly the inputs that slip through.
Here is the check we ended up with, in plain Python with only the standard library.
The rules
- Store scope as CIDRs and nothing else. Default to private space (RFC 1918 plus loopback); a public range is added deliberately, from the rules of engagement.
- Parse every target into a network before comparing.
- Dash ranges (
a.b.c.10-40) may only vary the last octet, and both ends must fall inside the same authorized block. A CIDR is a contiguous run of addresses, so if both ends are in it, everything between them is too. - Wildcards only at the end.
10.0.0.*is a /24;10.*.30.40is 256 scattered addresses and gets rejected. - Anything that doesn't parse is out of scope. No "probably fine".
The code
import ipaddress
DEFAULT_SCOPE = ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "127.0.0.0/8"]
def parse_target(t: str):
"""Return an ip_network, a (first, last) tuple for dash ranges, or None if ambiguous."""
t = t.strip()
if "-" in t and t.count(".") == 3 and "/" not in t:
base, _, last = t.rpartition(".")
a, _, b = last.partition("-")
try:
return (ipaddress.ip_address(f"{base}.{a}"), ipaddress.ip_address(f"{base}.{b}"))
except ValueError:
return None
if "*" in t:
octets = t.split(".")
if "*" not in octets:
return None
first = octets.index("*")
if any(o != "*" for o in octets[first:]):
return None # 10.*.30.40 is not a contiguous block
while len(octets) < 4:
octets.append("*")
fixed = octets[:first]
if not fixed:
return None
cidr = ".".join(fixed + ["0"] * (4 - first)) + f"/{8 * first}"
try:
return ipaddress.ip_network(cidr)
except ValueError:
return None
try:
return ipaddress.ip_network(t, strict=False)
except ValueError:
return None # hostnames, typos, anything else: deny
def in_scope(target: str, scope: list[str]) -> bool:
nets = [ipaddress.ip_network(r, strict=False) for r in scope]
parsed = parse_target(target)
if parsed is None:
return False
if isinstance(parsed, tuple):
lo, hi = parsed
return any(lo in n and hi in n for n in nets) # both ends in the SAME block
return any(parsed.subnet_of(n) for n in nets if n.version == parsed.version)
With a signed scope of 203.0.113.0/26 on top of the private defaults:
203.0.113.10 True
203.0.113.0-100 False # .64-.100 are outside the /26
203.0.113.0/25 False # the /25 is twice the authorized block
192.168.1.* True
10.*.30.40 False # not contiguous
example.com False # doesn't parse: deny
192.168.1.10-50 True
Where to call it
At every action, not once at the start of the engagement. Hosts get added halfway through: a new subnet shows up in a scan, someone pastes a target from chat. If the scan, the web recon and the login testing each re-check the target, a late addition can't skip the gate.
What it doesn't cover
- Hostnames. Resolve them, check every resulting address, and re-check later: DNS changes during an engagement.
- IPv6 dash ranges and wildcards. The sketch above handles IPv6 CIDRs only.
- Reading the rules of engagement. This turns "I think it was in scope" into a check; it doesn't decide what the client authorized.
This is how scope works in GRIMZ, the engagement console we build at NO-DO, where every active action also needs a human confirmation. If you handle client scopes written as hostnames or dash ranges differently, we'd like to hear how.
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.