Security
An honest isolation story, stated plainly: this is a platform for your applications, or your customers' applications under your operation, not for anonymous hostile code. celld's own security page says it is not safe for hostile multi-tenant use; the operator's design takes that seriously instead of papering over it.
The isolation model
celld trusts the application code, the fleet nodes, and the operators, so the design assumes the worst case: a V8 isolate escape hands an attacker the entire node process. The operator's answer is fleet-per-app blast-radius containment:
- Each app runs in its own fleet, with its own pods, ServiceAccount, and NetworkPolicy.
- Each fleet holds one bucket credential, scoped to that fleet's prefix
(
…/apps/<app>/) and nothing else. - A full runtime compromise inside one fleet therefore reaches only that app's pods and that app's prefix.
Two limits belong next to that claim. Within a fleet there is no per-cell resource quota:
application code can consume its nodes' shared resources, so a runaway cell starves its
neighbours in the same app. And kernel-level separation needs dedicated nodes: pin
fleets with spec.scheduling.nodeSelector and tolerations.
WorkerApp authors are trusted
Anyone who can create a WorkerApp can run code and reference Secrets in that namespace. The operator does not turn them into untrusted tenants; it limits what they can point a fleet at. Restrict WorkerApp RBAC per namespace, and configure the operator's allowlists:
| Helm value | Default | Effect |
|---|---|---|
operator.allowedImagePrefixes | ["ghcr.io/denoland/celld:"] | Runtime images must start with an allowed prefix and carry a numeric major.minor.patch tag, even when digest-pinned. Add trusted mirrors explicitly. |
operator.allowedIAMRoles | empty | Exact role ARNs a WorkerApp may name in credentialsFrom.iamRole. |
operator.allowedAzureClientIDs | empty | Exact client IDs allowed in credentialsFrom.azureClientID. |
operator.allowedBucketEndpoints | empty | Exact HTTPS endpoints allowed in bucket.endpoint (no credentials, query, or fragment). Empty permits AWS S3 only. |
A WorkerApp outside the allowlists reports SpecValid: False and nothing is
created for it. Image allowlists decide which runtime runs; they do not sandbox the
Worker code it runs.
Pod hardening
Fleet pods run as UID/GID 10001 with a read-only root filesystem, only
/tmp and /var/lib/celld writable, every capability dropped,
privilege escalation disabled, and the RuntimeDefault seccomp profile. No
service-account token is mounted by default, though identity webhooks (IRSA, AKS
workload identity) may inject purpose-specific tokens. Qualify your celld image, CSI
driver permissions, and identity injector against that profile.
The internal listener
celld's internal listener, which the operator pins to :8081, carries the peer
protocol and an alpha operator API whose routes do not authenticate the
caller: /state, /cell/, /evict/, /do/,
POST /reload, and POST /shutdown. /cell/ and
/do/ activate cells and run application code, so reaching the port means
state mutation, not just inspection. Reserved runtime classes (D1, KV, Queues, Workflows)
use the HMAC-authenticated /runtime/<SCOPE> route instead. The operator
fences the port in depth:
- NetworkPolicy: ingress to :8081 only from the fleet's own pods and
from pods labelled
control-plane: controller-managerandapp.kubernetes.io/name: celld-operatorin the operator namespace. - Istio AuthorizationPolicy (when Istio is present): :8081 limited to
the fleet's ServiceAccount principal and the operator's
(
--operator-principal). - Never routed: no ingress mode ever exposes :8081.
Peer tunnels and control requests carry celld's fleet HMAC, a clock limit, and replay
protection, but the calls inside a tunnel are plain HTTP and nothing is encrypted. The
operator neither installs nor requires a mesh; without one it reports
MeshPolicyReady: False. Verify that your CNI enforces NetworkPolicy, and
encrypt the pod network: prefer Istio ambient mode, since a sidecar exiting first would
break the handoff celld performs during termination.
Bucket credentials
The bucket credential is fleet-admin authority. The bucket holds deployments, cell state, ownership and node leases, and the peer-authentication secret; whoever holds the credential controls the fleet. Credential scoping is the tenancy enforcement.
- AWS: prefer
credentialsFrom.iamRole, rendered as the IRSA annotationeks.amazonaws.com/role-arnon the fleet's ServiceAccount, or EKS Pod Identity: associate the generated ServiceAccount outside the WorkerApp and leavecredentialsFromempty. The operator copies the ARN you give it and does not validate its scope. - Azure:
credentialsFrom.azureClientIDwires AKS workload identity (annotated ServiceAccount, labelled pods); the identity needs Storage Blob Data Contributor on the container. A node managed identity needs onlystorageAccount. - Static keys:
credentialsFrom.secretRefinjectsAWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEYorAZURE_STORAGE_ACCOUNT_KEY. Static keys spread; treat them as a fallback. Rotating the Secret rolls the fleet. - Not implemented: GKE Workload Identity wiring, and
iamRole: auto(operator-provisioned roles), which reportsBucketCredentialsReady: Falseand asks you to annotate the ServiceAccount yourself.
Grant put and delete under the prefix (the startup probe writes and removes an object
under probe/). The separate deployTrackingSecretRef for
appVersion: auto should be read-only on deploy/current.json; the
operator never uses its own ambient identity to read a bucket, and reads Secrets
uncached rather than holding them in an informer.
TLS and application auth
- celld terminates no TLS anywhere. Public TLS belongs to the edge; the pod network should be encrypted.
- The deployed Worker owns every public path except
/.well-known/celld/health. Application authentication is the application's job; celld does not authenticate end users. - The
Hostheader, and forwarded headers whentrustForwardedHeadersis on, are client-influenced. Do not make authorization decisions on an unchecked hostname.
Trust boundaries at a glance
| Boundary | Mechanism |
|---|---|
| Internet → Worker | Edge TLS + per-host routing; app-level auth in the Worker |
| Tenant ↔ tenant | Namespaces, NetworkPolicy, per-fleet credentials; node pools via spec.scheduling |
| WorkerApp author → cluster | Namespace RBAC plus operator allowlists for images, identities, and endpoints |
| Anything → operator API (:8081) | NetworkPolicy + AuthorizationPolicy; never routed |
| Node ↔ node | celld HMAC, clock limit, replay protection; encryption from your mesh or CNI |
| Fleet → bucket | One prefix-scoped identity per fleet |
| Operator → fleets | Manager pods selected by label in the operator namespace; narrowed to the operator's principal where Istio enforces |
Support and disclosure
Upstream ships security fixes for the latest celld release only; the operator's support policy mirrors it: current celld, current operator. Report operator vulnerabilities per the repository's SECURITY.md; report celld issues upstream at denoland/celld.