If you find a security vulnerability, please report it privately via GitHub Security Advisories. Do not open a public issue.
Do not describe an unfixed issue in a public issue, pull request, commit message, or branch name.
First-party apps run as web projections in the browser's opaque sandboxed frames. Runtime checks each app's signed launch token and actor before it performs an effect. Home can currently obtain every app's capability, so a compromised Home can reach those apps' authority. The target limits Home to delegation and gives each app a separate, revocable capability. The WASM Component authoring path runs in Wasmtime with memory and fuel limits and Runtime Bus hostcalls. Components run inside the Runtime process: separate linear memories, but the same operating system process as Runtime keys. Installed Homes admit only release-path capsules matched by signed CID receipts and capsules signed by the release publisher, so third-party executable capsules need key-free, confined worker processes before they are admitted (World Computer plan).
Providers run as native operating-system processes with the Runtime user's rights. Only the model provider is partly confined. The trusted shell helper also runs as a native host process. The web Terminal is disabled by default; host developer mode and closed guest registration are required to enable it. An enabled Terminal runs commands with the host user's rights.
The seed operator can read hosted data, wallet keys and recovery material. Passkeys control sign-in; stored data and keys remain accessible to the Runtime account and root while Home is locked. Protection against hosted operators and root, and against other software or OS users while a self-hosted Home is locked, is the target of hosted protection and locked Home protection. An unlocked self-hosted Home trusts its owner and their host software. Recovery from a stolen device or profile key requires a new identity.
The isolation plan records the remaining gates. Source checks describe this source tree. Accepted installed proof binds the exact Runtime, components and app assets to the journeys tested on that device.
A new or updated Home starts with Browser internet access off. The Home owner allows this computer's internet connection for Browser from the current Inbox request with a passkey. Runtime binds that approval to its request ID and expiry. Browser Settings offers Manage in Inbox. Inbox confirms Turn Off and requires a passkey. Runtime stores the consent decision separately from the capability token; the decision, Inbox and Browser responses contain no token bytes.
Runtime admits internet access only through VM Browser engines. This includes remote VM engines. Hosted, native and test-only Playwright engines are refused on the Runtime Browser path. The Browser frame uses the VM Open route; legacy Net HTTP, connect, resolve and stream routes return 410. Runtime owns Exit and Net resources. App capability requests and existing app tokens cannot access them. Direct owner shell network writes require an explicit capability token. Each Browser launch receives its own Runtime instance binding. Runtime checks the current grant at provider dispatch and at each Exit relay open. Stop writes the revoked decision before it invalidates the grant generation, cancels Runtime-owned byte copies and acknowledges completion. A provider fetch or Chain call accepted before Stop can still finish. A remote engine can take longer to close, while Runtime has already stopped its copies. An accepted Carrier invocation can keep Stop pending until its reply arrives. Inbox keeps Turn Off available to retry until Runtime confirms cleanup.
The approval display still has the trusted-display gap (#178). Home renders the request and starts the passkey ceremony; WebAuthn does not prove that the person saw that exact text on an independent trusted display. The target is a trusted display that binds what the person sees to the approved effect.
Keys are stored next to the data they protect. Full data-home backups include all keys. Protect those backups and your Recovery Kit as secrets. Encryption with keys stored on the same host leaves those secrets accessible to its operator. Use hosted accounts only for public demos; keep wallets, private data and recovery material on your own device until hosted protection passes its acceptance gate. Independent review and installed proof remain security gates.
The following security-relevant findings remain open in the current runtime and are documented here for transparency.
Severity: Medium
Files: elastos/crates/elastos-runtime/src/capability/manager.rs, elastos/crates/elastos-server/src/security_cmd.rs
Status: Open
Capability signing-key creation and elastos emergency rotate log persistence
errors but continue with in-memory state. The emergency command can therefore
report success even when the new key was not written. Rotation also advances a
fresh in-process capability store rather than a durable epoch record. Until the
key and revocation state are committed atomically, operators must verify the
persisted key and restart result instead of treating command completion as a
durable rotation receipt.
Severity: Medium
Files: elastos/crates/elastos-server/src/carrier.rs, elastos/crates/elastos-server/src/carrier_service.rs
Status: Open (host-plane envelope)
Runtime identifies each Carrier peer by its endpoint key. A key alone gives no
authority. A Home serves a peer's content/fetch only for a CID that an active
publication on it lists, and a Library publication only to a peer whose
authenticated device belongs to an accepted contact of the person who
published it, as receiving Homes take files only from contacts. A protected
listing's sealed payload is served to any peer; opening it needs the key
release a purchase grants. A pin is only local storage: files received in
Chat, models and withdrawn publications stay pinned, and pinned alone is never
served to peers. Unpublish withdraws the record, which stops new transfers of
that file at once, unless another file still shared on this Home (yours or
another person's) has the same contents. The pin stays until a later cleanup.
A Home answers a peer's read in one message and checks again just before
sending it, so a read under way when the publication is withdrawn is refused
on the same terms. Bytes already sent can't be recalled.
Over HTTP, an ordinary Home's raw CID routes (/content/<cid>, /ipfs/<cid>,
/s/<cid>) answer only its own Home and app sessions; a seed keeps its public
CID gateway.
Only a node that serves publisher content (a seed) answers the raw
content_fetch byte operation or serves without these checks. In this
release a seed accepts no new copies from other Homes; copies it already holds
stay. A Home accepts a new copy from a peer only if the owner gave that peer
the content.replica permission; copies it already holds stay. The owner
trusts such a peer like an own device: it can ask the Home to pin content,
import complete content and read storage status. An import pins only the CID
it was asked for and never removes an existing pin. No peer can publish,
remove or repair content on a Home or a seed. Peers cannot use the
availability provider. A Home signs an availability announcement only from its
own pin state. Peers cannot push or read gossip messages directly. Only topics
that a Home joins keep messages, to a maximum of 100 topics. A granted peer's
ensure (once the pin succeeds) announces the CID and joins its topic, so a
granted peer shares that limit with the Home's own topics. A granted peer's
import_exact, admission and status, and any peer's fetch, join no
topic. No peer can push a whole object with import_object.
Host-process provider capsules use a raw operation and path envelope without a capsule capability token. Runtime owns admission for this trusted provider class. Manifests and audit output must show this boundary. The envelope does not grant capsule authority.
Files: elastos/crates/elastos-runtime/src/handler/io_bridge.rs
Status: Open
The I/O bridge rejects complete lines above 1 MiB, but its line readers allocate before that check. Size checks after reading do not bound memory use or an incomplete frame's lifetime. Add bounds while reading, with oversized and slow-frame tests.
Files: elastos/crates/elastos-server/src/carrier.rs
Status: Open (#341)
A whole-object content fetch reply arrives as one line. It is refused while reading once it passes one 200 MiB file as base64 (about 268 MiB), the largest file Runtime downloads whole. Only two such fetches run at once, and one per peer.
Severity: Low
Files: elastos/crates/elastos-server/src/collaboration_discovery_runtime.rs, elastos/crates/elastos-server/src/collaboration_contact_store.rs
Status: Open (#86)
Anyone who has a Profile's DID can send it one contact request through the seed's Community node, whether or not that Profile is visible in Discovery. The node learns which Profile asked which and holds the requester's signed Profile; it learns nothing more about the recipient until the recipient answers in Inbox. Only the device that signed a request, answer or mailbox read may submit it, and the recipient's Home checks every request and answer itself. Profiles and devices are free to create, so the per-sender and per-device limits bound one identity only: many new identities can fill one person's 16 request slots on the node until those requests expire after 24 hours, and that person's other requests wait meanwhile. Leave Community stops all requests.
These findings are resolved in source but remain listed as security history because they shaped the runtime contract.
Severity: Low (reduced from Medium)
Files: elastos/crates/elastos-runtime/src/handler/io_bridge.rs
Status: Fixed (2026-03-28)
The I/O bridge rejects complete request lines above 1 MiB before parsing. The
old carrier_bridge.rs has been removed. This resolved parse-size check does
not close the read-time framing gap above.
Files: elastos/crates/elastos-server/src/carrier.rs, elastos/crates/elastos-server/src/operator_control.rs
Status: Fixed
Lines from peers are read with a size cap and a deadline, and longer lines are refused before they are buffered. Incoming Carrier requests allow one provider request or one gossip message plus envelope, within 10 seconds. Operator requests, read before their signature is checked, allow 64 KiB within 10 seconds. Replies are capped by what the request can return: a full gossip topic for a pull, one importable object for a provider call, update metadata for an operator answer. Provider replies share a 256 MiB in-flight budget. Whole-object content fetch replies allow one 200 MiB file as base64; the open item above tracks streaming them. Relays close after five minutes without bytes in either direction, and stream acknowledgements have deadlines.
Runtime validates signed capability tokens against the caller, action, resource, epoch, revocation and token constraints. It checks principal and session authority separately. Carrier authenticates transport endpoints; Runtime verifies product identity and signed message authority before exposing typed app projections. These checks complement the current browser boundary and do not establish provider process confinement or a separate Home authority.
See docs/ARCHITECTURE.md for the full trust model.