Docker Security

Docker security is the set of practices, controls, and configurations used to protect containers, images, hosts, and the workloads they run.

Containers can expose vulnerabilities, secrets, and attack surfaces if they are not carefully designed and managed.

A container escape is a vulnerability or misconfiguration that allows an attacker to break out of the container isolation boundary.

It prevents a compromised container from affecting the host or other containers.

The host kernel is the Linux kernel running on the Docker host, shared by containers in many setups.

The container attack surface is the set of things an attacker could exploit, such as exposed ports, running processes, network access, and filesystems.

A Docker image is a read-only filesystem snapshot used as the basis for running containers.

Because vulnerable base images and application dependencies can be exploited once a container is running.

A vulnerable dependency is a library, package, or binary that contains a known security flaw.

A CVE (Common Vulnerabilities and Exposures) is a publicly known software vulnerability.

A security scan inspects container images, filesystems, and packages for known vulnerabilities.

Trivy is a common image scanner used to detect vulnerabilities in container images and filesystems.

Anchore is a container image scanning and policy engine used for security validation.

Because vulnerable base images and packages can become the entry point for container compromise.

A minimal image contains only the runtime dependencies necessary to run the application.

They reduce the number of packages and libraries an attacker can exploit.

A distroless image contains only runtime artifacts and not a shell, package manager, or other developer tools.

Because shells can make privilege escalation and post-exploitation easier for attackers.

The root user has full privileges on the system and can perform almost any action.

Because a compromised process running as root can access the full container filesystem and potentially more.

A non-root user has restricted privileges and reduces the blast radius of compromise.

The USER instruction sets the user that will run commands in the container.

Prefer small, minimal, patched images and avoid running as root whenever possible.

Public images may contain malicious content or outdated, vulnerable software if not curated.

Trusted base images are often patched, maintained, and verified more regularly.

A private registry hosts images inside an internal network or organization-controlled environment.

A public registry hosts images publicly, such as Docker Hub.

Image provenance is the record of where the image came from, how it was built, and whether it is trusted.

Image signing allows a system to verify the authenticity and integrity of a container image.

Cosign is a tool for signing and verifying container images using cryptographic signatures.

Sigstore is a project used to sign, verify, and store software artifact signatures securely.

A registry scan checks images pushed into a registry for vulnerabilities and policy violations.

The Docker daemon is the service that manages container runtime and image operations on the host.

Because a compromised daemon can issue malicious container commands and affect the host.

The Docker socket is the Unix socket used by Docker clients to talk to the Docker daemon.

If exposed or misused, it can allow control of the host or other containers.

A process inside a container could potentially use the Docker socket to manage other containers or the host if misconfigured.

It is a bind mount of the Docker socket into a container, often used in CI/CD or dev tools but risky.

Because it effectively gives the container privileged access to Docker daemon operations.

A rootless container runs without requiring root privileges in the host namespace.

It reduces the risk of host-level privilege escalation if the container is compromised.

Namespaces isolate container processes, networks, mounts, and users from the host OS.

cgroups limit CPU, memory, and process usage for containers.

They prevent a compromised app from consuming all host resources and causing denial-of-service.

Seccomp is a Linux kernel security feature that restricts the system calls a process can make.

It reduces the system-call surface available to a compromised container.

AppArmor is a Linux Mandatory Access Control (MAC) system that restricts what applications can do.

SELinux is another MAC system commonly used to enforce containment and policy.

Namespaces isolate visibility; cgroups limit resource use.

Network isolation prevents containers from accessing or reaching unwanted networks or services.

Bridge networks isolate containers on the same host, but they still require firewall or policy rules for strict segmentation.

Network policies restrict traffic between workloads, reducing unintended lateral movement.

A microservice security boundary is the point where one service is isolated from another by network or policy boundaries.

A Docker secret is a secure mechanism to inject sensitive data such as passwords or TLS keys into services in a controlled way.

Environment variables can leak in logs, process lists, or debugging tools, while secrets are handled more securely.

Container secrets are sensitive values stored as files or secret objects and injected at runtime.

Environment variables are values passed to a process, but they may be exposed in process inspection and logs.

Image layers are stored in the image filesystem and can be inspected or extracted later.

A compromised image includes malicious code, backdoors, or unsafe configuration.

A trusted image pipeline includes scanning, signing, and validation before the image reaches production.

A registry vulnerability may let malicious images or tampered content get published or pulled.

Private registries give you control over who can pull and push images and how they are scanned.

Docker Content Trust verifies signed images before the client pulls them.

Image tag trust means trusting the image tag and associated signature, not just the name.

A malicious Dockerfile may add scripts or dependencies that perform unauthorized actions at build or run time.

The Docker build context may expose local secrets or files that get embedded into the image if not filtered with .dockerignore.

