Skip to main content
Preview. This part of the console is still being built. What you see here describes the intended behavior and can change before general availability.

Outpost security model

An outpost runs inside your network, holds credentials to your systems while it works, and runs analyzers against code you did not write. Your security team is right to ask hard questions about it, and should be able to sign off on the answers. This page gives them in the order a review usually takes them, and is plain about the limits.

The answers in one table​

QuestionAnswer
Does anything connect to it?No. It opens no port. Every connection starts from the outpost.
Where does it connect?Your Dwaar console, Dwaar's image registry and results storage, the providers you bind, and the hosts a few analyzers look things up on. See Outbound connections to allow.
What can its own credential do?Take that outpost's jobs and report on them, nothing else. It is not a user and cannot read findings or call Dwaar's API.
Does it store connection credentials?No. It receives a connection's credential for one job at a time and holds it in memory.
What leaves the network?Analyzer results, including the code lines a finding points at and the secrets a secret scanner matched; discovery metadata; status and progress. Not the source or the image layers.
What stays on the host after a scan?Nothing of the scan. Its directory, containers and network are deleted when it ends. The analyzer images and the outpost's credential stay.
What if an analyzer is exploited?It is confined to its own scan's files, its own memory and process limits, and the hosts its task may reach. See the boundary.
Does it run as root?Yes, because it drives Docker. Give it a host of its own.

Nothing connects in​

The outpost opens no port, needs no inbound firewall rule, no load balancer and no public address. Every connection starts from it: HTTPS to Dwaar, to the image registry, to upload results, and to the systems it scans. Dwaar cannot reach into your network through it. The only way Dwaar gives it work is by answering the outpost's own requests for jobs.

The AWS ECS stack's security group has no inbound rule. On your own hosts, the only local traffic the outpost accepts is from its own scan containers on their Docker networks, for the scan's credential and its proxy: leave the host firewall's default of letting Docker's bridges reach the host.

Two credentials of its own, each used once or kept close​

CredentialLifetimeWhat it can do
Enrollment tokenOne use, one hourEnroll one outpost into your tenant. It is shown once, spent on the outpost's first start, and can be cancelled until then.
The outpost's credentialUntil you revoke the outpostCall Dwaar's outpost interface for that one outpost: take its jobs, report progress and results, and fetch the credentials of the jobs it holds. Nothing else.

The outpost's credential is not a user or an API key. It cannot read findings, change settings or call Dwaar's API. Dwaar keeps only a hash of it, never logs it, and limits how often it may call. The outpost keeps it in /var/lib/outpost/outpost.json, readable by root only. Revoking the outpost stops it at once.

An unspent enrollment token is the one thing worth guarding closely: within its hour, it enrolls an outpost into your tenant for whoever holds it. Create tokens only when you deploy. If one is pasted somewhere it should not be, cancel it under Pending enrolments in the Outposts tab. Check that tab for outposts you do not expect.

Connection credentials​

A connection's credential is stored in Dwaar, encrypted, as for any connection. It is handed to the outpost for one job at a time, only while the outpost holds that job's lease, and only once per attempt. The outpost keeps it in memory and never writes it to disk. Every hand over is in the audit log as issueOutpostCredential or issueScanCredential on the connection.

Inside a scan, the analyzers never receive it. Only the container that checks out the source or pulls the image asks for it, through a one use token that works for that scan alone, from a small service the outpost runs on that scan's network. For an AWS connection, the container receives a one hour session for the connection's role, never a long lived key.

An AWS role assumed by the outpost needs no credential at Dwaar at all. Dwaar stores the role's ARN and external id, and the outpost assumes the role with its own identity in your account. That identity needs only sts:AssumeRole on the connections' roles. On the AWS ECS stack, it is the task role, which may assume the roles listed in AssumeRoleArns and nothing else.

What reaches Dwaar​

DataWhy
Every file each analyzer writes as its resultDwaar turns them into findings. A code finding carries the lines it points at. A secret scanner's result carries the secret it matched. A cloud posture result describes your account's configuration.
What discovery listsNames, refs, commit and image digests, and the other metadata a connection on Dwaar would read.
Connection test resultsWhether the credential works, and the preview of what discovery would find.
StatusVersion, protocol, the host's CPUs, memory and free disk, free scan slots, the capacity settings it runs with, and each job's progress, including the image digest each analyzer ran.
The outpost's AWS identityThe ARN of the AWS identity the host's credentials resolve to, so the console can show which role a trust policy must name. Only its name, never a credential.

The source checkout and the image layers do not reach Dwaar. Nor do the outpost's own credential, or the AWS credentials it uses to assume roles.

What to tell a data residency reviewer​

