certinspect 2.4.2__tar.gz → 2.4.3__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (32) hide show
  1. {certinspect-2.4.2/src/certinspect.egg-info → certinspect-2.4.3}/PKG-INFO +8 -3
  2. {certinspect-2.4.2 → certinspect-2.4.3}/README.md +7 -2
  3. {certinspect-2.4.2 → certinspect-2.4.3}/pyproject.toml +1 -1
  4. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/__init__.py +1 -1
  5. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/fetch.py +59 -17
  6. certinspect-2.4.3/src/certinspect/httpfetch.py +241 -0
  7. {certinspect-2.4.2 → certinspect-2.4.3/src/certinspect.egg-info}/PKG-INFO +8 -3
  8. {certinspect-2.4.2 → certinspect-2.4.3}/tests/test_fetch.py +107 -0
  9. certinspect-2.4.2/src/certinspect/httpfetch.py +0 -111
  10. {certinspect-2.4.2 → certinspect-2.4.3}/LICENSE +0 -0
  11. {certinspect-2.4.2 → certinspect-2.4.3}/setup.cfg +0 -0
  12. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/args.py +0 -0
  13. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/cli.py +0 -0
  14. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/completion.py +0 -0
  15. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/config.py +0 -0
  16. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/discover.py +0 -0
  17. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/exit_codes.py +0 -0
  18. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/formatter.py +0 -0
  19. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/models.py +0 -0
  20. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/parser.py +0 -0
  21. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/render.py +0 -0
  22. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/revocation.py +0 -0
  23. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect/state.py +0 -0
  24. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect.egg-info/SOURCES.txt +0 -0
  25. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect.egg-info/dependency_links.txt +0 -0
  26. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect.egg-info/entry_points.txt +0 -0
  27. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect.egg-info/requires.txt +0 -0
  28. {certinspect-2.4.2 → certinspect-2.4.3}/src/certinspect.egg-info/top_level.txt +0 -0
  29. {certinspect-2.4.2 → certinspect-2.4.3}/tests/test_cli.py +0 -0
  30. {certinspect-2.4.2 → certinspect-2.4.3}/tests/test_discover.py +0 -0
  31. {certinspect-2.4.2 → certinspect-2.4.3}/tests/test_formatter.py +0 -0
  32. {certinspect-2.4.2 → certinspect-2.4.3}/tests/test_parser.py +0 -0
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: certinspect
3
- Version: 2.4.2
3
+ Version: 2.4.3
4
4
  Summary: Command-line TLS certificate inspector
5
5
  Author-email: Michele Angrisano <michele.angrisano@gmail.com>
6
6
  License-Expression: MIT
@@ -349,7 +349,9 @@ is treated as `UNAVAILABLE` too, so a replayed answer cannot mask a later
349
349
  revocation. The OCSP/CRL/CA-Issuer URLs come from the certificate, so
350
350
  certinspect refuses to follow one that resolves to a loopback, link-local
351
351
  (cloud metadata) or otherwise non-routable address, and caps the download
352
- size — private/internal PKI addresses stay reachable.
352
+ size — private/internal PKI addresses stay reachable. It connects to the very
353
+ address it checked, so a DNS answer that changes in between (DNS rebinding)
354
+ cannot send the request elsewhere; through a proxy, the proxy resolves the name.
353
355
 
354
356
  When the responder is down (or the certificate has no OCSP URL at all) the CRL
355
357
  fallback can still catch a revoked certificate; the `via CRL` note shows which
@@ -756,7 +758,10 @@ The report is identical to a plain inspection; only how/where certinspect
756
758
  connects changes. Split the single `--timeout` into `--connect-timeout` and
757
759
  `--read-timeout` to fail fast on dead hosts while still allowing a slow
758
760
  handshake (requests-style), and add `--retries` to ride out transient network
759
- blips instead of reporting a false failure.
761
+ blips instead of reporting a false failure. The read timeout bounds each whole
762
+ server reply (TLS handshake, each STARTTLS reply, the proxy `CONNECT` answer),
763
+ not a single read, so a server sending one byte at a time cannot stall a run;
764
+ OCSP/CRL/CA-Issuer downloads have an overall 60-second limit.
760
765
 
