Can I trust this with my fleet?
This page summarizes the security model in the DeviceChain docs: what is enforced today, how releases are signed, and what is not there yet. It adds nothing to the docs. Every section links the page that states the detail in full.
Tenant isolation is enforced in the data and the messages.
- One set of services serves every tenant, so isolation is enforced in the data and the messages, not by separate pods.
- Tenant-owned tables carry the tenant, and a central database scope adds the tenant condition to every read and stamps it on every write. A tenant-scoped query that has no tenant in its context is rejected, not run unfiltered.
- Messaging subjects are scoped per tenant, and a malformed tenant segment is rejected where a service publishes or subscribes.
- The tenant of a request comes from the tenant claim of the caller's verified token. A service calling another service names the tenant in a header, which is honored only after the service token's signature is verified.
In the docs: Security model: tenants · Multi-tenancy: isolation
A device can speak only as itself.
- The broker's MQTT and NATS listeners use TLS by default. HTTP ingest is protected by the TLS of the instance's ingress.
- The broker asks the platform to approve each connection, and the platform binds the connection to that one device's subjects. A device cannot publish into another device's or another tenant's subjects, or read their commands.
- Device passwords and access tokens are stored only as keyed one-way digests, under a key derived from the instance root key. Each is shown once, when it is set.
- On the platform's own MQTT broker, a device can authenticate with an X.509 client certificate. The platform checks the chain against a trust anchor the tenant added, at every connect, requires the client-authentication key usage and refuses SHA-1 and weak keys. The device proves its key in the TLS handshake, so nothing replayable is stored or sent.
- A fleet can self-register with a server-generated 256-bit secret, stored only as a keyed digest and compared in constant time. Every way authentication can fail gets the same answer, so the response never says which part was wrong.
- Disabling, rotating or deleting a credential refuses new connections at once and ends the device's open sessions.
In the docs: Security model: devices · Certificate identity · Connecting with a certificate · Device self-registration · Device credentials
Updates are checked for integrity, and signed by keys you register.
- Uploaded bytes must match the artifact's declared size and SHA-256 digest. A body that does not match is discarded and the artifact stays in the uploading state.
- Signers are registered per tenant as public keys (ECDSA P-256 or Ed25519). The platform never needs a private key, and one is refused.
- By default, an artifact that no registered signer has signed cannot be assigned.
- An assignment of a signed artifact hands the device the signature over the artifact's digest. Your device must verify it before it installs; checking it on the device is the device's job, and the device must also enforce version and component, which the signature does not cover. The update path has been validated end to end against the reference device.
- The update service is part of the default install profile.
In the docs: Over-the-air updates: signers · What "verified" means · Signing updates
Stored secrets are sealed, and write-only.
- Credentials a tenant stores, such as connector settings and identity-provider client secrets, are kept in an encrypted secret store.
- Each value is sealed with its own AES-256-GCM data key, and that key is wrapped by the instance root key.
- A value is write-only over the API: it is resolved inside the server when it is used and never returned. Changes are audited by who, when and which handle, never by value.
- The root key has a documented escrow and restore procedure, and an escrow copy can be checked with
dcctl secrets escrow verify.
In the docs: Security model: secrets · Disaster recovery: the root key
Where a tenant's webhooks and connectors may send is checked at connect time.
- Webhooks, mail relays and outbound connectors are checked at the moment each connection is made, against the address the name actually resolved to.
- Loopback, private, carrier-grade NAT, link-local and cloud-metadata addresses are refused by default. An operator can permit specific private addresses, and an allowance applies to every tenant and every connector and webhook.
- For Kafka, every broker the cluster advertises is checked, not only the addresses you configured.
In the docs: Security model: outbound traffic · Outbound connectors: where a connector may send
API requests are authenticated and checked against permissions.
- Sign-in issues RS256-signed tokens. Each service validates them locally against a published key set. Signing keys are held by one service, sealed under the instance root key.
- Roles carry permissions, and the API checks them on each call. A membership can be limited to a customer's data, and members, invitations and roles a tenant manages for itself cannot grant more than the person granting them holds.
- Service accounts exchange a client ID and secret for a 5-minute access token, with no refresh token and no person's sign-in.
- A tenant can require sign-in through its own OpenID Connect identity provider, and accounts can require a code from an authenticator app after the password.
- The service-token endpoint and the signing-key set are served on a separate internal port that no ingress, route or load balancer refers to.
In the docs: Security model: people and programs · Two-factor authentication · Endpoints that never leave the cluster
An AI agent can never do more than the person who authorized it.
- The optional MCP server is opt-in. Its tools read under the caller's own token; in Preview, with agent actions switched on, an agent can also propose acknowledging or clearing alarms, and only a person's approval in the console carries one out.
- It sits behind an OAuth 2.1 authorization server: authorization code with PKCE, RFC 8414 metadata, refresh-token rotation and RFC 8707 audience binding.
- The server holds no token of its own. Every call runs under the caller's own token, so an agent reads only what its user can read.
In the docs: MCP: the security model
Changes are journaled with who made them.
- Every service records a journal entry, with the acting identity, for each create, update and delete it makes to a tenant's data.
- The sign-in service also records sign-in events such as logins, failed logins and single sign-on outcomes.
- A registry entry is written in the same transaction as the change it describes.
In the docs: Security model: audit
Check what you run before you run it.
- Every service image, the operator, the edge agent, the broker administrator, the message broker and console images, and the Helm chart are signed with cosign, keylessly. Each signature is bound to the release workflow and the tag, and recorded in a public transparency log.
- Each image also carries a signed SPDX list of what is inside it (an SBOM), and the images and the chart carry SLSA build provenance. The SBOM is generated from the amd64 variant.
- One script checks every image and the chart, and then proves its own check can fail by rejecting an identity that cannot match and an image that was not signed for the release.
- The dcctl and edge agent archives carry build provenance, and every npm package version from 0.14.0 onward carries npm provenance.
- Signing starts at v0.25.0.
In the docs: Verifying releases · The verification script · What verification does and does not tell you · npm packages
Report a vulnerability privately.
- Please do not report vulnerabilities through public issues, discussions or pull requests.
- Use GitHub's private vulnerability reporting on the repository's Security tab (preferred), or email admin@devicechain.io if you cannot use GitHub.
- The policy sets response targets for acknowledgement, assessment and fixes by severity. They are targets, not guarantees.
- From 1.0.0, security fixes ship for the latest 1.x minor release, and for the previous 1.x minor release for High and Critical issues for 90 days after the next minor ships.
What is not there yet.
Stated in the docs as accepted gaps. Plan around them.
- No external penetration test has been published.
- One database login is shared by all services of an instance, so tenant isolation in the database rests on the application's tenant scope, not on database permissions.
- The instance root key is readable by anyone who can read the instance's Kubernetes Secret, and no external key manager ships yet.
- Two-factor authentication guards the password only. A tenant's requirement binds entry to that tenant, not the operators' admin plane: a superuser with a password-only session can enter such a tenant, and each entry is audited. Someone who holds the password and keeps guessing at the lockout cap has about a 10% chance of getting in over a year, and can keep the owner's authenticator locked.
In the docs: The full list of accepted gaps
Nothing on this page replaces your own review. If an entry here is a problem for your deployment, the matching docs section says where the control sits.