.dockerignore excludes files from the Docker build context to avoid leaking secrets or large directories.

Because leaked files may be placed into the image or build cache.

A runtime secret file is mounted into the container for sensitive information such as TLS private keys.

Some workloads, like TLS, expect files rather than environment variables.

A health check asks whether a container is alive and working properly.

Healthy services are less likely to be compromised or in a failed state, and health checks can reduce accidental exposure of broken systems.

Docker logs capture container output, which may include secrets if mishandled.

Because logs may be accessible to operators or centralized monitoring systems beyond the container.

Debugging containers often requires shell access, which can increase risk if the container is not hardened.

Because shell access can help an attacker inspect and manipulate files, secrets, and system state.

The principle of least privilege means giving only the minimum permissions needed for a task.

It reduces the ability of a compromised container or service to do damage.

Resource limits constrain CPU, memory, and PIDs to reduce abuse and denial-of-service opportunities.

A memory limit restricts how much RAM a container can consume.

A CPU limit prevents a container from monopolizing host CPU resources.

A PID limit restricts how many processes a container can create.

Resource limits reduce the impact of runaway or malicious workloads.

--cap-drop removes Linux capabilities from a container to reduce privilege.

Capabilities are fine-grained privileges beyond the traditional root/non-root split.

Because a container may need fewer privileges than a full root process.

A seccomp profile restricts which system calls are allowed.

An AppArmor profile restricts a container to an allowed set of file operations and capabilities.

A read-only root filesystem prevents tampering with the container’s filesystem and helps enforce integrity.

It reduces the chance of malicious writes and makes the filesystem more predictable.

A tmpfs mount keeps temporary data in memory, reducing writes to disk and making state more ephemeral.

A signal sent to a container can terminate processes and affect containers if an attacker can send or abuse them.

A user namespace maps host UIDs to container UIDs and can reduce privilege escalation risk.

A privileged container runs with extra Linux capabilities and has broad access to the host and devices.

Because it weakens isolation and gives the container near-host capabilities.

--cap-add adds Linux capabilities to a container and should be used sparingly.

A breakout is the exploitation of a vulnerability to escape the containment boundary.

A host compromise occurs when an attacker gains access to the underlying Docker host.

Lateral movement is when a compromised container is used to access other containers or host systems.

Unsafe Docker networking exposes more services and routes than necessary; safe networks enforce segmentation and firewalling.

It means separating container workloads into distinct networks and trust zones.

It reduces the chance that a compromised container can reach unrelated services.

A Docker bridge network is a default internal network for containers on the same host.

Because a compromised container on the same network may discover or attack others.

A user-defined network allows better naming, DNS, and isolation than the default bridge.

They help enforce traffic boundaries and manage service discovery more intentionally.

A firewall restricts which network ports or destinations a container may use.

Docker uses iptables rules to implement port publishing and firewalling.

Without it, attackers may probe or reach unintended ports from other containers or external networks.

It is an abstraction in some environments that acts like a firewall policy for container traffic.

The daemon, privileges, and host environment are among the highest-risk parts of the Docker stack.

Because vulnerabilities in the engine, runtime, or kernel can affect the host.

Host hardening includes patching, disabling unnecessary services, setting secure kernel settings, and limiting access.

It remaps container root to an unprivileged user on the host, reducing the privilege of the container.

Rootless Docker avoids root on the host by running the daemon and containers as a non-root user.

It reduces the impact of a compromised runtime process.

Compose can be used to run many containers with broad network access and sharing if not designed carefully.

A threat model identifies who may attack the system, how they might do so, and what controls reduce the risk.

It forces engineers to think systematically about privilege boundaries and threat paths.

It detects vulnerable libraries, packages, or OS-level dependencies in images.

A package manager, such as apt or apk, increases the set of tools an attacker could use if the container is compromised.

Because they can make the image larger and may contain metadata or installed packages not needed by the app.

A multi-stage build can build the app in one stage and ship only the runtime artifact in a separate stage.

They reduce final image size and can eliminate compilers and package managers from the production image.

A signing policy defines which images are trusted, who can sign them, and under which conditions.

It controls what images can be pushed or pulled based on scan results, signatures, or tags.

It prevents insecure or untrusted images from entering a cluster or deployment workflow.

A policy engine evaluates images or runtime manifests against security rules before deployment.

A security baseline is a set of minimum controls, such as no root, no privileged mode, scan passes, and signed images.

It requires containers to run as non-root users whenever possible.

It enforces a writable layer only for needed runtime state, reducing mutable attack surface.

It forbids containers from requesting extra Linux capabilities beyond the minimum required.

It ensures images originate from approved registries, builds, or signing identities.

It reduces the chance of pulling malicious or outdated images from untrusted public registries.

Configuration drift is when the security settings of containers or hosts diverge from approved standards over time.