761
766
  ```console
762
767
  $ certinspect example.com --connect-timeout 3 --read-timeout 10 --retries 2
@@ -323,7 +323,9 @@ is treated as `UNAVAILABLE` too, so a replayed answer cannot mask a later
323
323
  revocation. The OCSP/CRL/CA-Issuer URLs come from the certificate, so
324
324
  certinspect refuses to follow one that resolves to a loopback, link-local
325
325
  (cloud metadata) or otherwise non-routable address, and caps the download
326
- size — private/internal PKI addresses stay reachable.
326
+ size — private/internal PKI addresses stay reachable. It connects to the very
327
+ address it checked, so a DNS answer that changes in between (DNS rebinding)
328
+ cannot send the request elsewhere; through a proxy, the proxy resolves the name.
327
329
 
328
330
  When the responder is down (or the certificate has no OCSP URL at all) the CRL
329
331
  fallback can still catch a revoked certificate; the `via CRL` note shows which
@@ -730,7 +732,10 @@ The report is identical to a plain inspection; only how/where certinspect
730
732
  connects changes. Split the single `--timeout` into `--connect-timeout` and
731
733
  `--read-timeout` to fail fast on dead hosts while still allowing a slow
732
734
  handshake (requests-style), and add `--retries` to ride out transient network
733
- blips instead of reporting a false failure.
735
+ blips instead of reporting a false failure. The read timeout bounds each whole
736
+ server reply (TLS handshake, each STARTTLS reply, the proxy `CONNECT` answer),
737
+ not a single read, so a server sending one byte at a time cannot stall a run;
738
+ OCSP/CRL/CA-Issuer downloads have an overall 60-second limit.
734
739
 
735
740
  ```console
736
741
  $ certinspect example.com --connect-timeout 3 --read-timeout 10 --retries 2
@@ -1,6 +1,6 @@
1
1
  [project]
2
2
  name = "certinspect"
3
- version = "2.4.2"
3
+ version = "2.4.3"
4
4
  description = "Command-line TLS certificate inspector"
5
5
  readme = "README.md"
6
6
  requires-python = ">=3.12"
@@ -1,3 +1,3 @@
1
1
  """certinspect — command-line TLS certificate inspector."""
2
2
 
3
- __version__ = "2.4.2"
3
+ __version__ = "2.4.3"
@@ -27,11 +27,15 @@ from cryptography.x509.oid import NameOID
27
27
  STARTTLS_PORTS = {"smtp": 587, "imap": 143, "pop3": 110, "ftp": 21}
28
28
 
29
29
 
30
- def _read_connect_response(sock: socket.socket) -> bytes:
31
- """Read an HTTP CONNECT response up to the end of its header block."""
30
+ def _read_connect_response(sock: socket.socket, timeout: float) -> bytes:
31
+ """Read an HTTP CONNECT response up to the end of its header block.
32
+
33
+ The whole response must arrive within ``timeout`` seconds.
34
+ """
35
+ reader = _Deadline(sock, timeout)
32
36
  buf = bytearray()
33
37
  while b"\r\n\r\n" not in buf:
34
- chunk = sock.recv(256)
38
+ chunk = reader.recv(256)
35
39
  if not chunk:
36
40
  break
37
41
  buf += chunk
