| T1 |
Provider credential leak |
Credentials held only by the gate, never sent to clients; client headers never forwarded. EuroDNS: key from the secret store, IP allowlist on the gate's egress IP, user scope restricted to DNS of served domains (layer 1), rotation. Route 53: no static key (IRSA, Pod Identity or the Lambda role), IAM policy limited to the managed hosted zones, optionally an assumed role in the zone account with an external id. |
If the egress IP is shared with other workloads, the EuroDNS allowlist is weak and the key alone protects. |
| T2 |
Gate compromise (code execution in the pod or the function) |
Layer 1 limits the provider credentials to DNS of served zones; non-root distroless image, read-only filesystem; NetworkPolicy restricting egress; audit to an external sink. |
An attacker inside the gate can do whatever layer 1 allows. Layer 1 is the only control at that point. |
| T3 |
Token replay (token issued for another service presented to the gate, or stolen token reused) |
Audience must equal the gate's audience; short lifetimes and maximum token lifetime enforced; exp/nbf; bound claims per binding; TLS everywhere. |
A stolen valid token is usable until expiry, within its role and team. |
| T4 |
Stolen client credential (CI or workload token, virtual key, API key) |
Least-privilege roles per zone/host/type; ownership limits damage to the team's own RRsets; protected records; blast-radius limit per request; virtual keys restricted to acme-solver, expiring, CIDR-bound; API keys stored as SHA-256, compared in constant time, never logged, bound to one team and one role no stronger than their issuer's rights (T41), expiring, CIDR-bound, revocable at once, refused uses audited. |
The attacker can alter the team's own RRsets within the role (for an ACME key: _acme-challenge TXT records, enough to obtain certificates for the names in scope until the key is revoked). |
| T5 |
SSRF / path tricks (encoded slashes, .., absolute URLs, host header, unexpected query parameters to reach unmapped operations) |
Path normalization and rejection of encoded slashes and dot segments; {domain-name} validated against a strict domain regex and the managed-zone list (discovered, unmanaged zones are refused); route lookup on the normalized path only; unknown operations denied; unknown query parameters rejected; fixed upstream base URL. |
— |
| T6 |
Buggy client wiping a zone (full-zone PUT built from a partial zone, e.g. libdns SetRecords) |
Delta computed against the current zone; any deletion outside the caller's scope or ownership is refused (or ignored with rebase); blast-radius limit; protected records; snapshot id logged before every write. |
Within its own scope a buggy client can still delete its own RRsets. |
| T7 |
Changes made in a provider console, outside the gate |
Ownership content hash; reconcile marks drifted RRsets tainted and blocks gate writes on them; alert; foreign inventory. |
The gate cannot prevent console changes; it only detects them. |
| T8 |
Lost updates (concurrent read-modify-write) |
Per-zone lock; every write re-reads the current zone under the lock; ETag/If-Match for clients that send it; rebase for stale ACME clients. |
Two rebasing clients on the same RRset without If-Match (see DESIGN 6.4). |
| T9 |
Upstream throttling or ban via the rate limit (malicious or accidental flood) |
Single upstream caller per account; waiting limiter below the provider limit (EuroDNS 10 req/10 s; Route 53 5 req/s per account); singleflight and inventory cache on zone reads; per-subject request limits; alerting on upstream 429. |
A ban still blocks all writes for its duration; the provider console remains available. |
| T10 |
Store tampering (write access to the DynamoDB table) |
Table only writable by the gate's IAM role; PITR; ownership changes are audited and can be cross-checked with the audit trail. |
An attacker with table write access can grant ownership, but RBAC (layer 2) and layer 1 still apply. |
| T11 |
Policy tampering |
Policy in git, changed by reviewed pull requests, deployed through GitOps; config loaded read-only. |
Compromised git/CD pipeline. |
| T12 |
Denial of service on the gate |
Request size limits, timeouts, per-subject limits; the gate is not on the DNS resolution path (only on the change path). |
Changes blocked while the gate is unavailable. |
| T13 |
Information disclosure through list endpoints (EuroDNS-compatible POST /domains/search returns every domain of the account) |
Not an opened operation of the EuroDNS-compatible API; /api/v1/zones lists only the zones the caller can read. |
— |
| T14 |
Audit evasion |
Every request audited, including denials; stdout to an external, append-only sink in addition to the store copy used by the UI; optional hash chain per instance (audit.hash_chain), checked by dns-gate audit verify, reveals deleted, altered or reordered events in an export (AUDIT.md). |
Gate compromise (T2) can suppress events. A whole chain missing, or events cut at the end of a chain, are not detected by the chain itself. |
| T15 |
UI session theft or fixation |
OIDC code flow with PKCE and state/nonce, or SAML bound to the login cookie (T36); encrypted HttpOnly, Secure, SameSite=Strict cookie; short session lifetime; session key rotated with the deployment secret; no token in browser storage. |
A stolen cookie gives read access and plans until expiry; applies and policy changes also need a recent login (T23). |
| T16 |
CSRF |
Inventory and audit routes are GET-only and side-effect free; SameSite=Strict; every other method with the browser session (DNS plan/apply and single-RRset writes, gate tokens, policy mutations) requires the X-Gate-CSRF header equal to the gate_csrf cookie and a same-origin Origin, as in T24; DNS applies also require step-up (T23). |
— |
| T17 |
XSS (record values, hostnames, subject names rendered in the UI are attacker-influenced: TXT content, claims) |
Values rendered as text only, never as HTML; strict CSP (default-src 'self', no inline script, frame-ancestors 'none'); JSON API with Content-Type: application/json and X-Content-Type-Options: nosniff. |
— |
| T18 |
Inventory leak (the UI exposes zone contents, owners, pipeline identities, internal hostnames) |
ui.read action required; zone-level filtering by readable zones; UI not exposed publicly by default (internal ingress); audit of UI access. Discovered, unmanaged zones: listed with ui.read on the zone, contents only with dns.read as well; providers[].zones.exclude hides domains entirely. |
Anyone with ui.read on a zone sees its full inventory and history. A read role on zones: ["*"] covers every domain of the account once discovery is enabled. |
| T19 |
UI as a rate-limit amplifier |
The UI reads the inventory cache filled by reconcile and writes; only an empty zone cache (first start) triggers one provider read for that zone, never a UI request afterwards. Discovery: one listing per providers[].zones.refresh (one request per 100 domains), plus at most one per minute triggered by policy proposals; listing zones never reads unmanaged zones; opening one reads it once per reconcile_interval, concurrent views sharing the request. |
One GET per zone at startup; one GET per opened unmanaged zone and interval. |
| T20 |
Token issued for another audience replayed (raw Azure DevOps OIDC token with the fixed audience api://AzureADTokenExchange, Kubernetes token meant for the API server, token for another API on the same issuer) |
aud must be one of the issuer's configured audiences, set to the gate's own audience whenever the issuer allows it; Entra issuers must be tenant-specific (/common, /organizations, /consumers refused); Entra bindings on app roles with tid+oid subjects. The raw Azure DevOps token, whose audience is shared, is accepted only from a dedicated issuer bound (bound_claims.sub) to service connections used for nothing but the gate, which no other federation trusts (CONFIG.md, Azure DevOps OIDC). |
A shared-audience token of such a service connection is still valid at another relying party that trusts its subject: keep those subjects out of every other federation. |
| T21 |
Privilege escalation through the policy editor (an editor grants themselves or others more rights) |
policy.* actions granted only by base bindings (git); managed rules confined to base bounds (zones, folders, actions; folder-based rights also depend on the EuroDNS folder layout, T47); zones brought under management by the managed layer confined to policy.bounds.zones and to the discovered account zones (providers[].zones include/exclude); managed names cannot shadow base names; protected records win; validation at proposal and activation; impact analysis shown to the approver. |
An approver who approves without reading can still grant anything within bounds. |
| T22 |
Self-approval |
Approval must come from a policy.approve holder other than the author; enforced server-side on the revision author's subject. With policy.require_approval: false, a proposer activates alone (single-person control, to be chosen knowingly). Delegated changes skip approval by design (T32). |
Two colluding approvers. |
| T23 |
Stolen UI session used to change the policy |
Step-up: recent auth_time (policy.edit_max_age) and MFA in amr (policy.require_amr) for every mutation, else reauth_required; short sessions; approval by a second person. |
A session stolen right after a step-up, within edit_max_age. |
| T24 |
CSRF on policy mutations |
X-Gate-CSRF header must equal the gate_csrf cookie; same-origin Origin header required; SameSite=Strict cookie; JSON bodies only. |
— |
| T25 |
Activating a stale revision (approved on a parent that is no longer active, silently reverting a newer change) |
parent_id recorded; stale revisions cannot be activated; activation is a conditional write on the expected active revision. |
— |
| T26 |
Store compromise rewriting the policy (direct write of revisions or of the active pointer, bypassing approval) |
Store writable only by the gate's identity; bounds and policy.* grants live in the file, not the store, so a forged revision stays within bounds; alert on every activation (audit event); regular export of the active revision to git to detect divergence; PITR. |
Within bounds, a forged revision is effective until detected. |
| T27 |
LLM agent tricked by prompt injection into writing DNS (instructions hidden in a TXT value, a hostname, an audit comment or any content the agent reads) |
MCP writes disabled by default; when enabled, every write goes through plan_rrset_change then apply_rrset_change(plan_id), the plan being bound to the subject, the zone version and an expiry; RBAC, protected records, ownership and blast-radius limits unchanged (the agent's identity has only its own rights); no policy tools over MCP; via=mcp in audit. Give agents read-only identities by default. |
An agent with write rights and a human who approves the apply call without reading the plan. |
| T28 |
Abusive adoption of a production record (an admin or a stolen admin session adopts a foreign RRset for a team, which can then change or delete it) |
dns.record.adopt reserved to admins (base policy); preview mandatory, apply all-or-nothing bound to preview_token; mandatory comment; protected and server-managed records never adoptable; step-up authentication for humans; audit event listing every adopted RRset and value; alert on adoption. |
An admin acting in bad faith within the protected-record exclusions. |
| T29 |
Pipeline impersonating another through a shared binding (one team_from binding for every identity matching a glob) |
Team derived per subject from an anchored regex with one capture; a subject whose claim does not yield a valid team is not bound (fail closed, never the team of another binding); ownership confines each derived team to the RRsets it created; protected records; narrow role (hosts, types, zones). |
Any identity matching the glob can create any not-yet-existing RRset allowed by the role, and whoever can create matching identities (repositories, namespaces, roles) gets that right. With Azure DevOps (sub = sc://<org>/<project>/<service connection>, team = service connection name), anyone allowed to create a service connection under the glob prefix and to authorize it for a pipeline they control mints a new trusted identity with its own team: no access to other teams' records, but any free name its role allows. Mitigations: prefix dedicated to the gate and trusted by no other federation, service connection creation restricted (project Endpoint Creators / Administrators), approvals and checks on service connections or environments, audit log (subject and team of every write; a new team is a new service connection). Captures differing only by case share a team. |
| T30 |
Unmanaged zone changed through the gate (a discovered zone written to or adopted before review) |
Unmanaged zones are read-only in RBAC (only dns.read and ui.read can match), refused by the EuroDNS-compatible API, adoption, Terraform export and plans; managing one is a policy revision with approval by a second admin, step-up and impact analysis; reconcile only runs on managed zones. |
Same as T21 once a revision managing the zone is approved. |
| T31 |
Releasing a zone that holds owned RRsets (a revision removing a managed zone) |
Impact analysis warns with the number of owned RRsets; ownership entries stay in the store, so managing the zone again restores them. |
While released, nobody can change those RRsets through the gate (fail closed). |
| T32 |
Delegated identity escalating (a pipeline holding a delegation grants itself or others more than intended) |
Delegations live in the base file only (reviewed pull request), never in the managed layer; delegated roles bounded by allow.zones, allow.actions, allow.records (inside policy.bounds, policy.* impossible), bindings by allow.binding_subjects (sound glob coverage, * alone refused), allow.teams and allow.roles/allow.groups; quota allow.max_objects; protected records win; validation at write and on every revision, re-check at evaluation; the delegated subject gets no role of its own from the delegation. |
Within its limits the delegation can bind any covered identity to any allowed role, without review: keep allow as narrow as the cloud policy the same stack writes, and binding_subjects to a prefix dedicated to the gate. |
| T33 |
Stolen credential of a delegated identity (the stack's service connection or CI token) |
Same token controls as T3/T4/T20 (dedicated service connection, audience, short lifetime, approvals and checks on the service connection); ownership: only objects of its delegation; every change audited (policy.delegated.*, policy.activate) with the impact analysis; ETag preconditions reveal out-of-band changes to the owner stack at its next plan. |
The attacker can create, within the limits, identities able to write any free name the delegation allows, until the change is noticed in the audit or the next plan. |
| T34 |
Human edit silently altering delegated objects (a UI round trip dropping fields, a rollback reverting a pipeline's binding) |
Delegated objects in a separate section the UI never edits; proposals keep the active section and refuse any change (403 delegated_object); rollbacks keep it; changes only through the delegation API or an explicit, audited takeover by a policy.approve holder, reviewed as any proposal. |
A policy administrator can still take objects over (by design), which the owner stack sees as a deletion at its next refresh. |
| T35 |
Revision churn (a buggy or hostile delegated client flooding the policy with changes) |
Idempotent writes (no revision when nothing changes); quota of objects per delegation; serialized writes; per-request audit; request size limits. |
Each real change is a revision: a client changing objects in a loop fills the history and makes open human proposals stale. |
| T36 |
Forged or replayed SAML assertion (response signed by another key, issued for another application, replayed from a proxy log, or injected into a victim's browser to log them in as the attacker) |
Signature of the response or assertion with the IdP metadata certificate (unsigned refused); audience, Destination/Recipient, issuer, validity window and 90 s issue age checked; InResponseTo and RelayState must match the AuthnRequest kept in the sealed login cookie of the same browser, cleared on first use; unsolicited assertions never accepted (redirected to a fresh login); the IdP metadata only from HTTPS or the file. |
No server-side record of consumed assertions (stateless gate): a response replayed with the stolen login cookie of the same browser within 90 s is accepted. |
| T37 |
Gate token theft or forgery (token copied from a script or the extension's token file; signing key leaked) |
Short token_ttl (1 h) capped by the session end; bound at every request as the original issuer, so removing a binding cuts the token at once; a token never yields another one (/api/v1/tokens needs a session); key from the secret store only, never in the file; every issuance audited with its jti. |
A stolen token is valid until expiry; a leaked signing key lets anyone mint tokens for any bound identity until the key is replaced (which invalidates every token). |
| T38 |
Local application abusing the gate authorization server (another process starts an authorization request with its own loopback port and PKCE pair) |
Only loopback redirects for the public client dns-gate-relay (declared clients have exact HTTPS redirect URIs, T52); PKCE S256 mandatory; consent page naming the gate and the user, posted with the CSRF token and same-origin check; codes valid 2 minutes; refresh limited to the session and re-checked against the bindings. |
A user who clicks Allow on a request they did not start hands their rights to that process until the session ends. Codes of dns-gate-relay are not single-use within their 2 minutes (stateless), which PKCE makes harmless. |
| T39 |
Token exchange abuse (a token of any trusted issuer turned into a gate token; an exchanged token chained into another; a stolen CI token exchanged to outlive its job) |
Opt-in per issuer (token_exchange: true), off by default; the subject token is validated exactly as a bearer token (signature, audience, bound_claims, bindings), so an unbound identity gets nothing; gate tokens and API keys are never exchanged; lifetime 15 minutes by default, capped by the issuer's max_exchanged_ttl, token_ttl and the subject token expiry plus 5 minutes; the gate token keeps the identity and is bound again at every request (a binding removed, or the issuer opted out, cuts it at once); every exchange audited (gate.token.exchange, with both jti). |
A stolen subject token, while valid, yields a gate token valid a few minutes longer. |
| T40 |
ACME endpoints as a write path (a credential used to change records through /acme/…, or to hold or disturb challenges of others) |
Same engine as every write: RBAC with record scope, ownership, protected records, audit; only _acme-challenge TXT RRsets are reachable; the caller's role must be ephemeral and an ephemeral RRset lives at most limits.ephemeral_lifetime_factor TTLs from its creation; values capped per RRset (acme.max_values) and per author (acme.max_values_per_author), owned by their author (only the author removes a value, a value of another cannot be claimed: value_taken), recorded only for RRsets the caller wrote; registrations capped per owner under the zone lock, saved only after a successful write (retried on conflicts), those of token subjects purged when idle; the allowfrom of a key's registrations for a domain applies to every write of the key to that domain's challenge RRset, whatever the entry point; acme-dns registrations belong to API keys. |
Whoever holds an ACME credential can obtain certificates for the names in its scope until the credential expires or is revoked. A caller that empties its RRset and writes again starts a new lifetime bound (a new RRset). Value ownership and the value caps apply to the /acme endpoints only: ownership of the RRset is per team, so any identity of the same team whose role covers _acme-challenge TXT can rewrite it through the RRset or EuroDNS-compatible API; give each third party its own team. The registration cap is checked per zone lock: concurrent first uses in different zones can overshoot it by the number of zones written at once. |
| T41 |
API key outgrowing its issuer (a key minted with more rights, a longer ephemeral TTL or a higher change limit than its manager; a role widened after issuance) |
Issuance refused unless the manager holds every rule of the key role on the same zones and records, an ephemeral TTL at least as short and, for writing roles, a change limit at least as low; the declared grant of the role (rules, TTL, change limit, 0 for inherited) is recorded at issuance and a key whose role declares more is refused (role_widened, audited), a key without a recorded grant too; global limits and policy.bounds are not part of the grant, so changing them never revokes keys; the creator and the key's team members holding gate.apikey.manage can always revoke it. |
A role shrunk and widened back within the issued grant keeps working, by design. |
| T42 |
Audit flooding with forged keys or wrong secrets (requests carrying random dgk_… values, or guesses for an existing key id) |
Refusals aggregated into one event per minute and per source (IPv6 per /64): per source for unknown or malformed keys, per key id and source for existing keys; the counters live in a bounded LRU (4096 entries, O(1) per request) whose evictions emit their pending counts; the endpoints never audit a key refusal a second time. |
Bursts from many /64 or IPv4 sources still produce one event per source and minute. |
| T43 |
Subject id collision with gate-made subjects (an OIDC issuer named api-key, virtual-key or gate) |
Those issuer names are reserved and refused at load. |
— |
| T44 |
Records handed to another team without its consent (adoption for a team the caller is not a member of, a deleted RRset re-created at once by another team, a typo in a team name creating a new team, a derived team taking the name of a declared one, a claim value joining another family) |
The adopt owner must be one of the caller's teams unless it holds dns.ownership.approve on each RRset; a deleted RRset stays reserved for its team for ownership.tombstone_ttl, written atomically with the deletion (re-creation and adoption by another team refused, whoever adopts); ownership moves through transfer requests whose approver may write every RRset through the owner team's own bindings (an ACME-only identity of the team does not count) or holds dns.ownership.approve on it, a human after a recent login; applied only if the RRsets did not change, idempotently (transfer id on moved entries, one replica at a time, approver rights checked again on every retry), audited with both identities and approval; with a teams block, undeclared references are refused, families need disjoint prefixes no declared team carries, a derived team equal to a declared one is dropped and team_claim values stay in the prefixed family of their issuer. |
With the default ownership.require_second_approver: false, one person holding the rights above transfers records alone (audited as approval: self): enable it as soon as two people administer the gate, with ownership.person_issuers set to the UI login issuer. person_issuers is required as soon as several issuers yield humans (and defaults to the only one otherwise), so a person cannot approve their own request through a second human issuer; two identities of one person on the same person issuer stay possible only if that issuer gives one person several subjects; ownership.machine_approvers lets machines approve and requests by unidentifiable identities be approved. A dns.ownership.approve holder can adopt free RRsets for any team; without a teams block (migration), a typo still creates a team; a rename moves the RRsets in the store but the policy keeps naming the old team until a revision changes it. |
| T45 |
Managed grants silently lost after a base change or a rollback (a new teams block or an older binary invalidating the active managed revision) |
The previous policy is kept while a replica runs; a replica starting with an invalid revision serves the base only and says so in error logs and in load_error of GET /api/v1/policy (policy.read), the unauthenticated /healthz//readyz only saying that the managed policy is not served; dns-gate --check validates the active revision against the new base before a deploy; rollout order documented in MIGRATION. |
A replica restarted on an invalid revision serves the base policy until the revision or the file is fixed (fail closed). |
| T46 |
Zone profile as a pre-positioned write (a profile changed so that a domain arriving in the EuroDNS account, by transfer or Premium DNS, gets the attacker's MX, TXT verification or CNAME records, outside any zone RBAC or ownership) |
Opt-in per EuroDNS account (providers[].eurodns.zone_profiles, off by default); dns.zone.profile only counts when granted on every zone ("*", "**") without record scope (a narrower grant has no effect and is flagged at load and in the impact analysis of managed revisions), meant for the account administrators; refused before any upstream call; the managed layer can grant it only if policy.bounds allow it on "*"; humans need a recent login for writes on every channel; records of the protected list refused in profiles whatever the zones of the entry (create, update, check), mail forwards counting as the apex MX and URL forwards as A, AAAA and CNAME of their host; 60 operations per subject and minute; every operation audited with the provider and profile id, refusals included, writes with the profile content, updates with the previous content (an update and a delete read it first) and the host, type and operation of each changed record, the journal showing profile events (whose content may hold verification tokens) only to dns.zone.profile holders; bodies decoded and re-encoded (only ZoneProfilePage fields reach EuroDNS), no query string, explicit provider when several EuroDNS providers exist; reads need the action too (profiles may hold verification tokens). |
A holder of the action decides the initial content (outside the protected list) of any domain that arrives in an opted-in account, and of none in particular: there is no per-domain scope nor team ownership for profiles. EuroDNS applies the profile itself: the records are foreign to the gate until adopted, and profile changes made in the EuroDNS console are not audited by the gate. |
| T47 |
Rights moved through EuroDNS folders (a domain moved into a folder selected by a role rule, folders: ["/ES/**"], gives that role rights on it; moved out, the rights are lost; a managed or delegated folder rule used to reach a sensitive base zone moved into its folder) |
Folder selectors never make a zone managed: only the base and managed zones are writable. Folders narrow the bounds, never widen them: a managed rule applying through a folder only reaches zones matching policy.bounds.zones, a delegated one only zones matching its allow.zones, so moving a base zone kept out of the bounds into a folder grants the managed layer nothing there. policy.bounds.folders and delegation allow.folders bound the folders of managed and delegated rules. Unknown folders (field absent, listing failed for longer than zones.folder_expiry refresh periods, zone listed by two providers) match no folder rule: they fail closed. API keys issued by a managed or delegated holder never get folder patterns beyond that narrowing. Listings are audited (a gate.zone.folders_listed summary with a digest per process start, then gate.zone.folder_changed, folder_seen, folder_gone per zone), and writes, adoptions and transfers granted through a folder carry the folder of their authorization in their audit event; the folder of a zone is shown in the zone list, explain and who-can; the impact analysis flags dynamic folder rules; providers[].zones.folders restricts what an account serves. Use zones instead of folders where the folder layout is not trusted. |
Whoever can move domains between folders in the EuroDNS console (or with the EuroDNS API key, T1, T2) controls folder-based rights within the bounds, without a policy revision nor approval: restrict folder management in EuroDNS to the people who could approve the corresponding policy change. Base folder rules are not bounded. A move is effective at the next listing (zones.refresh); folder events are per process, not compared across instances (a move while no instance runs only shows as a different folders_listed digest). |
| T48 |
URL forwards turned into phishing or open redirects (a redirect of a trusted host changed to an attacker's site, a frame forward showing another site under the zone's name, a forward of another team rewritten through the full-zone PUT) |
Forwards are owned like RRsets: dns.forward.write scoped by host, separate from dns.record.write; ownership, tombstones, transfers, blast-radius limit and audit with the old and new target; foreign forwards need adoption (dns.record.adopt); the full-zone PUT applies the same checks, dns.zone.admin keeping only the pre-ownership right to change or delete unowned forwards (never to create one; audited as zone_admin_forwards); a forward is never created over the A/AAAA/CNAME/APEX records of a host held by another team (also when missing upstream or reserved by a tombstone) or by nobody, nor the reverse, and a protected entry listing those types protects the forward; frame fields are length-limited plain text (no control nor bidirectional format characters) and URLs canonical http(s) URLs without user information, with punycode hosts; zone profile forwards get the same checks and the protected list as type URLFWD (EuroDNS serves frame forwards as a page on the customer host); drift outside the gate taints the forward; a host holding several forwards is read-only and does not block other full-zone saves. |
A team may point its own hosts anywhere; the gate does not vet target URLs. A dns.zone.admin holder can still change unowned forwards through the full-zone PUT. |
| T49 |
Paid products ordered through the gate (HTTPS redirect subscriptions bought or cancelled by a client) |
The gate only reads subscriptions (GET /subscriptions, GET /https-redirect-subscriptions/{id}) for the HTTPS status of forwards; subscription operations stay denied in the EuroDNS-compatible API. |
The read needs an API key allowed to list subscriptions; without it the status is unknown and require_https writes are refused. A failed read is kept 30 seconds and shared by concurrent requests, and is done before the zone lock, so a slow subscription API delays only the writes asking for HTTPS. |
| T50 |
Propagation check as an open resolver, SSRF, oracle or traffic amplifier (asking the gate to resolve arbitrary names, reach internal hosts on port 53 directly or through NS records, learn split-horizon answers, or send many DNS queries; a stale inventory or a shared CDN address reported as propagated) |
Names asked are built from a zone managed by the gate and a host and type the gate validated (unmanaged and unknown zones refused, ANY, AXFR and other meta types refused), with dns.read on that RRset (the UI hides the panel otherwise); servers contacted are only the configured resolvers (IP literals from the base file, public unicast unless propagation.allow_private_resolvers) and the authoritative name servers of the zone, whose addresses must be public unicast outside the IANA special-purpose blocks, IPv4 embedded in IPv6 (NAT64, 6to4, mapped) checked as IPv4, the caller giving no address; one query per server (two for an alias), 5 s at most per check; results cached per RRset content and shared; per process, checks missing the cache limited per subject (requests_per_minute, LRU of 4096 subjects, 429) and in number at once (max_in_flight, 503); answers capped (32 values of 512 bytes, 1 MiB per result); expect (the new_hash of the apply) forces a bounded provider re-read instead of comparing with a stale per-process inventory; alias answers must be a subset of the target addresses, else indeterminate, never converged; convergence needs an authoritative match; off by default on Lambda. |
Limits are per process: N replicas or Lambda instances allow N times the checks, and every check on Lambda holds an execution environment (reserved concurrency) for up to 5 s. A reader can make the gate send about 20 small queries per check to well-known public resolvers and to the name servers of the managed zones; the answers reveal nothing beyond what public DNS already shows, except with a private resolver explicitly allowed. Alias targets come from the provider content, so they may be names outside the managed zones, asked to the public resolvers and the system resolver only. |
| T51 |
Third-party application acting with the full rights of its user (a Microsoft 365 Copilot agent, an orchestrator or a SaaS holding a token of a trusted issuer; prompt injection or a compromised vendor turning a read assistant into a writer) |
Delegated clients: the azp / appid of the token selects a declared client whose scopes (allowlists of RBAC actions), zones and surfaces cap the RBAC of the user, in the policy engine itself (every decision, REST and MCP) and at the router. Endpoints and MCP tools are opened to delegated clients by an explicit table: anything else answers 403 not_delegable (policy writes, API keys, zone administration and profiles, gate tokens, the token exchange, ACME and the EuroDNS-compatible API are never delegable). dns.plan grants write actions only while a plan is computed; a plan is applied only by the same user through the same client. MCP tools/list hides the tools outside the scopes, and their calls are refused. Client ids are compared without case against azp, else appid, so one entry covers v1 and v2 tokens; the gate warns once per undeclared client id it sees. A delegated subject is never a person for transfer approvals (second approver, machine_approvers) and its transfers are confined to the client zones. require_known_client refuses every undeclared client. The audit records client_id and actor from the configuration (never from claims), from the subject of each event (background transfer retries included) and auth_method: oauth-delegated. |
Without require_known_client, a client that is not declared keeps the full rights of its user (compatibility). The scopes cap what the client may do, not what it does within them: a dns.write client still writes everything its user may write. The azp / appid claim is trusted as issued by the IdP: an issuer whose clients can choose it freely gives no client separation. |
| T52 |
Declared OAuth client abused (refresh or access token stolen from the application's database or logs; the client or its key compromised; a user tricked into consenting; scopes granted too widely) |
OAuth clients are declared in the reviewed base file; confidential clients authenticate (private_key_jwt with jti replay protection and assertions of at most 5 minutes, or a secret of 32+ characters compared in constant time); PKCE S256 always; exact HTTPS redirect URIs; codes stored, single use, 2 minutes, bound to client, redirect and verifier; refresh tokens sealed with the session key, only their SHA-256 stored, rotated at every use, a reused one revoking the whole grant (30 s grace returning the same answer to the same client); grants expire when idle (refresh_idle_ttl), absolutely (refresh_max_ttl ≤ 180 days) and when their claims are older than claims_max_age (Identity Center groups looked up again at each refresh instead); access tokens 10 minutes, checked at every request against the client (declared, enabled) and the grant (active; cached 30 s); scopes are the delegated-client scopes (T51): RBAC ∩ scopes ∩ zones, deny-by-default routes, policy, API keys, tokens, ACME and the EuroDNS API never reachable; write_max_age demands a recent sign-in for dns.write; consent page with the configured name, the user, the scopes in words and the duration, CSRF and origin checked, form-action limited to the redirect URI, never framed; consent remembered only within the scopes already granted; users revoke under Connected applications, gate.oauth.manage holders per client or user, disabled: true cuts a client; every step audited (oauth.*, client_id, extra.grant_id), client authentication failures aggregated. |
An attacker holding the client credential and a refresh token acts as each linked user within their scopes until revocation; a stolen access token works up to 10 minutes and a revocation takes up to 30 s on other replicas. Claims of an OIDC session are replayed up to claims_max_age. Rotating DNS_GATE_SESSION_KEY ends every grant. A client granted dns.write writes everything its users may write. |
| T53 |
Authorization response mix-up and code injection (an application talking to several gates sends a code to the wrong one; a code captured from a redirect replayed) |
iss in every authorization response (RFC 9207, advertised in the metadata) for the client to compare with the gate it pinned; client assertions bound to one gate by aud; codes bound to the client, its exact redirect URI and the PKCE verifier, single use; one client per application tenant with tenant-specific redirect URIs. |
Relies on the client checking iss and state. |
| T54 |
Account linking on an unverified email (an application that links its users to the gate by email, through GET /api/v1/me, matches a user whose IdP lets them choose the address: an Entra mail set by an administrator or a guest, a self-service IdP account) |
email is returned only when the issuer vouches for it (Email of the subject): the SAML email attribute or an emailAddress NameID; for OIDC, email_claim with email_verified_claim true, or email_trusted: true set by the administrator; a verification claim present and not true and email_trusted: false always withhold it; never derived from the display name or the subject. Gate tokens carry the claims of their session, signed by the gate; the NameID format is recorded by the gate after the attribute mapping (an attribute cannot forge it). The email of an OAuth grant is omitted past claims_max_age when identity store groups keep the grant alive. |
email_trusted: true trusts every value of email_claim (Entra upn or preferred_username of guests, an IdP whose users edit their email). The SAML email attribute is trusted as the IdP sends it. Within claims_max_age, an address changed at the IdP is still returned for a grant. |