The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Where Remote Config may send a credential (the plane bearer, the IdP client secret).
The plane URL and the IdP token URL are operator-selected (D19: the plane defaults to
``https://config-config.nousresearch.com`` and an on-prem deployment points it elsewhere), so this
is a transport policy, not an allow-list of hosts:
- ``https`` only; plain ``http`` only to a loopback host (tests, local development);
- one unambiguous origin: no userinfo, query or fragment in the configured URL;
- a credentialed request never follows a redirect, so the credential reaches only the origin the
operator configured (a 3xx is refused, not re-authorized hop by hop).
"""
from __future__ import annotations
import ipaddress
import urllib.error
import urllib.parse
import urllib.request
from .credentials import PlaneCredentialError
class CredentialDestinationError(PlaneCredentialError):
"""A credential would go somewhere the transport policy forbids. Never retryable: the
configuration (or the server's redirect) has to change."""
def __init__(self, message: str) -> None:
super().__init__(message, retryable=False)
def _is_loopback(host: str) -> bool:
if host == "localhost":
return True
try:
return ipaddress.ip_address(host).is_loopback
except ValueError:
return False
def display_url(url: str) -> str:
"""*url* for messages: any user info (``user:password@``) dropped, so a misconfigured URL
never echoes a credential back (an unparsable one is cut at the last ``@``)."""
try:
parts = urllib.parse.urlsplit(url)
if parts.username is None and parts.password is None:
return url
host = parts.hostname or ""
if ":" in host:
host = f"[{host}]"
port = parts.port
except ValueError:
head, sep, tail = url.partition("//")
return f"{head}{sep}{tail.rpartition('@')[2]}" if sep else url.rpartition("@")[2]
return urllib.parse.urlunsplit(parts._replace(netloc=f"{host}:{port}" if port is not None else host))
def checked_url(url: str, *, env_name: str) -> str:
"""``url`` when a credential may be sent to it, else :class:`CredentialDestinationError`."""
try:
parts = urllib.parse.urlsplit(url)
host = (parts.hostname or "").lower()
_ = parts.port # raises ValueError on a malformed port
except ValueError as exc:
raise CredentialDestinationError(f"{env_name}={display_url(url)!r} is not a valid URL: {exc}") from exc
if not host:
raise CredentialDestinationError(f"{env_name}={display_url(url)!r} has no host.")
if parts.username is not None or parts.password is not None or parts.query or parts.fragment:
raise CredentialDestinationError(
f"{env_name} must be a plain origin and path (no user info, query or fragment); "
"Remote Config does not send credentials to an ambiguous destination.")
scheme = parts.scheme.lower()
if scheme == "https" or (scheme == "http" and _is_loopback(host)):
return url
raise CredentialDestinationError(
f"{env_name} must be an https:// URL (plain http is accepted only for localhost, "
f"127.0.0.1 or ::1); Remote Config does not send credentials to {parts.scheme or 'no'}://{host}.")
class _RefuseRedirect(urllib.request.BaseHandler):
"""Every 3xx (308 included, whatever the interpreter's redirect handler knows) is refused."""
def _refuse(self, req, fp, code, msg, headers):
fp.close()
raise CredentialDestinationError(
f"{req.get_full_url()} answered HTTP {code} redirecting to {display_url(headers.get('Location') or '')!r}; "
"Remote Config never follows a redirect with credentials. Point the URL at the final "
"destination.")
http_error_301 = http_error_302 = http_error_303 = http_error_307 = http_error_308 = _refuse
# build_opener drops its default HTTPRedirectHandler when given a subclass only; give it ours
# AND remove the default explicitly so nothing earlier in the chain follows a 3xx.
_OPENER = urllib.request.OpenerDirector()
for _handler in (urllib.request.ProxyHandler(), urllib.request.UnknownHandler(), urllib.request.HTTPHandler(),
urllib.request.HTTPSHandler(), urllib.request.HTTPDefaultErrorHandler(), _RefuseRedirect(),
urllib.request.HTTPErrorProcessor()):
_OPENER.add_handler(_handler)
def open_credentialed(req: urllib.request.Request, *, timeout: float):
"""``urlopen`` for a request carrying a credential: a 3xx raises
:class:`CredentialDestinationError` instead of being followed."""
return _OPENER.open(req, timeout=timeout)