0
0
Proposed security controls
Controls an agent thinks are needed. None is implemented until the owner approves it. See AGENTS.md, "Security controls: propose, never implement".
Proposed
Release downloads: SHA256SUMS from the same bucket as the binary
- What: sign the
SHA256SUMSof a release (a detached signature by a key published out of band, or a record in the owner's repo), and havedocs/bidder.mdverify it. - Where:
docs/bidder.md"Binary" (rc and main builds verify against theSHA256SUMSfetched from the same bucket directory);README.mdpins the hashes inline for one rc. - Threat: whoever can write the bucket replaces the binary and its
SHA256SUMStogether; the check then proves nothing. The operator runs the binary as root (install bidder).
The staging module: an oci: requester spec with a shell metacharacter
- What:
prefix()intests/modules/staging/src/lib.rscould refuse anoci:<ref>@sha256:<digest>spec whose reference contains a single quote, a space or a semicolon. An agent added it without approval; it is removed. - Where: the staging module puts the reference into the root shell command it runs on each staging VM (
oras pull <ref>). - Threat: a hostile spec (a target file, a fork's workflow input) could end the command and run another as root on the VM. Today the spec is written by
scripts/ci-staging-binary.shfromoci-push.shoutput; the VMs are rented for the run and a fork's are its own. - Proposal: quote the reference as one shell word instead of refusing it.
The bidder: --cpu-overcommit below 1
- What:
run bidder,install bidderanddev upcould refuse--cpu-overcommitbelow 1 (and a MarketBidderspec.cpuOvercommitbelow 0). Not implemented: 0 means the default 2, and a negative value commits no vCPUs, so the bidder bids on nothing. - Where:
vmLimitsininternal/market/bidder/vmsize.go. - Threat: an operator typo takes its own bidder out of the market. There is no upper bound either: a large ratio lets one host commit far more vCPUs than it has cores, which is the operator's choice.
- Proposal: refuse a negative ratio when the bidder starts, and say in
check-hostthe ratio the bidder commits.
A network PDS: pin a network name's address
- What: when a network PDS fetches OAuth client metadata or a
jwks_urifrom a name under its network's domain, refuse a connection whose resolved address is not one the network value names (itsdns,xrpcFrontandhostsaddresses). Not implemented: today the name alone decides (the network's domain, resolved by the host's resolver, TLS by the system roots plus the network CA). - Where:
internal/atproto/oauth/client.gohttpClientFor,internal/services/pds/service.gooauthNetwork. - Threat: whoever can answer DNS for a name under the network's domain on the PDS's host (a network whose domain is a public one, a poisoned resolver) points a client_id at any private address the PDS's host reaches; the PDS then GETs it (no redirect followed; the answer must be TLS under a trusted root and JSON client metadata to be used).
- Proposal: a dial control on the network client that accepts only those addresses.
A policy input that cannot be read
- What: fail closed when a record the policy run names (
rfp,bid,accept) cannot be read:recordInput(internal/policyengine/controller/run.go:221-235) drops the read error and hands the action{uri, cid}withoutvalue;bid-payload(internal/policyengine/bundled-actions/tangy/policy-bid-payload,createBidPayloadFilterPolicy) then answersallow: truewhen no offer is present.requester-tangled-vouchand the other trust policies never read the bid's value. - Where: those two places; the requester's winner run (
runner.gothewinnerPolicystep) passes the bid by strongRef. - Threat: a bid whose record the policy engine cannot read (gone, another version, a route that answers 404) passes a payload policy it would have failed.
An invalid receipt leaves the bidder's VM running
- What: when a receipt fails its check (
acceptReceiptininternal/market/requester/runner.go: FailedreceiptInvalid), send the bidder a release for the receipt read from its repo at the deterministic rkey (market.ReceiptRKey), not for the invalid one; today no release is sent (main does the same) and the VM runs until the bidder's own lease ends. Not one call on an existing path:releaseContractnamesstate.Receipt, the invalid receipt, which the bidder refuses ("the inbound event names another receipt", seen 2026-11-20 in run a2-main). - Where:
acceptReceiptandreleaseContractininternal/market/requester/runner.go. - Threat: a forged or broken receipt costs the bidder a running guest for up to its lease (24 h by default).
The bidder's check of a requester's signing key
- What: give the bidder's
participant.Verifier(internal/market/participant/comms.go) the verified binding the requester uses (identlink.Remote.GetVerifiedRecord), not a plain getRecord of the requester'sbadgeBlueKeys. - Where:
Verifier.BadgeBlueBinding, used for the RFP and accept checks ofinternal/market/bidder. - Threat: a requester whose PDS is behind a route (a guest requester, a did:key ingress) gets an RFP or accept forged by whoever controls the route.
Guest secrets: getSecrets plaintext at the did:key ingress relay
- What: seal the getSecrets answer end to end to a key the guest makes at boot (it sends an age recipient with the request; the requester answers ciphertext), or serve getSecrets only on an ingress whose TLS ends at the requester. Not implemented.
- Where:
secretsState.fetch(internal/market/requester/secrets.go), setup-secrets (internal/atproto/cloudinit/modules.go); the guest'sSECRETS_URLis the requester's ingress Exposure, on prodhttps://did-key-<key>.xrpc.fedproxy.com, whose TLS ends at the relay host's Caddy; the Go relay (internal/atproto/ingress) carries the answer to the requester's websocket as a JSON body. - Threat: whoever runs or breaks into the relay host (xrpc.fedproxy.com) reads every bundle served on the direct path, in clear, and can answer a guest itself. The relay is ours, but it is a third party to each requester and bidder.
Guest secrets: bind the peer channel to the guest's own iroh id
- What: accept a getSecrets request over iroh only from the guest's iroh endpoint id (
status.contract.vmAddress), or over WebRTC only with the guest agent's DTLS fingerprint (vm.onNetworkkind webrtc). Not implemented (owner, 2026-11-20: a proposal only; the workload identity token check is the authentication). - Where: the requester's iroh Exposure (
svc-requester-<name>-iroh,ingress/iroh:dumbpipe listen-tcpreports no peer id) and its guest WebRTC ingress (ingress/webrtc.Service.Acceptchecks no fingerprint). - Threat: anyone holding the guest's workload identity token (the bidder, which issues it) can fetch over any channel; the binding would add nothing against the bidder and would refuse a guest whose key changed at a reboot.
- Status: after roll two (owner, decision 69, 2026-11-20: the requester's ticket stays public, as the bidders' are).
What it needs: a listener that reads the dialer's id (dumbpipe
listen-tcpcannot; socialweb-meshd'sconn.remote_id()check is the model, or a branch of the owner's dumbpipe fork with an id allowlist reloaded per contract), and a guest that dials with its own key (the agent'sdumbpipe connectruns withoutIROH_SECRET, so its id is random per connection); about 2 to 3 days.
Guest secrets: the bidder vouches for the guest's sealing key
- What: none proposed without a guest attestation. The requester seals to the latest
guest.publicKeytagsecretsof the contract (latestGuestSecretsKey,internal/market/requester/guestsecrets.go), a record the bidder signs and publishes for the guest; a bidder can publish its own key and open the bundle. - Where: the sealed path (comms mode Firehose with
secretsFallback: Sealed). - Threat: a malicious bidder reads the secrets. This is the trust model of the direct path too: the bidder runs the guest's
workload identity issuer (it can mint a token with the guest's
suband fetch getSecrets itself) and runs the VM. The sealed path adds no reader beyond the bidder; it adds the ciphertext on the public protocol (relays, Jetstreams, archives) after the requester deletes the record at release, age X25519 (not post quantum) to be broken later. - Proposal: if the owner wants the published ciphertext to outlive a future break, seal to a hybrid post-quantum recipient (age's ML-KEM-768 + X25519) as well.
GuestControlPlane: the unpinned-download warning is triggerable by anyone who reaches the route
- What: rate-limit
pinned_download_not_pinned(for example one line per name and sha256 per minute, with a count). Not implemented. - Where:
internal/kit/pinneddownloads/pinneddownloads.goServeHTTP(GET /v1/downloads/{sha256}/{name}, unauthenticated; the gateway's downloads route uses the same handler). - Threat: a guest or any peer that reaches the route asks for random sha256s and fills the bidder's journal with WARN lines (disk, log noise that hides real failures).
The requester: release a Held contract after N minutes without a policy verdict
- What: when the recorded-winner recheck (resume after a restart, adopt, a resubmitted accept) gives no verdict for N
minutes (a run that does not complete: deadline, cancel, sandbox down, no PolicyEngine, a deny while trust lookups
failed), treat it as a deny and release the contract. Not implemented: the owner-approved design (commit eca9f345,
docs/spec/integration-catalog.yamlTestRequesterPolicyRelease) is that a run that does not complete fails the step without releasing, so an engine restart does not drop held VMs;untilSettledretries it forTransientResumeGiveUp(2 min) and then the step fails with the last error, the VM still held. - Where:
internal/market/requester/runner.goresumeAccepted,resumeReceipt,adopt(recordedWinnerAllowed). - Threat: a winner whose trust was really withdrawn (vouch deleted) while its reads fail (its PDS or the voucher's PDS down, or answering 5xx on purpose) keeps the requester's VM and its secrets until a recheck completes (the next requester restart) or the contract is released or expires. The trade-off: with the release, any PolicyEngine or PDS outage longer than N minutes releases every held VM of the requester.
- Proposal: keep the design; if the owner wants the bound, release after N minutes only when the run that gave no verdict had unconfirmed trust lookups (a deny with the reads failing), never for an engine, sandbox or deadline failure.
The bidder: end an admitted accept that has no receipt after N minutes
- What: a bidder ends (Obsolete, its capacity hold released) an accept it admitted (answered 202, or took from the firehose)
that still has no receipt N minutes after its admission (N about the requester's
ReceiptTimeout, 5 min by default; the old in-memory hold was 10 min). Not implemented. - Where: the provision StateSync of the accept (
internal/market/bidder/vmsize.goadmitAccept,openHolds): today its hold counts until the sync ends Rejected or Obsolete, settles, or its bid is over (released, failed, expired: the bid TTL, 24 h). No capacity check runs after admission, so a hold never lapses on its own. - Threat: an admitted accept whose attempts keep failing retryably before the receipt (the bidder's own PDS refuses the
receipt write, the policy engine is down, a requester PDS stops answering after the 202) holds its room up to 24 h;
the requester stopped waiting after its
ReceiptTimeoutand failed the contract. A requester that is the bid'sspec.requestercan make this happen on purpose only by making its own records unreadable after the 202 (an unreadable accept is abandoned at 3 to 5 min byunresolvedAccept; an unreadable RFP or payload is retried). - Trade-off: ending it is a timeout that cuts off the counterparty: an accept the requester still waits for (a longer
ReceiptTimeout, a slow PDS) would lose its room and its receipt would never come. Keeping it costs room for at most the bid TTL, only while the bidder itself cannot finish the accept.
The bidder: no single bidder process per state (pre-existing, not built)
- What: a lease (or an flock on the bidder's state dir) so that only one bidder process admits accepts for one bidder.
- Where:
internal/market/bidderadmission (admitAcceptunderadmitMu, in memory per process). - Threat: two processes of one bidder each admit into the same room (their overlays and refusal maps are their own; the
StateSync index catches up within the informer's lag). On a self-update this cannot happen: the update restarts
socialweb-computer-bidder@<handle>.service(install.RestartOwnUnits), and systemd stops the whole control group (KillMode=control-group; SIGTERM, then SIGKILL afterTimeoutStopSec, default 90 s) before it starts the new process, so the overlap is zero. It needs a second process started by hand on the same state (arun bidderbeside the unit, or adev restartracing another), which nothing prevents today.
The bidder: a Releasing or deleted ComputeVM counts nothing against MemTotal (pre-existing, not built)
- What: count a VM's committed memory against MemTotal until its VMM process has exited, not only while it is live.
- Where:
internal/market/bidder/vmsize.gocommitted(liveGuestexcludes Releasing and deleted VMs). - Threat: during a release (seconds) a new guest's MemTotal check ignores memory the old VMM still holds. The MemAvailable check covers it (the old VMM's pages are charged and MemAvailable is lower until they are freed), so the exposure is only the MemTotal sum on a host whose MemAvailable is close to MemTotal.
Approved by the owner and built
The requester reads each bid from the bidder's own repo (approved and built 2026-11-20)
- Owner: "The requester takes bids from a bidder's answer as given: fetch each bid from the bidder's own repo."
- What: the submitRfp answer is never read for a bid (
bidsFromReplyis gone; the lexicon's answer has none and no bidder sent one). Of a submitBid the requester takesuriandcidonly: the service-auth issuer must be the bid URI's authority (as before), the bid is read byuriandcidfrom that repo and only those bytes are used (400 when they do not hash tocid, 503 while unreadable: the bidder retries). The winning bid'sconfig(compute.config.wif.simple, the token issuer of its guest's secrets) must be a record in that same repo, read by its strongRef (an owner question on this refusal is open). Bids from the streams and the catch-up read were already read from the bidder's repo. Not checked: that the bid's DID was one the RFP was sent to. - Where:
SubmitRFPininternal/market/requester/market.go,SubmitBidininternal/market/requester/callbacks.go,resolveBidConfigininternal/market/requester/secrets.go.
Every bid and receipt is signed by a key bound to the bidder (approved and built 2026-11-20, decision 71)
- Owner: asked "verify the signature on every bid before it is queued, and prove the key-binding record is really in the bidder's repo by verifying the repo's signed commit against the DID document's key (the same check the vouch walk already does)", answered "Bids and receipts, in the batch".
- What: before a bid is queued, by
SubmitBidor by the bid mailbox (the streams and the catch-up read feed it), one check (verifyBid): an inline signature must verify and its key must be a key of the DID document of the repo that holds the bid, or bound by that repo'sbadgeBlueKeysrecord read withcom.atproto.sync.getRecordand taken only when the CAR, the MST path and the commit signed by the DID document's atproto key check out (identlink.Remote.GetVerifiedRecord; the DID document from the PLC directory, never through the route). A signature entry whoseissuernames another DID counts for nothing. A refusal answers 403 (requester_bid_refused); a failed lookup is an error, never "not bound" (SubmitBid answers 503, the mailbox tries again every 2 s and leaves the bid out after 2 min,requester_bid_verify_gave_up: a PLC or PDS outage fails closed). Receipts (VerifyReceipt) get the same rule; before, any key named inside the receipt's signature entry verified. Guest events use the same verified binding. A bound answer is kept 5 min; "not bound" and a failed lookup are never kept. The catch-up read checks the bid's bytes against the cid its server reported. The bidder offers and bids only once its binding is written and read back (retried with backoff). - Where:
internal/market/requester/keybinding.go,verifyBidandverifyOptionsinevents.go,SubmitBidincallbacks.go,processBidMailboxininbox.go,verifyReceiptinrunner.go;CheckRecordSignaturesininternal/atproto/market/attest.go,VerifyReceiptincontract.go;GetVerifiedRecordininternal/identlink/remote.go. - Threat it stops: a route in front of a bidder's PDS or market endpoint (every prod bidder today) forging a bid, its payload,
its config (bound to the signed bid by cid) or a receipt. What it leaves: "The bidder's check of a requester's signing key",
"A policy input that cannot be read", "An invalid receipt leaves the bidder's VM running". Upstream by design, not ours to
close: a route can replay an older signed commit; TLS ends at the relay;
badgeBlueKeysis unsigned and has no purpose separation (service); offerings are unsigned; no solicitation check.
Record reads by strongRef check the bytes against the content id (approved and built 2026-11-20)
- Owner: "Record reads trust the content id the server reports: check the bytes against the id asked for."
- What: where a record is read with a known content id, the record value is decoded with exact integers (int64), encoded
as dag-cbor (indigo
atdata, the encoder our PDS writes with), hashed (CIDv1, dag-cbor, sha2-256) and compared with that id. Per site:HTTPReader.Resolve,RepoStore.Resolveandremote.Repo.Resolvefail hard (recordcid.ErrMismatch) unless the bytes hash to the id the server reports instead, which is another version and answers not found (before, the market readers took any version);pdsclient.GetRecordwith an expected cid and the stream sink's relay fallback deliver another version under its own cid (as main did) and fail hard otherwise (the stream sink then neither falls back to another source nor fetches thaturi|cidagain within 15 s); the policy engine compares the cid its verified repo tree holds and answers another version as not found. The caller's own retry rules apply to not found; a mismatch is not retried. A read by URI alone (the latest version) has no id to check. - Where:
internal/atproto/recordcid;internal/atproto/market(http.go,repostore.go),internal/atprotorepo/remote,internal/atproto/pdsclient,internal/eventstream/market.go,Resolver.Resolveininternal/policyengine/trust. - Proof the encoder agrees with the PDSes (2026-11-20,
hack/recordcheck): see plan 0054 Proof for the counts.
Ingress relay: a registration is bound to its key and to the token's issuer (approved and built 2026-11-19)
- Owner: "only a signature by the key being registered counts, and the token issuer must equal it".
- What:
getRegistrationNonceanswers 403IssuerMismatchunless the service-authissequals thekeyasked for;subscribeanswers 403IssuerMismatchbefore the upgrade unless theissequals thedidparam; the registration counts only signatures whosekeyis the registration'skey(no signature by the registered key). A newer subscription of the same key still takes the route, and the relay now closes the replaced socket with 4009. - Where:
internal/atproto/ingress/nonce.goVerify,signaturesBy,verifySignatures;internal/atproto/ingress/server.gohandleNonce,handleSubscribe,denyIssuer. - Threat it stops: anyone who reaches the relay self-signs a token with a fresh did:key, asks a nonce for another DID, signs it with its own key and subscribes as that DID: it got that DID's host (
<label>.xrpc.fedproxy.com: submitRfp, submitAccept, submitEvent, getSecrets) and the victim was never told. Reproduced on a local relay of main d349ef83 for a did:key and a did:plc victim; refused on the fix (docs/plans/0040-findings.md).
The bidder: admission sets aside the memory every admitted guest has not taken yet (owner decision 73, built 2026-11-20)
- Owner (2026-11-20, decision 73): "we have to close the little free memory potential failure gap, we should serialize VM start requests on a bidder so that we reject if starting one means the next won't have capacity to start. Not serialize the starting, but just the queue to start them."
- What: a guest is admitted (and bid for) only when its committed memory (
VMCommitMiB) fits in MemAvailable less the memory owed to admitted guests that have not taken it: every unplaced hold's whole committed memory and, for every live ComputeVM, its committed memory less the anonymous memory of its cgroup (memory.statanon) (the whole committed memory while its cgroup is not found or not readable). Before it, a hold stopped counting once its VM was listed, while the VMM had not touched the guest's RAM, so a burst of accepts was admitted against the same MemAvailable (hat-10, 16 GiB with about 7 GiB available: up to 3 guests of 4G, capped only by MemTotal; now 1). Admission is the one queue (admitAcceptunderadmitMu); the starts still run in parallel. - Where:
internal/market/bidder/vmsize.gocommitted,unrealizedMiB,capacityRefused.
Test host delete guard: a run's guest requester's own rentals (approved and built 2026-11-18)
- Owner: "Both" (2026-11-18, of the two fixes for 0005:b's orphan guest-requester VM: this guard and the bidder ending a VM whose association no longer verifies).
- What: the swc-test-host kube guard deletes a ComputeVM whose receipt is one of this run's, or (new) whose
spec.requester.didis a guest requester this run's own requester associated: thesubjectof arequester_association_writtenline in the request log of one of this run's invocations (the requester writes it only after it proved the guest's associationRequest by its nonce). Nothing else: FirecrackerVM and QemuVM still need a receipt of this run. - Where:
tests/host/src/main.rs(theatlibs_kube::Guard),tests/host/src/swc.rs(Swc.associated, filled by the request log follower); used bytests/modules/acc-0005/src/lib.rsr2_vms, only after its assertion window.
PDS: com.atproto.server.createAccount is closed on an identity's own PDS (approved and built 2026-11-18)
- Owner: "Own account only: a requester's, bidder's or gateway's own PDS refuses createAccount once its identity's account exists. A market network's PDS (staging's, for throwaway test accounts) stays open unless its operator sets otherwise."
- What: Pds
spec.accountCreationClosed(default) orOpen; Closed answers 400InvalidInviteCodeto every XRPCcreateAccountanddescribeServersaysinviteCodeRequired: true; the application's own code makes the identity's and its co-located accounts through the bus handlepds.accountin process. The market network composer setsOpenon the network's alice and bob Pds. - Where:
internal/atproto/pds/accounts.gohandleCreateAccount,WithLocalCaller;internal/pds/local/accounts.goCreateAccount;internal/services/pds/service.go;internal/app/marketnetwork/desired.go;api/v1alpha1/types_component.goPdsAccountCreation. - Not built: an operator option to close a market network's Pds (
MarketNetworkhas no field for it; the network's Pds is always Open); removing the accounts already made from outside.
Vault atproto plugin: a zoned IPv6 literal is judged without its zone; the zone wildcard skips address hosts (approved and built 2026-11-18)
- Owner: "Fix it: strip the zone before the public-address check, and skip the zone wildcard for hosts containing ':' or '%'"
- What:
publicAddrstrips the zone before the prefix checks;trustedAddrskips the*.<zone>entries oftrusted_hostsfor a host holding:or%. - Where:
cmd/openbao-plugin-auth-atproto/netguard.gopublicAddr,trustedAddr.
Read-only operations routes behind a shared secret (approved and built 2026-11-18)
- Owner: "Can't we expose some read only metrics/logs routes protected by some shared secret we provision into the CI so those tests still have what they need? Keyword READONLY"
- What: GET-only XRPC queries
com.fedfork.exec.ops.{listVms,getVm,getBidder,getHealth,getLog,getVmMemory}on a bidder's market endpoint andcom.fedfork.exec.ops.getRequesterLogon the SshServer's web origin, each one fixed projection of the fields the tests read, never a whole status (docs/SYSTEM.md, Market Protocol, XRPC).Authorization: Bearer <secret>, compared in constant time; absent (404) unless a 0600 secret file is configured; 401 otherwise; no write, no selector, no path parameter, no shell. - Input checks that are part of it:
namea DNS label (a VM's cgroup is found by its exact unit name),subjecta DNS label or an at:// URI,dida DID,sinceRFC 3339,msgone of the fixed message names (internal/contract/opsread); a log answer holds at most 50 lines of fixed keys, an error text at most 160 characters; a secret file that group or others can read is refused (the routes stay absent, one warning). - Where:
internal/services/opsread/routes.go(LoadSecret,RegisterBidder,RegisterGateway),internal/contract/opsread,internal/opsread/hostread,internal/controllers/opsread,internal/services/bidder/routes.go,internal/services/sshserver/service.go. - What the holder of the secret reads of other tenants (reviewer's list):
listVms,getVmandgetVmMemoryanswer for any VM of the bidder (name, requester DID, receipt URI, phase, image sha256, memory figures);getLogreturns the first 50 matching lines across tenants;getRequesterLoganswers for any DID. - Decided by the owner, not built (2026-11-18): that reach is "Expected": "take no action" (no per-tenant allowlist); "one secret for all": one shared secret for every bidder and the gateway, no per-host or derived secret. The test host sends it to
https://origins only, or, for a bidder whose offering has no https endpoint (prod: iroh and webrtc only), inside the iroh connection to the iroh market endpoint its ownmarket.offering/selfrecord names (the same listener and mux every requester dials; no new listener, route or exposure); never overhttp://. - Proposed, not built (the owner has not approved any): a minimum secret length; throttling of the routes; a limit on concurrent reads (each
getHealth/getLogscans the log); secret rotation; a cap on how many VMslistVmsreturns. - Rejected by the owner: an ssh or iroh route from the CI VM to the bidder hosts (their shells, kcp, journals). The bidder's own public iroh market endpoint is not such a route: it serves only the market mux.
The bidder: a webrtcUDPPorts range that overlaps other host UDP sockets
- What: when the bidder starts, refuse (or warn on) a
spec.guestNetwork.webrtcUDPPortsrange that overlaps the host'snet.ipv4.ip_local_port_range(ephemeral source ports of any host process) or, on a host that runs kube-proxy or k3s, the NodePort range 30000-32767 (which holds the default 31000-31999). - Where:
internal/services/bidder/webrtcports.gowebrtcPorts(today it checks only 1024-65535); the range feeds the owner-approved accept rule of decision 54 (internal/guestnet/fence_linux.go: UDP from a guest's tap to the host's own addresses on a destination port in the range). - Threat: a guest reaches ANY host UDP socket bound in the range on the host's own addresses (another guest's forwarded
webrtc port, the bidder's own mesh endpoint
bidder-mesh, other bidders' leases, pasta's outbound sockets of other guests, and with an overlapping range any ephemeral or NodePort socket of the host). Read 2026-11-20 (read only): every prod hat hasip_local_port_range32768 60999 (no overlap with 31000-31999); hat-7, hat-9 and hat-10 each have one wildcard UDP socket in 31000-31999 (31846, 31005, 31633), hat-8 four (31006, 31187, 31465, 31777); their owners were not read (ss -pof another account needs root): presumably the bidders'bidder-meshleases and, on hat-8, local dev networks' bidders.
Existing, not owner-approved
For the owner to keep, change or remove. Listing them changed none of them. Line numbers are of the base of the pull that listed them (fix-marker-cap).
| Control | Where | Value | Added | Real reason |
|---|---|---|---|---|
| Requested image manifest size | internal/guestimage/requested.go:24 RequestedManifestMax | 64 KiB | bd1686a1 (2026-11-13) | every bidder reads a requester-named URL into memory per RFP; bounds that read |
| bootArgs length of a requested image | requested.go:26 RequestedBootArgsMax | 4096 bytes | bd1686a1 | none beyond the manifest cap; a kernel's own command line ceiling is per kernel (2048 on x86 builds), the number is arbitrary |
| Dial and TLS handshake timeout of the image fetch | requested.go:30 RequestedDialTimeout | 10 s | bd1686a1 | a requester-named host that never answers would hold a bidder goroutine |
| Response header timeout of the image fetch | requested.go:32 RequestedHeaderTimeout | 30 s | bd1686a1 | same |
| Manifest fetch timeout | requested.go:34 RequestedManifestTimeout | 30 s | bd1686a1 | same; also what turns a slow host into a "unavailable now" decline |
| Whole image download timeout | requested.go:36 RequestedFetchTimeout | 30 min | bd1686a1 | a stuck download holds an accepted VM and its reservation; also added to the requester's contract timeout (internal/market/requester/image.go:47, cmd/socialweb-computer/request.go:367); a 589 MB image needs 0.3 MB/s |
| Cache of fetched manifests | requested.go:106 manifestsMax | 256 entries, cleared when full | 705c1c20 (2026-11-13) | memory bound of a cache keyed by requester-chosen URLs |
| Public addresses only, no redirects, https base only, no userinfo/query | requested.go Valid, PublicClient, PublicAddr | n/a | bd1686a1 | the bidder fetches a requester-named URL: stops reaching its own network (SSRF); the full fix is deferred (docs/FEATURES.md Known limits) |
| Kernel + rootfs within the request's disk | requested.go Manifest.CheckFor | disk of the RFP | bd1686a1 | the rootfs clone must fit the VM disk, or the VM cannot boot |
| Requested image must match the bidder's target, hypervisor and arch | requested.go Manifest.CheckFor | exact match | bd1686a1 | the bidder's VMM cannot boot another target's kernel |
| bootArgs, vcpu and memMiB must be present | requested.go Manifest.CheckFor | non-empty | bd1686a1 | a kernel needs a command line; a VM needs a size |
| Requested images kept within a disk budget | internal/guestimage/gc.go:26-27 DefaultBudget, DefaultMinFree | 16 GiB, 8 GiB free | 81d35e02 (2026-11-13) | requester-chosen images would fill the bidder's disk |
| Reservation of an accepted VM's capacity | internal/market/bidder/bidder.go:36 AcceptReserveHold; :38 ReservedVMSeenGrace | 10 min; 1 min | 8b04fd2c (2026-11-13) | a requester that never completes provisioning must not hold capacity for ever |
| Accept replacements per round | internal/market/requester/runner.go:371 MaxAcceptReplacements | 3 | 8b04fd2c | bounds the accept/decline loop on one RFP before a new round |
| Capacity wait | runner.go:415-419 CapacityBackoffFirst, CapacityBackoffMax, DefaultCapacityWait | 30 s, 2 min, 30 min (the contract's own deadline overrides) | d1fdc057 (2026-11-14) | a contract with no deadline must end somewhere |
| Give up on an accept whose record is gone | internal/market/bidder/acceptgiveup.go AcceptGiveUpTries, AcceptNotFoundGiveUpAfter, AcceptUnreachableGiveUpAfter | 5 tries and 3 min (not found); 30 min (PDS unreachable) | f439fb2f (2026-11-14) | a deleted accept was retried 195 times on a prod bidder; the ages are a guess at replication lag |
| Fail a bid whose RFP is gone | acceptgiveup.go RFPGiveUpTries, RFPNotFoundGiveUpAfter | 3 reads and 2 min | f439fb2f | same; the 10 min bid window (RFPBidWindow, internal/atproto/market/rfpwindow.go:10, 8dc74cef 2026-10-25) already bounds a deciding bid |
| Infra index reconcile | internal/controllers/infra/index.go:37-43 IndexVerifyMax, IndexVerifyEvery, IndexVerifyWorkers, IndexVerifyBudget | 64 reads per write (256 the first time), 10 min per entry, 8 in flight, 6 s | b046b88b (2026-11-14) | bounds the PDS reads one index write may do and how long it blocks an Infra reconcile worker |
| Guest-originated event size | internal/guestidentity/guestrecord.go:434 MaxGuestEventBytes | 24 KiB | 86c62c28 (2026-10-24) | a guest is untrusted; bounds the record the bidder publishes for it; also bounds a guest.image marker now that its own cap is gone |
| Pinned guest image re-verification | internal/market/bidder/bidder.go:49 ImageRetry | 1 min | f62a6914 (2026-11-13) | cadence of the bidder's own check, not a limit on input |
Removed by the owner's direction
The 256 byte cap of an image marker: RequestedMarkerMax (requested.go), MaxGuestImageMarker and its printable-ASCII check
(guestrecord.go) and maxLength: 256 of com.publicdomainrelay.temp.compute.events.guest.image, from commits bd1686a1 and 254722b8.
Vault atproto plugin: a zoned IPv6 literal passes the public-address guard (existing control, a bypass)
- What:
publicAddrtreats::1%x,fe80::1%eth0,fd00::5%1as public, becausenetip.Prefix.Containsis false for a zoned address; the repair isa.Unmap().WithZone("")there, or refusing a host with%incheckURL. - Where:
cmd/openbao-plugin-auth-atproto/netguard.go:34-42,107-123; reachable from a DID document's PDS endpoint or a did:web identifier (identity.go:15,87-99). - Threat: a signing-in party makes the vault plugin open TCP (a TLS ClientHello) to its own loopback or a link-local/ULA IPv6 address at any port: a blind port probe (no response body; certificate verification fails). Seen by a review probe (2026-11-18, ~/.tmp/trust-review-probe). Prod and networks alike.
- Status: approved by the owner and built 2026-11-18 (owner: "Fix it: strip the zone before the public-address check, and skip the zone wildcard for hosts containing ':' or '%'"):
publicAddrstrips the zone. See "Approved by the owner and built".
Vault atproto plugin: the zone wildcard matches by bare suffix
- What: skip the
*.<zone>entry when the host contains:or%(asinternal/atproto/oauth/client.gonames()does). - Where:
cmd/openbao-plugin-auth-atproto/netguard.go:61-65. - Threat:
[::1%25.stg.test]:443counts as a trusted network name (so http is allowed); the dial is still rewritten to the front's fixed address, so it cannot be steered. - Status: approved by the owner and built 2026-11-18 (owner: "Fix it: strip the zone before the public-address check, and skip the zone wildcard for hosts containing ':' or '%'"):
trustedAddrskips the wildcard entries for a host holding:or%. See "Approved by the owner and built".
PDS: com.atproto.server.createAccount is open to anyone who reaches the PDS (SEEN USED, 2026-11-18)
- What: an invite / allow rule on
createAccount(for a requester's, bidder's or gateway's own PDS: no account but the identity's own; for a network PDS: what the network's operator sets). - Where:
internal/atproto/pds/server.go:224(POST /xrpc/com.atproto.server.createAccount),accounts.gohandleCreateAccount: no invite, allow or admin check. - Threat: anyone who reaches a PDS through its public ingress name makes an account on it: free hosting under our name (records, blobs), a real did:plc signed by our PDS's rotation key, and, for a single-account identity, a refusal to start again ("the identity <name> PDS holds 2 accounts; one identity serves one account",
internal/stack/request/identity.go:255). Seen: 2026-11-18T09:56:55Z an accountbarb.<host>.xrpc.fedproxy.com(did:plc:m57euzk3yz5fv6erfo2mccae) was made on alice's hand requester identity alice2 (root.requester.aliceoa.bsky.social) while it ran; it made an app password and one record with a blob 28 s later; the hand runner's next start failed. Evidence (a full copy of the identity's state, 0700): ~/.swc/evidence-alice2-20261118T115916Z. - Status: approved by the owner and built 2026-11-18 (owner: "Own account only: a requester's, bidder's or gateway's own PDS refuses createAccount once its identity's account exists. A market network's PDS (staging's, for throwaway test accounts) stays open unless its operator sets otherwise."): Pds
spec.accountCreationClosed by default, Open on a market network's Pds. See "Approved by the owner and built".
Ingress relay: a registration is not bound to its key or to the token's issuer
- What: count only a registration signature whose
keyis the registration'skey, and/or require the service-auth issuer of getRegistrationNonce and subscribe to be that key (the subscribedid). - Where:
internal/atproto/ingress/nonce.go:84-102(verifySignaturestakes a signature by any key),server.go:466-488(a nonce is issued for anykey; the token's issuer is not compared),server.go:503-538(the subscribedidis compared with the registration key only;#renewis the one place the issuer is checked,server.go:719). - Threat: anyone holding a valid service-auth token for the relay (any DID; aud the relay, lxm the method) asks a nonce for another DID, signs it with its own key and subscribes as that DID; the relay then routes
<that DID's label>.xrpc.fedproxy.com(a bidder's or requester's market endpoint: submitRfp, submitAccept, submitEvent, getSecrets with the guest's workload token) to it, until the DID's own subscriber connects again and replaces it. The relay's DID allowlist (didAllowed), when set, limits which DIDs, not who may claim one. Read from the code by the lexicon sweep (2026-11-19,lexicons/com/fedproxy/temp/xrpc/registration.json), not tried. - Status: proposed; not built.
Guest boot: the dumbpipe fetch checks no sha256
- What: the guest's cloud-init install script checks the dumbpipe archive against the versions.json sha256 of its arch (as
deploy/bidder/preinstall-market.jsonalready does for the image build) and refuses a mismatch. - Where:
internal/atproto/cloudinit/modules.go(the dumbpipe install script:curl,tar -xzf,install; nosha256sum -c). It runs only when the image's/usr/local/bin/dumbpipe.versiondiffers fromcloudinit.DumbpipeVersionDefault(a guest booted from an older image than its bidder's cloud-init). - Threat: a changed or substituted release asset on GitHub (or a path to it) becomes the guest's ssh listener (
iroh.service, root) with no check; the image build and the host embed are pinned, this path is not. - Status: proposed; not built.