~ knotless Search/
↑↓ move↵ open⇧↵ all results

socialweb.computer/socialweb-computer-kcp

socialweb.computer: a compute market on atproto (kcp)

1 collaborator
0
0
343 lines · 38.7 KB Raw History

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 SHA256SUMS of a release (a detached signature by a key published out of band, or a record in the owner's repo), and have docs/bidder.md verify it.
  • Where: docs/bidder.md "Binary" (rc and main builds verify against the SHA256SUMS fetched from the same bucket directory); README.md pins the hashes inline for one rc.
  • Threat: whoever can write the bucket replaces the binary and its SHA256SUMS together; 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() in tests/modules/staging/src/lib.rs could refuse an oci:<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.sh from oci-push.sh output; 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 bidder and dev up could refuse --cpu-overcommit below 1 (and a MarketBidder spec.cpuOvercommit below 0). Not implemented: 0 means the default 2, and a negative value commits no vCPUs, so the bidder bids on nothing.
  • Where: vmLimits in internal/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-host the 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_uri from a name under its network's domain, refuse a connection whose resolved address is not one the network value names (its dns, xrpcFront and hosts addresses). 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.go httpClientFor, internal/services/pds/service.go oauthNetwork.
  • 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} without value; bid-payload (internal/policyengine/bundled-actions/tangy/policy-bid-payload, createBidPayloadFilterPolicy) then answers allow: true when no offer is present. requester-tangled-vouch and the other trust policies never read the bid's value.
  • Where: those two places; the requester's winner run (runner.go the winnerPolicy step) 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 (acceptReceipt in internal/market/requester/runner.go: Failed receiptInvalid), 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: releaseContract names state.Receipt, the invalid receipt, which the bidder refuses ("the inbound event names another receipt", seen 2026-11-20 in run a2-main).
  • Where: acceptReceipt and releaseContract in internal/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's badgeBlueKeys.
  • Where: Verifier.BadgeBlueBinding, used for the RFP and accept checks of internal/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's SECRETS_URL is the requester's ingress Exposure, on prod https://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.onNetwork kind 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-tcp reports no peer id) and its guest WebRTC ingress (ingress/webrtc.Service.Accept checks 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-tcp cannot; socialweb-meshd's conn.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's dumbpipe connect runs without IROH_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.publicKey tag secrets of 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 sub and 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.go ServeHTTP (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.yaml TestRequesterPolicyRelease) is that a run that does not complete fails the step without releasing, so an engine restart does not drop held VMs; untilSettled retries it for TransientResumeGiveUp (2 min) and then the step fails with the last error, the VM still held.
  • Where: internal/market/requester/runner.go resumeAccepted, 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.go admitAccept, 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 ReceiptTimeout and failed the contract. A requester that is the bid's spec.requester can 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 by unresolvedAccept; 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/bidder admission (admitAccept under admitMu, 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 after TimeoutStopSec, 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 (a run bidder beside the unit, or a dev restart racing 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.go committed (liveGuest excludes 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 (bidsFromReply is gone; the lexicon's answer has none and no bidder sent one). Of a submitBid the requester takes uri and cid only: the service-auth issuer must be the bid URI's authority (as before), the bid is read by uri and cid from that repo and only those bytes are used (400 when they do not hash to cid, 503 while unreadable: the bidder retries). The winning bid's config (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: SubmitRFP in internal/market/requester/market.go, SubmitBid in internal/market/requester/callbacks.go, resolveBidConfig in internal/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 SubmitBid or 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's badgeBlueKeys record read with com.atproto.sync.getRecord and 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 whose issuer names 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, verifyBid and verifyOptions in events.go, SubmitBid in callbacks.go, processBidMailbox in inbox.go, verifyReceipt in runner.go; CheckRecordSignatures in internal/atproto/market/attest.go, VerifyReceipt in contract.go; GetVerifiedRecord in internal/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; badgeBlueKeys is 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.Resolve and remote.Repo.Resolve fail 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.GetRecord with 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 that uri|cid again 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.Resolve in internal/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: getRegistrationNonce answers 403 IssuerMismatch unless the service-auth iss equals the key asked for; subscribe answers 403 IssuerMismatch before the upgrade unless the iss equals the did param; the registration counts only signatures whose key is the registration's key (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.go Verify, signaturesBy, verifySignatures; internal/atproto/ingress/server.go handleNonce, 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.stat anon) (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 (admitAccept under admitMu); the starts still run in parallel.
  • Where: internal/market/bidder/vmsize.go committed, 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.did is a guest requester this run's own requester associated: the subject of a requester_association_written line 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 (the atlibs_kube::Guard), tests/host/src/swc.rs (Swc.associated, filled by the request log follower); used by tests/modules/acc-0005/src/lib.rs r2_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.accountCreation Closed (default) or Open; Closed answers 400 InvalidInviteCode to every XRPC createAccount and describeServer says inviteCodeRequired: true; the application's own code makes the identity's and its co-located accounts through the bus handle pds.account in process. The market network composer sets Open on the network's alice and bob Pds.
  • Where: internal/atproto/pds/accounts.go handleCreateAccount, WithLocalCaller; internal/pds/local/accounts.go CreateAccount; internal/services/pds/service.go; internal/app/marketnetwork/desired.go; api/v1alpha1/types_component.go PdsAccountCreation.
  • Not built: an operator option to close a market network's Pds (MarketNetwork has 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: publicAddr strips the zone before the prefix checks; trustedAddr skips the *.<zone> entries of trusted_hosts for a host holding : or %.
  • Where: cmd/openbao-plugin-auth-atproto/netguard.go publicAddr, 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 and com.fedfork.exec.ops.getRequesterLog on 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: name a DNS label (a VM's cgroup is found by its exact unit name), subject a DNS label or an at:// URI, did a DID, since RFC 3339, msg one 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, getVm and getVmMemory answer for any VM of the bidder (name, requester DID, receipt URI, phase, image sha256, memory figures); getLog returns the first 50 matching lines across tenants; getRequesterLog answers 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 own market.offering/self record names (the same listener and mux every requester dials; no new listener, route or exposure); never over http://.
  • Proposed, not built (the owner has not approved any): a minimum secret length; throttling of the routes; a limit on concurrent reads (each getHealth/getLog scans the log); secret rotation; a cap on how many VMs listVms returns.
  • 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.webrtcUDPPorts range that overlaps the host's net.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.go webrtcPorts (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 has ip_local_port_range 32768 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 -p of another account needs root): presumably the bidders' bidder-mesh leases 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).

ControlWhereValueAddedReal reason
Requested image manifest sizeinternal/guestimage/requested.go:24 RequestedManifestMax64 KiBbd1686a1 (2026-11-13)every bidder reads a requester-named URL into memory per RFP; bounds that read
bootArgs length of a requested imagerequested.go:26 RequestedBootArgsMax4096 bytesbd1686a1none 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 fetchrequested.go:30 RequestedDialTimeout10 sbd1686a1a requester-named host that never answers would hold a bidder goroutine
Response header timeout of the image fetchrequested.go:32 RequestedHeaderTimeout30 sbd1686a1same
Manifest fetch timeoutrequested.go:34 RequestedManifestTimeout30 sbd1686a1same; also what turns a slow host into a "unavailable now" decline
Whole image download timeoutrequested.go:36 RequestedFetchTimeout30 minbd1686a1a 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 manifestsrequested.go:106 manifestsMax256 entries, cleared when full705c1c20 (2026-11-13)memory bound of a cache keyed by requester-chosen URLs
Public addresses only, no redirects, https base only, no userinfo/queryrequested.go Valid, PublicClient, PublicAddrn/abd1686a1the 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 diskrequested.go Manifest.CheckFordisk of the RFPbd1686a1the rootfs clone must fit the VM disk, or the VM cannot boot
Requested image must match the bidder's target, hypervisor and archrequested.go Manifest.CheckForexact matchbd1686a1the bidder's VMM cannot boot another target's kernel
bootArgs, vcpu and memMiB must be presentrequested.go Manifest.CheckFornon-emptybd1686a1a kernel needs a command line; a VM needs a size
Requested images kept within a disk budgetinternal/guestimage/gc.go:26-27 DefaultBudget, DefaultMinFree16 GiB, 8 GiB free81d35e02 (2026-11-13)requester-chosen images would fill the bidder's disk
Reservation of an accepted VM's capacityinternal/market/bidder/bidder.go:36 AcceptReserveHold; :38 ReservedVMSeenGrace10 min; 1 min8b04fd2c (2026-11-13)a requester that never completes provisioning must not hold capacity for ever
Accept replacements per roundinternal/market/requester/runner.go:371 MaxAcceptReplacements38b04fd2cbounds the accept/decline loop on one RFP before a new round
Capacity waitrunner.go:415-419 CapacityBackoffFirst, CapacityBackoffMax, DefaultCapacityWait30 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 goneinternal/market/bidder/acceptgiveup.go AcceptGiveUpTries, AcceptNotFoundGiveUpAfter, AcceptUnreachableGiveUpAfter5 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 goneacceptgiveup.go RFPGiveUpTries, RFPNotFoundGiveUpAfter3 reads and 2 minf439fb2fsame; the 10 min bid window (RFPBidWindow, internal/atproto/market/rfpwindow.go:10, 8dc74cef 2026-10-25) already bounds a deciding bid
Infra index reconcileinternal/controllers/infra/index.go:37-43 IndexVerifyMax, IndexVerifyEvery, IndexVerifyWorkers, IndexVerifyBudget64 reads per write (256 the first time), 10 min per entry, 8 in flight, 6 sb046b88b (2026-11-14)bounds the PDS reads one index write may do and how long it blocks an Infra reconcile worker
Guest-originated event sizeinternal/guestidentity/guestrecord.go:434 MaxGuestEventBytes24 KiB86c62c28 (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-verificationinternal/market/bidder/bidder.go:49 ImageRetry1 minf62a6914 (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: publicAddr treats ::1%x, fe80::1%eth0, fd00::5%1 as public, because netip.Prefix.Contains is false for a zoned address; the repair is a.Unmap().WithZone("") there, or refusing a host with % in checkURL.
  • 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 '%'"): publicAddr strips 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 % (as internal/atproto/oauth/client.go names() does).
  • Where: cmd/openbao-plugin-auth-atproto/netguard.go:61-65.
  • Threat: [::1%25.stg.test]:443 counts 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 '%'"): trustedAddr skips 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.go handleCreateAccount: 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 account barb.<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.accountCreation Closed 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 key is the registration's key, and/or require the service-auth issuer of getRegistrationNonce and subscribe to be that key (the subscribe did).
  • Where: internal/atproto/ingress/nonce.go:84-102 (verifySignatures takes a signature by any key), server.go:466-488 (a nonce is issued for any key; the token's issuer is not compared), server.go:503-538 (the subscribe did is compared with the registration key only; #renew is 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.json already does for the image build) and refuses a mismatch.
  • Where: internal/atproto/cloudinit/modules.go (the dumbpipe install script: curl, tar -xzf, install; no sha256sum -c). It runs only when the image's /usr/local/bin/dumbpipe.version differs from cloudinit.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.