@@ -95,7 +99,7 @@ def _open_socket(
95
99
  request += f"Proxy-Authorization: Basic {token}\r\n"
96
100
  request += "\r\n"
97
101
  sock.sendall(request.encode("ascii"))
98
- status_line = _read_connect_response(sock).split(b"\r\n", 1)[0]
102
+ status_line = _read_connect_response(sock, connect_timeout).split(b"\r\n", 1)[0]
99
103
  fields = status_line.split(None, 2)
100
104
  if len(fields) < 2 or fields[1] != b"200":
101
105
  raise ValueError(
@@ -141,6 +145,28 @@ _MAX_STARTTLS_LINE_BYTES = 8192
141
145
  _MAX_STARTTLS_REPLY_LINES = 100
142
146
 
143
147
 
148
+ class _Deadline:
149
+ """A read-only view of a socket that bounds the total time of its reads.
150
+
151
+ A socket timeout applies to each ``recv`` alone, so a server sending one
152
+ byte just before it expires could keep a read loop going indefinitely.
153
+ """
154
+
155
+ def __init__(self, sock: socket.socket, timeout: float):
156
+ self._sock = sock
157
+ self._timeout = timeout
158
+ self._end = time.monotonic() + timeout
159
+
160
+ def recv(self, n: int) -> bytes:
161
+ remaining = self._end - time.monotonic()
162
+ if remaining <= 0:
163
+ raise TimeoutError(
164
+ f"server reply took longer than {self._timeout:g}s to arrive"
165
+ )
166
+ self._sock.settimeout(remaining)
167
+ return self._sock.recv(n)
168
+
169
+
144
170
  def _readline(sock: socket.socket) -> bytes:
145
171
  """Read one line (up to and including ``\\n``) from a plaintext socket.
146
172
 
@@ -179,33 +205,49 @@ def _expect(line: bytes, prefix: bytes) -> None:
179
205
  raise ValueError(f"unexpected STARTTLS reply: {line!r}")
180
206
 
181
207
 
182
- def _negotiate_starttls(sock: socket.socket, protocol: str) -> None:
208
+ def _negotiate_starttls(
209
+ sock: socket.socket, protocol: str, timeout: float | None = None
210
+ ) -> None:
183
211
  """Run the plaintext STARTTLS handshake for ``protocol`` on ``sock``.
184
212
 
185
213
  Supports the line-based protocols smtp, imap, pop3 and ftp. On return the
186
214
  socket is ready to be wrapped in TLS. Raises ValueError if the server does
187
- not agree to upgrade.
215
+ not agree to upgrade. With ``timeout``, each server reply must arrive in
216
+ full within that many seconds (TimeoutError otherwise), and the socket is
217
+ left with that timeout for the TLS handshake.
188
218
  """
219
+ try:
220
+ _run_starttls(sock, protocol, timeout)
221
+ finally:
222
+ if timeout is not None:
223
+ sock.settimeout(timeout)
224
+
225
+
226
+ def _run_starttls(sock: socket.socket, protocol: str, timeout: float | None) -> None:
227
+ def reply():
228
+ return sock if timeout is None else _Deadline(sock, timeout)
229
+
189
230
  proto = protocol.lower()
190
231
  if proto == "smtp":
191
- _expect(_read_reply(sock), b"220")
232
+ _expect(_read_reply(reply()), b"220")
192
233
  sock.sendall(b"EHLO certinspect\r\n")
193
- _expect(_read_reply(sock), b"250")
234
+ _expect(_read_reply(reply()), b"250")
194
235
  sock.sendall(b"STARTTLS\r\n")
195
- _expect(_read_reply(sock), b"220")
236
+ _expect(_read_reply(reply()), b"220")
196
237
  elif proto == "ftp":
197
- _expect(_read_reply(sock), b"220")
238
+ _expect(_read_reply(reply()), b"220")
198
239
  sock.sendall(b"AUTH TLS\r\n")
199
- _expect(_read_reply(sock), b"234")
240
+ _expect(_read_reply(reply()), b"234")
200
241
  elif proto == "pop3":
201
- _expect(_readline(sock), b"+OK")
242
+ _expect(_readline(reply()), b"+OK")
202
243
  sock.sendall(b"STLS\r\n")
203
- _expect(_readline(sock), b"+OK")
244
+ _expect(_readline(reply()), b"+OK")
204
245
  elif proto == "imap":
205
- _expect(_readline(sock), b"* OK")
246
+ _expect(_readline(reply()), b"* OK")
206
247
  sock.sendall(b"a001 STARTTLS\r\n")
248
+ response = reply()
207
249
  for _ in range(_MAX_STARTTLS_REPLY_LINES):
208
- line = _readline(sock)
250
+ line = _readline(response)
209
251
  if not line:
210
252
  raise ValueError("connection closed during STARTTLS")
211
253
  if line.startswith(b"a001 "):
@@ -256,7 +298,7 @@ def get_server_cert(
256
298
  host, port, connect_timeout, read_timeout, resolved_proxy
257
299
  ) as sock:
258
300
  if starttls:
259
- _negotiate_starttls(sock, starttls)
301
+ _negotiate_starttls(sock, starttls, read_timeout)
260
302
  with context.wrap_socket(sock, server_hostname=servername or host) as ssock:
261
303
  der = ssock.getpeercert(binary_form=True)
262
304
  cipher = ssock.cipher()
@@ -337,7 +379,7 @@ def verify_chain(
337
379
  host, port, connect_timeout, read_timeout, resolved_proxy
338
380
  ) as sock:
339
381
  if starttls:
340
- _negotiate_starttls(sock, starttls)
382
+ _negotiate_starttls(sock, starttls, read_timeout)
341
383
  with context.wrap_socket(sock, server_hostname=servername or host) as ssock:
342
384
  return True, None, _chain(ssock, "get_verified_chain")
343
385
  except ssl.SSLCertVerificationError as err:
@@ -0,0 +1,241 @@
1
+ """SSRF-guarded HTTP GET/POST for certificate- and CT-log-supplied URLs.
2
+
3
+ OCSP, CRL, CA-Issuer and Certificate Transparency URLs all come from untrusted
4
+ input, so this small client screens the target host against internal or
5
+ non-routable addresses and caps the response size. Shared by the revocation
6
+ checks and the CT-log discovery.
7
+ """
8
+
9
+ import http.client
10
+ import ipaddress
11
+ import socket
12
+ import threading
13
+ import urllib.request
14
+ from urllib.parse import urlsplit
15
+
16
+ # Cap the size of any certificate-supplied HTTP response (OCSP/CRL/CA-Issuer)
17
+ # so a malicious certificate cannot point us at an unbounded download and
18
+ # exhaust memory. Real-world CRLs stay comfortably below this.
19
+ _MAX_HTTP_RESPONSE_BYTES = 16 * 1024 * 1024
20
+
21
+ # CRL/OCSP URLs legitimately redirect once or twice (http->https, a CDN).
22
+ _MAX_REDIRECTS = 5
23
+
24
+ # The socket timeout covers one read at a time; this bounds a whole fetch
25
+ # (redirects included) against a server that sends one byte at a time.
26
+ _FETCH_DEADLINE_SECONDS = 60.0
27
+
28
+ # Sockets opened by the fetch running in this thread, closed at its deadline.
29
+ _active = threading.local()
30
+
31
+
32
+ def _is_blocked_fetch_address(
33
+ ip: ipaddress.IPv4Address | ipaddress.IPv6Address,
34
+ ) -> bool:
35
+ """Return True for addresses a certificate-supplied URL must not reach.
36
+
37
+ Loopback, link-local (which covers the cloud metadata endpoint
38
+ ``169.254.169.254``), unspecified, multicast and reserved ranges are
39
+ refused. Private RFC1918 ranges are deliberately allowed so revocation
40
+ still works behind an internal PKI.
41
+ """
42
+ return (
43
+ ip.is_loopback
44
+ or ip.is_link_local
45
+ or ip.is_unspecified
46
+ or ip.is_multicast
47
+ or ip.is_reserved
48
+ )
49
+
50
+
51
+ def _vetted_addresses(host: str, port: int | None) -> list[str]:
52
+ """Resolve ``host`` and return its IP addresses, all of them allowed.
53
+
54
+ Raises ValueError when the name does not resolve or when any address is
55
+ internal or non-routable (see ``_is_blocked_fetch_address``).
56
+ """
57
+ try:
58
+ infos = socket.getaddrinfo(host, port, proto=socket.IPPROTO_TCP)
59
+ except OSError as err:
60
+ raise ValueError(f"could not resolve {host}: {err}") from err
61
+ addresses: list[str] = []
62
+ for info in infos:
63
+ ip = ipaddress.ip_address(info[4][0])
64
+ if _is_blocked_fetch_address(ip):
65
+ raise ValueError(
66
+ f"refusing to fetch from {host}: {ip} is a non-routable or "
67
+ "internal address"
68
+ )
69
+ if str(ip) not in addresses:
70
+ addresses.append(str(ip))
71
+ return addresses
72
+
73
+
74
+ def _guard_fetch_host(url: str) -> None:
75
+ """Refuse to fetch a certificate-supplied URL pointing at an internal host.
76
+
77
+ OCSP, CRL and CA-Issuer URLs come from the inspected certificate, i.e. from
78
+ untrusted input; following them blindly would turn certinspect into an SSRF
79
+ primitive able to reach the cloud metadata service or a port on localhost.
80
+ This is the early check on the URL; the connection itself goes to an
81
+ address vetted again at connect time (see ``_connect_vetted``), so a DNS
82
+ answer that changes in between cannot redirect it. Raises ValueError when
83
+ the target is not allowed, which the callers already treat as a soft-fail.
84
+ """
85
+ parts = urlsplit(url)
86
+ if not parts.hostname:
87
+ raise ValueError(f"URL has no host: {url}")
88
+ _vetted_addresses(parts.hostname, parts.port)
89
+
90
+
91
+ def _check_url(url: str) -> None:
92
+ """Raise ValueError unless ``url`` is an http(s) URL on an allowed host."""
93
+ if not url.lower().startswith(("http://", "https://")):
94
+ raise ValueError(f"unsupported URL scheme: {url}")
95
+ _guard_fetch_host(url)
96
+
97
+
98
+ class _GuardedRedirectHandler(urllib.request.HTTPRedirectHandler):
99
+ """Follow redirects only to URLs that pass the same checks as the first.
100
+
101
+ Without this, a public host named in a certificate could answer with a
102
+ redirect to loopback or the cloud metadata endpoint and urllib would follow
103
+ it unchecked.
104
+ """
105
+
106
+ max_redirections = _MAX_REDIRECTS
107
+
108
+ def redirect_request(self, req, fp, code, msg, headers, newurl):
109
+ _check_url(newurl)
110
+ return super().redirect_request(req, fp, code, msg, headers, newurl)
111
+
112
+
113
+ def _track(sock: socket.socket) -> socket.socket:
114
+ """Register ``sock`` with the fetch running in this thread, if any."""
115
+ sockets = getattr(_active, "sockets", None)
116
+ if sockets is not None:
117
+ sockets.append(sock)
118
+ return sock
119
+
120
+
121
+ def _connect_direct(address, timeout, source_address=None) -> socket.socket:
122
+ """Connect like http.client does, to a proxy chosen by the environment."""
123
+ return _track(socket.create_connection(address, timeout, source_address))
124
+
125
+
126
+ def _connect_vetted(address, timeout, source_address=None) -> socket.socket:
127
+ """Connect to a vetted IP of ``address``'s host, never re-resolving it.
128
+
129
+ Resolving once and connecting to that exact address closes the DNS
130
+ rebinding window: an attacker's name server cannot answer the check with a
131
+ public IP and the connection with loopback. TLS still verifies the
132
+ certificate against the original host name.
133
+ """
134
+ host, port = address
135
+ error: OSError | None = None
136
+ for ip in _vetted_addresses(host, port):
137
+ try:
138
+ return _track(socket.create_connection((ip, port), timeout, source_address))
139
+ except OSError as err:
140
+ error = err
141
+ raise error or OSError(f"could not connect to {host}")
142
+
143
+
144
+ def _connection_class(base: type, connect) -> type:
145
+ """Return ``base`` with its socket opened by ``connect``."""
146
+
147
+ class _Connection(base):
148
+ def __init__(self, *args, **kwargs):
149
+ super().__init__(*args, **kwargs)
150
+ # http.client's connection hook; HTTPSConnection wraps this socket.
151
+ self._create_connection = connect
152
+
153
+ return _Connection
154
+
155
+
156
+ _PINNED_HTTP = _connection_class(http.client.HTTPConnection, _connect_vetted)
157
+ _PINNED_HTTPS = _connection_class(http.client.HTTPSConnection, _connect_vetted)
158
+ _PROXIED_HTTP = _connection_class(http.client.HTTPConnection, _connect_direct)
159
+ _PROXIED_HTTPS = _connection_class(http.client.HTTPSConnection, _connect_direct)
160
+
161
+
162
+ def _via_proxy(req: urllib.request.Request) -> bool:
163
+ """True when urllib routes ``req`` through a proxy from the environment.
164
+
165
+ The proxy then resolves the target itself, so pinning cannot apply; only
166
+ the URL check guards those requests.
167
+ """
168
+ return req.has_proxy() or bool(getattr(req, "_tunnel_host", None))
169
+
170
+
171
+ class _PinnedHTTPHandler(urllib.request.HTTPHandler):
172
+ def http_open(self, req):
173
+ return self.do_open(_PROXIED_HTTP if _via_proxy(req) else _PINNED_HTTP, req)
174
+
175
+
176
+ class _PinnedHTTPSHandler(urllib.request.HTTPSHandler):
177
+ def https_open(self, req):
178
+ return self.do_open(
179
+ _PROXIED_HTTPS if _via_proxy(req) else _PINNED_HTTPS,
180
+ req,
181
+ context=self._context,
182
+ )
183
+
184
+
185
+ _OPENER = urllib.request.build_opener(
186
+ _GuardedRedirectHandler, _PinnedHTTPHandler, _PinnedHTTPSHandler
187
+ )
188
+
189
+
190
+ def fetch(url: str, *, data: bytes | None = None, timeout: float) -> bytes:
191
+ """Perform a minimal HTTP(S) GET/POST and return the response body.
192
+
193
+ Only ``http`` and ``https`` URLs are accepted; the URLs come from the
194
+ certificate's own AIA/CRL extensions, i.e. from untrusted input, so the
195
+ target host is screened against internal/non-routable addresses — on the
196
+ first request and on every redirect — and the response size is capped. A
197
+ POST is used when ``data`` is given. The whole fetch must finish within
198
+ ``_FETCH_DEADLINE_SECONDS`` (TimeoutError otherwise); a malformed HTTP
199
+ response raises ValueError.
200
+ """
201
+ _check_url(url)
202
+ headers = {"Content-Type": "application/ocsp-request"} if data else {}
203
+ request = urllib.request.Request(url, data=data, headers=headers)
204
+ sockets: list[socket.socket] = []
205
+ expired = threading.Event()
206
+
207
+ def expire() -> None:
208
+ expired.set()
209
+ for sock in list(sockets):
210
+ try:
211
+ sock.shutdown(socket.SHUT_RDWR)
212
+ except OSError:
213
+ pass
214
+
215
+ timer = threading.Timer(_FETCH_DEADLINE_SECONDS, expire)
216
+ timer.daemon = True
217
+ _active.sockets = sockets
218
+ timer.start()
219
+ try:
220
+ with _OPENER.open(request, timeout=timeout) as response:
221
+ body = response.read(_MAX_HTTP_RESPONSE_BYTES + 1)
222
+ except (OSError, http.client.HTTPException) as err:
223
+ if expired.is_set():
224
+ raise _deadline_error(url) from err
225
+ if isinstance(err, http.client.HTTPException):
226
+ raise ValueError(f"malformed HTTP response from {url}: {err!r}") from err
227
+ raise
228
+ finally:
229
+ timer.cancel()
230
+ _active.sockets = None
231
+ if expired.is_set():
232
+ raise _deadline_error(url)
233
+ if len(body) > _MAX_HTTP_RESPONSE_BYTES:
234
+ raise ValueError(
235
+ f"response from {url} exceeds the {_MAX_HTTP_RESPONSE_BYTES}-byte limit"
236
+ )
237
+ return body
238
+
239
+
240
+ def _deadline_error(url: str) -> TimeoutError:
241
+ return TimeoutError(f"fetching {url} took longer than {_FETCH_DEADLINE_SECONDS:g}s")
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: certinspect
3
- Version: 2.4.2
3
+ Version: 2.4.3
4
4
  Summary: Command-line TLS certificate inspector
5
5
  Author-email: Michele Angrisano <michele.angrisano@gmail.com>
6
6
  License-Expression: MIT
@@ -349,7 +349,9 @@ is treated as `UNAVAILABLE` too, so a replayed answer cannot mask a later
349
349
  revocation. The OCSP/CRL/CA-Issuer URLs come from the certificate, so
350
350
  certinspect refuses to follow one that resolves to a loopback, link-local
351
351
  (cloud metadata) or otherwise non-routable address, and caps the download
352
- size — private/internal PKI addresses stay reachable.
352
+ size — private/internal PKI addresses stay reachable. It connects to the very
353
+ address it checked, so a DNS answer that changes in between (DNS rebinding)
354
+ cannot send the request elsewhere; through a proxy, the proxy resolves the name.
353
355
 
354
356
  When the responder is down (or the certificate has no OCSP URL at all) the CRL
355
357
  fallback can still catch a revoked certificate; the `via CRL` note shows which
@@ -756,7 +758,10 @@ The report is identical to a plain inspection; only how/where certinspect
756
758
  connects changes. Split the single `--timeout` into `--connect-timeout` and
757
759
  `--read-timeout` to fail fast on dead hosts while still allowing a slow
758
760
  handshake (requests-style), and add `--retries` to ride out transient network
759
- blips instead of reporting a false failure.
761
+ blips instead of reporting a false failure. The read timeout bounds each whole
762
+ server reply (TLS handshake, each STARTTLS reply, the proxy `CONNECT` answer),
763
+ not a single read, so a server sending one byte at a time cannot stall a run;
764
+ OCSP/CRL/CA-Issuer downloads have an overall 60-second limit.
760
765
 
761
766
  ```console
762
767
  $ certinspect example.com --connect-timeout 3 --read-timeout 10 --retries 2
@@ -1,6 +1,7 @@
1
1
  """Tests for the network helpers that do not require a live server."""
2
2
 
3
3
  import threading
4
+ import time
4
5
  from http.server import BaseHTTPRequestHandler, HTTPServer
5
6
 
6
7
  import pytest
@@ -301,6 +302,42 @@ def test_negotiate_starttls_rejects_endless_replies(protocol, prefix, pattern):
301
302
  _negotiate_starttls(_EndlessSocket(pattern, prefix=prefix), protocol)
302
303
 
303
304
 
305
+ class _DrippingSocket(_EndlessSocket):
306
+ """A hostile server sending one byte per ``delay``, below any read timeout."""
307
+
308
+ def __init__(self, pattern: bytes, prefix: bytes = b"", delay: float = 0.02):
309
+ super().__init__(pattern, prefix=prefix)
310
+ self._delay = delay
311
+ self._give_up = time.monotonic() + 5.0
312
+
313
+ def recv(self, n: int) -> bytes:
314
+ if time.monotonic() > self._give_up:
315
+ raise AssertionError("client kept reading a dripping stream")
316
+ time.sleep(self._delay)
317
+ return super().recv(n)
318
+
319
+
320
+ def test_negotiate_starttls_bounds_a_dripped_reply():
321
+ from certinspect.fetch import _negotiate_starttls
322
+
323
+ start = time.monotonic()
324
+ with pytest.raises(TimeoutError, match="took longer than 0.2s"):
325
+ _negotiate_starttls(_DrippingSocket(b"x", prefix=b"220 "), "smtp", 0.2)
326
+ assert time.monotonic() - start < 1.0
327
+
328
+
329
+ def test_open_socket_bounds_a_dripped_proxy_reply(monkeypatch):
330
+ from certinspect import fetch
331
+
332
+ dripping = _DrippingSocket(b"X-Padding: x\r\n", prefix=b"HTTP/1.1 200 OK\r\n")
333
+ monkeypatch.setattr(
334
+ fetch.socket, "create_connection", lambda addr, timeout=None: dripping
335
+ )
336
+ with pytest.raises(TimeoutError):
337
+ fetch._open_socket("example.com", 443, 0.2, 5.0, "http://proxy:8080")
338
+ assert dripping.closed is True
339
+
340
+
304
341
  def test_verify_chain_uses_custom_ca(monkeypatch):
305
342
  """--cafile/--capath must build the SSL context from the given bundle."""
306
343
  import ssl
@@ -827,6 +864,7 @@ def _guard_allowing(monkeypatch, *allowed_bases):
827
864
  from certinspect import httpfetch
828
865
 
829
866
  real_guard = httpfetch._guard_fetch_host
867
+ real_vetted = httpfetch._vetted_addresses
830
868
  checked = []
831
869
 
832
870
  def guard(url):
@@ -834,7 +872,13 @@ def _guard_allowing(monkeypatch, *allowed_bases):
834
872
  if not url.startswith(allowed_bases):
835
873
  real_guard(url)
836
874
 
875
+ def vetted(host, port):
876
+ if f"http://{host}:{port}" in allowed_bases:
877
+ return [host]
878
+ return real_vetted(host, port)
879
+
837
880
  monkeypatch.setattr(httpfetch, "_guard_fetch_host", guard)
881
+ monkeypatch.setattr(httpfetch, "_vetted_addresses", vetted)
838
882
  return checked
839
883
 
840
884
 
@@ -891,6 +935,69 @@ def test_http_caps_redirect_chain(monkeypatch, serve):
891
935
  assert len(hits) == httpfetch._MAX_REDIRECTS + 1
892
936
 
893
937
 
938
+ def test_http_connects_to_the_vetted_address_despite_dns_rebinding(monkeypatch, serve):
939
+ """A name that resolves public for the check and loopback afterwards
940
+ (DNS rebinding) must not reach the internal server."""
941
+ import socket as _socket
942
+
943
+ from certinspect import httpfetch
944
+
945
+ hits = []
946
+ internal = serve(_body(b"SECRET", hits))
947
+ port = int(internal.rsplit(":", 1)[1])
948
+ real_getaddrinfo = _socket.getaddrinfo
949
+ answers = iter(["93.184.215.14", "127.0.0.1"])
950
+
951
+ def rebinding_dns(host, *args, **kwargs):
952
+ if host != "rebind.example":
953
+ return real_getaddrinfo(host, *args, **kwargs)
954
+ return _addrinfo(next(answers, "127.0.0.1"))
955
+
956
+ monkeypatch.setattr(httpfetch.socket, "getaddrinfo", rebinding_dns)
957
+ with pytest.raises(ValueError, match="non-routable or internal"):
958
+ httpfetch.fetch(f"http://rebind.example:{port}/", timeout=3.0)
959
+ assert hits == []
960
+
961
+
962
+ def test_http_fetch_has_a_total_deadline(monkeypatch, serve):
963
+ """A server dripping its body below the per-read timeout is cut off."""
964
+ from certinspect import httpfetch
965
+
966
+ def respond(handler):
967
+ handler.send_response(200)
968
+ handler.send_header("Content-Length", "1000")
969
+ handler.end_headers()
970
+ try:
971
+ for _ in range(200):
972
+ handler.wfile.write(b"x")
973
+ handler.wfile.flush()
974
+ time.sleep(0.02)
975
+ except OSError:
976
+ pass
977
+
978
+ public = serve(respond)
979
+ _guard_allowing(monkeypatch, public)
980
+ monkeypatch.setattr(httpfetch, "_FETCH_DEADLINE_SECONDS", 0.3)
981
+
982
+ start = time.monotonic()
983
+ with pytest.raises(TimeoutError, match="took longer than 0.3s"):
984
+ httpfetch.fetch(f"{public}/crl", timeout=3.0)
985
+ assert time.monotonic() - start < 2.0
986
+
987
+
988
+ def test_http_malformed_response_is_a_value_error(monkeypatch, serve):
989
+ """A broken status line is a soft failure, not an unexpected exception."""
990
+ from certinspect import httpfetch
991
+
992
+ def respond(handler):
993
+ handler.wfile.write(b"NOT-HTTP garbage")
994
+
995
+ public = serve(respond)
996
+ _guard_allowing(monkeypatch, public)
997
+ with pytest.raises(ValueError, match="malformed HTTP response"):
998
+ httpfetch.fetch(f"{public}/crl", timeout=3.0)
999
+
1000
+
894
1001
  # --- OCSP response freshness ------------------------------------------------
895
1002
 
896
1003
 
@@ -1,111 +0,0 @@
1
- """SSRF-guarded HTTP GET/POST for certificate- and CT-log-supplied URLs.
2
-
3
- OCSP, CRL, CA-Issuer and Certificate Transparency URLs all come from untrusted
4
- input, so this small client screens the target host against internal or
5
- non-routable addresses and caps the response size. Shared by the revocation
6
- checks and the CT-log discovery.
7
- """
8
-
9
- import ipaddress
10
- import socket
11
- import urllib.request
12
- from urllib.parse import urlsplit
13
-
14
- # Cap the size of any certificate-supplied HTTP response (OCSP/CRL/CA-Issuer)
15
- # so a malicious certificate cannot point us at an unbounded download and
16
- # exhaust memory. Real-world CRLs stay comfortably below this.
17
- _MAX_HTTP_RESPONSE_BYTES = 16 * 1024 * 1024
18
-
19
- # CRL/OCSP URLs legitimately redirect once or twice (http->https, a CDN).
20
- _MAX_REDIRECTS = 5
21
-
22
-
23
- def _is_blocked_fetch_address(
24
- ip: ipaddress.IPv4Address | ipaddress.IPv6Address,
25
- ) -> bool:
26
- """Return True for addresses a certificate-supplied URL must not reach.
27
-
28
- Loopback, link-local (which covers the cloud metadata endpoint
29
- ``169.254.169.254``), unspecified, multicast and reserved ranges are
30
- refused. Private RFC1918 ranges are deliberately allowed so revocation
31
- still works behind an internal PKI.
32
- """
33
- return (
34
- ip.is_loopback
35
- or ip.is_link_local
36
- or ip.is_unspecified
37
- or ip.is_multicast
38
- or ip.is_reserved
39
- )
40
-
41
-
42
- def _guard_fetch_host(url: str) -> None:
43
- """Refuse to fetch a certificate-supplied URL pointing at an internal host.
44
-
45
- OCSP, CRL and CA-Issuer URLs come from the inspected certificate, i.e. from
46
- untrusted input; following them blindly would turn certinspect into an SSRF
47
- primitive able to reach the cloud metadata service or a port on localhost.
48
- The host is resolved and every returned address checked. The guard is
49
- best-effort (the HTTP client resolves DNS again, so a rebinding attacker
50
- could still race it) but closes the obvious vectors. Raises ValueError when
51
- the target is not allowed, which the callers already treat as a soft-fail.
52
- """
53
- host = urlsplit(url).hostname
54
- if not host:
55
- raise ValueError(f"URL has no host: {url}")
56
- try:
57
- infos = socket.getaddrinfo(host, None, proto=socket.IPPROTO_TCP)
58
- except OSError as err:
59
- raise ValueError(f"could not resolve {host}: {err}") from err
60
- for info in infos:
61
- ip = ipaddress.ip_address(info[4][0])
62
- if _is_blocked_fetch_address(ip):
63
- raise ValueError(
64
- f"refusing to fetch {url}: {ip} is a non-routable or internal address"
65
- )
66
-
67
-
68
- def _check_url(url: str) -> None:
69
- """Raise ValueError unless ``url`` is an http(s) URL on an allowed host."""
70
- if not url.lower().startswith(("http://", "https://")):
71
- raise ValueError(f"unsupported URL scheme: {url}")
72
- _guard_fetch_host(url)
73
-
74
-
75
- class _GuardedRedirectHandler(urllib.request.HTTPRedirectHandler):
76
- """Follow redirects only to URLs that pass the same checks as the first.
77
-
78
- Without this, a public host named in a certificate could answer with a
79
- redirect to loopback or the cloud metadata endpoint and urllib would follow
80
- it unchecked.
81
- """
82
-
83
- max_redirections = _MAX_REDIRECTS
84
-
85
- def redirect_request(self, req, fp, code, msg, headers, newurl):
86
- _check_url(newurl)
87
- return super().redirect_request(req, fp, code, msg, headers, newurl)
88
-
89
-
90
- _OPENER = urllib.request.build_opener(_GuardedRedirectHandler)
91
-
92
-
93
- def fetch(url: str, *, data: bytes | None = None, timeout: float) -> bytes:
94
- """Perform a minimal HTTP(S) GET/POST and return the response body.
95
-
96
- Only ``http`` and ``https`` URLs are accepted; the URLs come from the
97
- certificate's own AIA/CRL extensions, i.e. from untrusted input, so the
98
- target host is screened against internal/non-routable addresses — on the
99
- first request and on every redirect — and the response size is capped. A
100
- POST is used when ``data`` is given.
101
- """
102
- _check_url(url)
103
- headers = {"Content-Type": "application/ocsp-request"} if data else {}
104
- request = urllib.request.Request(url, data=data, headers=headers)
105
- with _OPENER.open(request, timeout=timeout) as response:
106
- body = response.read(_MAX_HTTP_RESPONSE_BYTES + 1)
107
- if len(body) > _MAX_HTTP_RESPONSE_BYTES:
108
- raise ValueError(
109
- f"response from {url} exceeds the {_MAX_HTTP_RESPONSE_BYTES}-byte limit"
110
- )
111
- return body
File without changes
File without changes