Say it plainly: with an outpost, your source code and container images are processed on a host you control and are not copied to Dwaar. The findings about them are. A finding includes the lines of code it points at, and a found secret includes the secret, because that is what lets you triage it in the console. Those results are stored by Dwaar, as for any scan. If your rule is that no line of this code may leave the network, an outpost alone does not meet it, and you should say so before the review rather than after.

Scan containers are treated as hostile​

A scan runs code chosen by whoever controls what is scanned: a repository's build files, an image's layers, an input crafted to exploit an analyzer. So every scan container is treated as hostile, and the outpost starts each one:

ControlAs implemented
CapabilitiesEvery Linux capability dropped. Without the raw network capability, a container cannot spoof its scan network to read another container's traffic.
Privilege escalationno-new-privileges.
ResourcesThe catalogue's memory and CPU limits, and at most 512 processes.
Root filesystemRead only, with a private /tmp of up to 2 GB. One exception: the code analysis server one of the analyzers talks to keeps a writable root filesystem, with every other control here.
FilesThe source mounted read only for analyzers. Only the scan's own output directory is writable.
NetworkA Docker network of its own scan, with no route out. Analyzers that need no network get none at all.
EgressThrough a proxy the outpost runs for that scan, with a token per container and a list of hosts per task.

The proxy lets each container reach only the hosts its task needs, such as your Git server for the checkout or a package registry for a provenance check. It never connects to the cloud instance metadata service, the ECS task credential endpoint, or loopback and link-local addresses, whatever a name resolves to. A host with a private address, such as your Git server, is reached only when the task's list names that host exactly, never through a wildcard entry like *.example.com. A request for a host that is not on the list is logged as outpost.egress_denied, with the container's task and the host it asked for, never a path. A host that is on the list but resolves to an address the proxy never reaches is logged as outpost.egress_failed, with the reason.

The outpost itself​

The outpost runs as root, because it drives Docker, and the Docker socket is root equivalent whichever way you install it. What it reads from or writes to a scan's directory, it opens without following links, so a container cannot plant a link that makes the outpost read, upload or overwrite a file on the host. Each attempt at a job gets a directory, containers and networks of its own, so two attempts never share files.

The systemd unit runs it with NoNewPrivileges, a read only view of the system except /var/lib/outpost and the Docker socket, no access to home directories, and a private /tmp.

Discovery and tests run in the outpost's own process and may reach private, loopback and link-local addresses and plain HTTP, because reaching your private systems is what an outpost is for. Start it with --allow-private-hosts=false to apply the same guard as Dwaar instead.

On the AWS ECS stack, the instance requires IMDSv2 with one hop, so scan containers cannot reach the instance's role. On your own EC2 instance with the outpost in a container, the instance profile needs a hop limit of 2 for the outpost to reach it; the scan containers still cannot, because their network has no route out and the proxy never connects to link-local addresses.

What stays on the host​

WhatFor how long
Each scan's checkout, image layers and analyzer outputUntil the scan ends, whatever the outcome. A crash leaves them until the outpost's next start, which removes them first.
The analyzer imagesKept, so the next scan does not pull them again. They are Dwaar's images, not your data.
/var/lib/outpost/outpost.jsonUntil you remove it. It holds the outpost's credential and console address.
The outpost's logsAs long as your log rotation keeps them.

What a compromised analyzer could and could not reach​

Say an analyzer is exploited by the repository it scans. Here is the honest boundary.

It couldIt could not
Read the source of the scan it is part of.Read the host's filesystem, the outpost's credential or another scan's directory.
Write anything into that scan's output, which is uploaded to that scan's results.Upload anywhere but that scan's results, or change another scan's.
Reach the hosts on its own task's list.Reach other hosts on your network, the instance metadata service or the outpost's AWS identity.
Use its own memory, CPU and processes, up to its limits.Take the host's memory or processes beyond them.

Outside this boundary sits an escape from the container through a kernel or Docker flaw. Keep the host patched, and give the outpost a host that holds nothing else, the way you would a CI runner.

Builds that run your repository's code​

To find the dependencies of a repository without a lock file, some ecosystems need a real build: Gradle, Bundler, dotnet restore, and Python projects with setup.py. A build runs code from the repository and from every plugin it applies, so treat it as the analyzer the table above assumes was exploited, and run it only on an outpost with a host of its own. On Dwaar's cloud these builds are an Enterprise feature that your administrator requests in Settings › Features. See Dependency resolution and builds.

Images and uploads​

Analyzer images come from Dwaar's registry with a pull token that lasts hours, not days, passed to each pull and never written to a Docker configuration file. The outpost runs each image by its exact digest and reports the digest to Dwaar with the scan's progress. Results go up through upload links that last an hour and are each tied to one file's checksum, under that scan's results only, so nothing but the file the outpost reported can be written.

Try this next​

Give your security team the table at the top of this page, then ask what else runs on the host you picked. If the answer is anything sensitive, move the outpost to a host of its own before you bind a connection to it.