A hardened baseline includes patched OS, minimum privileges, network restrictions, and limited external exposure.

It helps detect suspicious processes, unauthorized network connections, and unexpected privilege changes.

Docker events report lifecycle changes to containers, images, and networks.

It is the process of investigating a container compromise by looking at filesystem, logs, network, and process state.

It is a tampered or malicious image stored in a registry and pulled by a system without validation.

A secret placed in an image layer may be recoverable by anyone with access to the image.

Because they become part of the image history and may be copied into many environments.

Because they are embedded in image layers and viewable through image history.

Use Docker secrets, mounted volumes, or a secret manager with controlled access.

Use build arguments carefully and never bake secrets directly into the final image unless absolutely required.

The build stage can use secrets during compilation, but they should not remain in the final image.

They may include metadata and dependencies from internal registries or secret-laden build layers.

A shell in the container may retain commands and secrets if used in debugging or build processes.

An attacker can influence dependency resolution or package installation steps to add malicious code.

A reproducible build gives the same output for the same source and environment, reducing attack vectors from nondeterministic builds.

A vulnerability feed is the database or service that provides known issues and patch information.

It may block images with critical or high vulnerabilities before deployment.

A security gate checks the image or artifact before it is allowed to proceed to deployment.

It defines security expectations such as scan results, signed images, and runtime constraints.

Because compromised containers often call home or exfiltrate data to an attacker-controlled endpoint.

It limits the damage a compromised container can do externally.

Egress control restricts outbound network connections from containers.

It protects against malware beaconing, data exfiltration, and command-and-control traffic.

It includes kernel hardening, seccomp, AppArmor, namespaces, user namespaces, and minimal privileges.

Kernel hardening reduces known vulnerabilities and increases the difficulty of exploitation.

It ensures containers do not run with host-root-like privileges or capabilities.

Because if the daemon is compromised, the entire host is at risk.

It includes separate hosts, VMs, or hypervisors for workloads with different trust levels.

It is a level of isolation that prevents unauthorized access across workload boundaries.

It isolates high-risk or high-value systems away from other containers or services.

VMs provide stronger isolation at the hypervisor layer; Docker containers rely more on kernel and process isolation.

To reduce the risk of cross-container or host compromise when high security is required.

It means restricting access to the Docker socket to only trusted users or automation agents.

It enforces policy beyond simple file permissions and reduces the chance of privilege abuse.

Process isolation means one container’s processes are not directly visible to others.

Filesystem isolation keeps each container’s file system separate from the host and other containers.

It limits which destinations a container can reach over the network.

Good observability helps detect suspicious activity, abnormal process launch, or unexpected network access.

It logs actions performed by the Docker daemon and system administrators.

They help reconstruct what happened during a security incident or policy violation.

A service account or service identity is used to grant controlled access to registries or secret stores.

RBAC (Role-Based Access Control) restricts registry access by role and identity.

It is the chain showing where the image came from, who built it, and whether it was signed.

It ensures the image signature matches a trusted identity before it can be deployed.

They prevent untrusted or outdated images from being used in production.

A pod security policy imposes security constraints on workloads, often relevant when Docker is part of a Kubernetes deployment.

A security context configures user ID, capabilities, seccomp, and privilege settings for containers.

Because many container security boundaries ultimately depend on kernel features such as namespaces, seccomp, and cgroups.

A kernel exploit can allow attackers to escape container isolation and access host-level resources.

Because a kernel vulnerability may undermine all container isolation.

It is an exploit that takes advantage of a kernel defect to escape the container and reach the host.

A seccomp bypass is a method to evade Linux seccomp restrictions and perform disallowed actions.

An AppArmor bypass is a policy evasion that allows behavior beyond the intended confinement.

Because single controls alone are not enough; defense-in-depth is essential.

Defense-in-depth uses multiple layers of protection, such as image scanning, privileged restrictions, network segmentation, and runtime monitoring.

Runtime threat detection looks for suspicious process execution, malformed network traffic, or unexpected file changes.

eBPF can inspect system calls, network behavior, and process activity with low overhead for security monitoring.

Container forensics analyzes the container filesystem, process list, logs, and network artifacts after an incident.

Static analysis checks Dockerfile instructions for risky patterns such as insecure base images or unrestricted privileges.

It includes build, scan, sign, promote, deploy, and retire stages, each with security controls.

It ensures only scanned, signed, and compliant images move from dev to staging to production.

Because registries are often the single point where malicious or policy-violating images can be introduced.

Attackers may leave malicious binaries, cron jobs, or scripts in a compromised container to persist beyond the immediate session.

Examples include privileged mode, host networking, Docker socket mounts, and broad host port exposure.

Docker security is not just about the container runtime; it spans image provenance, privilege boundaries, network isolation, secrets handling, registry policy, and host hardening.